use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::Arc;
use super::lxc::SandboxSize;
use super::{docker, Budget, Gpus, HostResources, Limits, Probe, Runtime, RuntimeKind, StartSpec};
use super::{State, GIB};
pub const INSTANCE: &str = "zakuro";
pub const MIN_VERSION: (u32, u32, u32) = (2, 0, 0);
pub const NOT_INSTALLED: &str = "limactl is not installed";
const MIB: u64 = 1024 * 1024;
pub trait LimaCli: Send + Sync {
fn run(&self, argv: &[String]) -> Result<String, String>;
}
pub struct LimaShell {
bin: String,
}
impl LimaShell {
pub fn new() -> Self {
Self {
bin: resolve_binary(
"limactl",
"ZAKURO_LIMACTL",
&|k| std::env::var(k).ok(),
&|p| p.is_file(),
),
}
}
}
pub fn binary() -> String {
LimaShell::new().bin
}
impl Default for LimaShell {
fn default() -> Self {
Self::new()
}
}
impl LimaCli for LimaShell {
fn run(&self, argv: &[String]) -> Result<String, String> {
run_cli(&self.bin, "limactl", NOT_INSTALLED, argv)
}
}
pub(super) fn run_cli(
bin: &str,
name: &str,
not_installed: &str,
argv: &[String],
) -> Result<String, String> {
let rest = argv
.get(1..)
.ok_or_else(|| format!("empty {name} command"))?;
let out = Command::new(bin).args(rest).output().map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
format!("{not_installed} ({e})")
} else {
format!("{name} failed to run: {e}")
}
})?;
if out.status.success() {
Ok(String::from_utf8_lossy(&out.stdout).trim().to_string())
} else {
let err = String::from_utf8_lossy(&out.stderr).trim().to_string();
Err(if err.is_empty() {
String::from_utf8_lossy(&out.stdout).trim().to_string()
} else {
err
})
}
}
pub(super) fn resolve_binary(
name: &str,
var: &str,
get: &dyn Fn(&str) -> Option<String>,
is_file: &dyn Fn(&Path) -> bool,
) -> String {
if let Some(v) = get(var)
.map(|v| v.trim().to_string())
.filter(|v| !v.is_empty())
{
return v;
}
let path = get("PATH").unwrap_or_default();
let dirs = path
.split(':')
.filter(|d| !d.is_empty())
.chain(["/opt/homebrew/bin", "/usr/local/bin"]);
for d in dirs {
let p = Path::new(d).join(name);
if is_file(&p) {
return p.to_string_lossy().into_owned();
}
}
name.to_string()
}
pub(super) fn s(v: &[&str]) -> Vec<String> {
v.iter().map(|a| a.to_string()).collect()
}
#[derive(Debug, Clone)]
pub struct Host {
pub macos: bool,
pub apple_silicon: bool,
pub home: Option<PathBuf>,
pub work_dir: Option<PathBuf>,
}
impl Host {
pub fn detect() -> Self {
Self {
macos: cfg!(target_os = "macos"),
apple_silicon: cfg!(all(target_os = "macos", target_arch = "aarch64")),
home: std::env::var_os("HOME").map(PathBuf::from),
work_dir: crate::credentials::dir(),
}
}
}
pub(super) fn gib_flag(bytes: u64) -> String {
let g = (bytes as f64 / GIB * 100.0).round() / 100.0;
let t = format!("{g:.2}");
t.trim_end_matches('0').trim_end_matches('.').to_string()
}
pub(super) fn vm_cpus(l: &Limits) -> u32 {
l.cpu_millis.div_ceil(1000).max(1)
}
pub(super) fn vm_disk_gib(size: &SandboxSize) -> u64 {
size.disk_bytes.div_ceil(1024 * 1024 * 1024).max(1)
}
pub fn create_argv(instance: &str, size: &SandboxSize, host: &Host) -> Vec<String> {
let mut a = s(&[
"limactl",
"create",
"--tty=false",
"--name",
instance,
"--vm-type",
"vz",
]);
if host.apple_silicon {
a.push("--rosetta".into());
}
a.extend(s(&["--cpus", &vm_cpus(&size.limits).to_string()]));
a.extend(s(&["--memory", &gib_flag(size.limits.memory_bytes)]));
a.extend(s(&["--disk", &vm_disk_gib(size).to_string()]));
a.extend(s(&["--containerd", "system"]));
a.extend(s(&["--mount-type", "virtiofs"]));
if let Some(w) = &host.work_dir {
a.push("--mount-only".into());
a.push(format!("{}:w", w.display()));
} else {
a.push("--mount-none".into());
}
a
}
pub fn edit_argv(instance: &str, size: &SandboxSize, grow_disk: bool) -> Vec<String> {
let mut a = s(&["limactl", "edit", "--tty=false"]);
a.extend(s(&["--cpus", &vm_cpus(&size.limits).to_string()]));
a.extend(s(&["--memory", &gib_flag(size.limits.memory_bytes)]));
if grow_disk {
a.extend(s(&["--disk", &vm_disk_gib(size).to_string()]));
}
a.push(instance.to_string());
a
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Info {
pub name: String,
pub status: String,
pub vm_type: String,
pub cpus: u32,
pub memory_bytes: u64,
pub disk_bytes: u64,
pub mounts: Vec<(String, bool)>,
}
pub fn parse_list(out: &str) -> Vec<Info> {
let one = |v: &serde_json::Value| -> Option<Info> {
let mounts = v["config"]["mounts"]
.as_array()
.map(|m| {
m.iter()
.filter_map(|m| {
Some((
m["location"].as_str()?.to_string(),
m["writable"].as_bool().unwrap_or(false),
))
})
.collect()
})
.unwrap_or_default();
Some(Info {
name: v["name"].as_str()?.to_string(),
status: v["status"].as_str().unwrap_or("").to_string(),
vm_type: v["vmType"].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),
mounts,
})
};
let t = out.trim();
if t.starts_with('[') {
if let Ok(serde_json::Value::Array(a)) = serde_json::from_str(t) {
return a.iter().filter_map(one).collect();
}
}
t.lines()
.filter_map(|l| serde_json::from_str::<serde_json::Value>(l.trim()).ok())
.filter_map(|v| one(&v))
.collect()
}
pub(super) fn writable_home_mount(mounts: &[(String, bool)], home: &Path) -> Option<String> {
mounts
.iter()
.find(|(loc, w)| *w && home.starts_with(loc.trim_end_matches('/').max("/")))
.map(|(loc, _)| loc.clone())
}
pub fn parse_version(out: &str) -> Option<(u32, u32, u32)> {
let v = out.split_whitespace().last()?.trim_start_matches('v');
let core = v.split(['-', '+']).next()?;
let mut p = core.split('.').map(|n| n.parse::<u32>());
Some((
p.next()?.ok()?,
p.next()?.ok()?,
p.next().unwrap_or(Ok(0)).ok()?,
))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Drift {
pub cpu_or_memory: bool,
pub disk_grows: bool,
}
impl Drift {
pub fn any(&self) -> bool {
self.cpu_or_memory || self.disk_grows
}
}
pub(super) fn drift(cpus: u32, memory_bytes: u64, disk_bytes: u64, size: &SandboxSize) -> Drift {
Drift {
cpu_or_memory: cpus != vm_cpus(&size.limits)
|| memory_bytes / MIB != size.limits.memory_bytes / MIB,
disk_grows: disk_bytes < vm_disk_gib(size) * 1024 * MIB,
}
}
pub(super) fn map_mounts(
work_dir: Option<&Path>,
mounts: &[(String, String)],
) -> Result<Vec<(String, String)>, String> {
mounts
.iter()
.map(|(host, ctr)| {
let w = work_dir.ok_or("no zakuro work directory to share into the VM")?;
let p = Path::new(host);
let escapes = p
.components()
.any(|c| matches!(c, std::path::Component::ParentDir));
if escapes || !p.starts_with(w) {
return Err(format!(
"mount {host:?} is outside the zakuro work directory {}: the VM \
shares only that directory (never the home)",
w.display()
));
}
Ok((host.clone(), ctr.clone()))
})
.collect()
}
pub(super) fn refuse_gpu(backend: &str, spec: &StartSpec) -> Result<(), String> {
if spec.limits.gpus.flag_value().is_some() {
return Err(format!(
"{} asks for a GPU, which the {backend} backend cannot give: there is no GPU \
passthrough to a Linux VM on macOS",
spec.name
));
}
Ok(())
}
pub(super) fn check_publish(backend: &str, publish: &[String]) -> Result<(), String> {
for spec in publish {
let p = super::lxc::parse_publish(spec)
.map_err(|e| e.replace("the lxc backend", &format!("the {backend} backend")))?;
if p.host.is_none() {
return Err(format!(
"publish {spec:?}: the {backend} backend needs a fixed host port"
));
}
}
Ok(())
}
pub fn egress_script() -> String {
"set -e; C=${1:-10.4.0.0/16}; \
iptables -N ZAKURO-EGRESS 2>/dev/null || true; iptables -F ZAKURO-EGRESS; \
iptables -A ZAKURO-EGRESS -m conntrack --ctstate ESTABLISHED,RELATED -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; \
iptables -A ZAKURO-EGRESS -d $C -j RETURN; \
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; \
iptables -N CNI-ADMIN 2>/dev/null || true; \
iptables -C CNI-ADMIN -s $C -j ZAKURO-EGRESS 2>/dev/null || iptables -A CNI-ADMIN -s $C -j ZAKURO-EGRESS; \
iptables -C FORWARD -s $C -j ZAKURO-EGRESS 2>/dev/null || iptables -I FORWARD 1 -s $C -j ZAKURO-EGRESS; \
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 $C -j RETURN; \
iptables -A ZAKURO-IN -m addrtype --dst-type LOCAL -j REJECT; \
iptables -C INPUT -s $C -j ZAKURO-IN 2>/dev/null || iptables -I INPUT 1 -s $C -j ZAKURO-IN"
.to_string()
}
static ENSURE_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
pub(super) fn owned_name(name: &str, what: &str) -> Result<(), String> {
if name.trim().is_empty() || name == "default" {
return Err(format!(
"refusing to use the {what} {name:?}: zc owns its own VM and never uses one the \
owner uses (set ZAKURO_LIMA_INSTANCE / ZAKURO_COLIMA_PROFILE to another name)"
));
}
Ok(())
}
#[derive(Clone)]
pub struct LimaRuntime {
cli: Arc<dyn LimaCli>,
instance: String,
size: Result<SandboxSize, String>,
host: Host,
mkdir: fn(&std::path::Path) -> std::io::Result<()>,
}
impl LimaRuntime {
pub fn new(
cli: Arc<dyn LimaCli>,
instance: &str,
size: Result<SandboxSize, String>,
host: Host,
) -> Self {
Self {
cli,
instance: instance.to_string(),
size,
host,
mkdir: |p| std::fs::create_dir_all(p),
}
}
#[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 LimaCli>, get: &dyn Fn(&str) -> Option<String>) -> Self {
let instance = get("ZAKURO_LIMA_INSTANCE")
.map(|v| v.trim().to_string())
.filter(|v| !v.is_empty())
.unwrap_or_else(|| INSTANCE.to_string());
let size = Budget::from_env(get)
.and_then(|b| SandboxSize::from_budget(&b, &HostResources::detect()));
Self::new(cli, &instance, size, Host::detect())
}
pub fn shell() -> Self {
Self::from_env(Arc::new(LimaShell::new()), &|k| std::env::var(k).ok())
}
pub fn instance(&self) -> &str {
&self.instance
}
fn lima(&self, rest: &[&str]) -> Result<String, String> {
let mut argv = vec!["limactl".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(&["limactl", "shell", "--workdir", "/", &self.instance, "--"]);
a.extend(s(&["sudo", "nerdctl"]));
let rest = match docker_argv.first().map(String::as_str) {
Some("docker") => &docker_argv[1..],
_ => docker_argv,
};
a.extend(rest.iter().cloned());
a
}
fn nerdctl(&self, docker_argv: &[String]) -> Result<String, String> {
self.cli.run(&self.in_vm(docker_argv))
}
fn emulated_platform(&self, image: &str) -> Option<&'static str> {
if !self.host.apple_silicon {
return None;
}
let arch = self
.nerdctl(&s(&[
"docker",
"image",
"inspect",
"--format",
"{{.Architecture}}",
image,
]))
.ok()?;
arch.trim()
.is_empty()
.then_some(crate::up::EMULATED_PLATFORM)
}
pub fn info(&self) -> Result<Option<Info>, String> {
let out = self.lima(&["list", "--json"])?;
Ok(parse_list(&out)
.into_iter()
.find(|i| i.name == self.instance))
}
fn running(&self, info: &Info) -> bool {
info.status.eq_ignore_ascii_case("Running")
}
fn adoption_problem(&self, info: &Info) -> Option<String> {
if !info.vm_type.is_empty() && info.vm_type != "vz" {
return Some(format!(
"{} is a {} VM, not Apple Virtualization (vz); delete it \
(`limactl delete {}`) and zc recreates it",
self.instance, info.vm_type, self.instance
));
}
let home = self.host.home.as_deref()?;
writable_home_mount(&info.mounts, home).map(|m| {
format!(
"{} mounts {m} writable, which gives the VM the owner's home; refusing to \
adopt it (delete it with `limactl delete {}` and zc recreates it with only \
the zakuro work directory)",
self.instance, self.instance
)
})
}
pub fn resize_pending(&self) -> Result<bool, String> {
let size = self.size.clone()?;
Ok(match self.info()? {
Some(i) => drift(i.cpus, i.memory_bytes, i.disk_bytes, &size).any(),
None => false,
})
}
pub fn ensure(&self) -> Result<(), String> {
let _g = ENSURE_LOCK.lock().unwrap_or_else(|p| p.into_inner());
owned_name(&self.instance, "Lima instance")?;
if !self.host.macos {
return Err("the lima backend runs on macOS only".into());
}
let size = self.size.clone()?;
let inst = self.instance.as_str();
match self.info()? {
None => {
if let Some(w) = &self.host.work_dir {
(self.mkdir)(w).map_err(|e| format!("cannot create {}: {e}", w.display()))?;
}
self.cli
.run(&create_argv(inst, &size, &self.host))
.map_err(|e| format!("limactl create {inst} failed: {e}"))?;
self.start_vm()?;
}
Some(info) => {
if let Some(p) = self.adoption_problem(&info) {
return Err(p);
}
let d = drift(info.cpus, info.memory_bytes, info.disk_bytes, &size);
if self.running(&info) {
if d.any() && self.is_idle()? {
self.lima(&["stop", inst])?;
self.cli.run(&edit_argv(inst, &size, d.disk_grows))?;
self.start_vm()?;
}
} else if info.status.eq_ignore_ascii_case("Stopped") {
if d.any() {
self.cli.run(&edit_argv(inst, &size, d.disk_grows))?;
}
self.start_vm()?;
} else {
return Err(format!(
"{inst} is {} (not Running or Stopped); `limactl delete -f {inst}` and \
zc recreates it",
info.status
));
}
}
}
self.cli
.run(&self.in_vm_root(&["sh", "-c", &egress_script(), "zakuro-egress"]))
.map_err(|e| format!("applying the guest firewall in {inst} failed: {e}"))?;
self.cli
.run(&self.in_vm_root(&["nerdctl", "version"]))
.map_err(|e| format!("containerd/nerdctl is not ready in {inst}: {e}"))?;
Ok(())
}
fn in_vm_root(&self, argv: &[&str]) -> Vec<String> {
let mut a = s(&[
"limactl",
"shell",
"--workdir",
"/",
&self.instance,
"--",
"sudo",
]);
a.extend(argv.iter().map(|x| x.to_string()));
a
}
fn start_vm(&self) -> Result<(), String> {
self.lima(&["start", "--tty=false", "--timeout", "15m", &self.instance])
.map(|_| ())
.map_err(|e| format!("limactl start {} failed: {e}", self.instance))
}
fn is_idle(&self) -> Result<bool, String> {
Ok(self.nerdctl(&s(&["ps", "-q"]))?.trim().is_empty())
}
}
impl Runtime for LimaRuntime {
fn kind(&self) -> RuntimeKind {
RuntimeKind::Lima
}
fn probe(&self) -> Probe {
let no = |detail: String| Probe {
kind: RuntimeKind::Lima,
available: false,
detail,
};
if !self.host.macos {
return no("macOS only".into());
}
if let Err(e) = owned_name(&self.instance, "Lima instance") {
return no(e);
}
let out = match self.lima(&["--version"]) {
Ok(v) => v,
Err(e) if e.starts_with(NOT_INSTALLED) => {
return no(format!(
"{NOT_INSTALLED} (brew install lima, or set ZAKURO_LIMACTL)"
))
}
Err(e) => {
return no(e
.lines()
.next()
.unwrap_or("limactl --version failed")
.into())
}
};
let Some(v) = parse_version(&out) else {
return no(format!("cannot read the limactl version from {out:?}"));
};
if v < MIN_VERSION {
return no(format!(
"limactl {}.{}.{} is too old: zc needs {}.{}.{} or newer (brew upgrade lima)",
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("limactl list failed").into()),
Ok(None) => "not created yet (created at the first start)".to_string(),
Ok(Some(i)) => {
if let Some(p) = self.adoption_problem(&i) {
return no(p);
}
format!(
"{} ({} cpu, {:.1} GiB memory)",
i.status.to_lowercase(),
i.cpus,
i.memory_bytes as f64 / GIB
)
}
};
Probe {
kind: RuntimeKind::Lima,
available: true,
detail: format!(
"limactl {}.{}.{}, vz VM {} {vm}",
v.0, v.1, v.2, self.instance
),
}
}
fn verify_image(&self, image: &str, expected_digest: Option<&str>) -> Result<(), String> {
let out = self
.nerdctl(&s(&[
"docker",
"image",
"inspect",
"--format",
"{{.Id}}|{{json .RepoDigests}}",
image,
]))
.map_err(|e| format!("image {image} is not in {}: {e}", self.instance))?;
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("lima", spec)?;
check_publish("lima", &spec.publish)?;
let mounts = map_mounts(self.host.work_dir.as_deref(), &spec.mounts)?;
self.ensure()?;
let mut inner = spec.clone();
inner.mounts = mounts;
let size = self.size.clone()?;
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: Gpus::None,
};
inner.remove_on_exit = false;
if spec.create_network {
if let Some(net) = &spec.network {
let _ = self.nerdctl(&s(&["docker", "network", "create", net]));
}
}
let mut run = vec!["docker".to_string()];
run.extend(docker::run_argv(&inner));
if let Some(p) = self.emulated_platform(&spec.image) {
run.splice(2..2, s(&["--platform", p]));
}
self.nerdctl(&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.nerdctl(&full)
}
fn stop(&self, name: &str) -> Result<(), String> {
match self.info()? {
Some(i) if self.running(&i) => {}
_ => return Ok(()),
}
match self.nerdctl(&crate::up::docker_rm_argv(name)) {
Ok(_) => Ok(()),
Err(e) if e.contains("no such container") || e.contains("no such object") => Ok(()),
Err(e) => Err(e),
}
}
fn limits(&self, name: &str) -> Result<Limits, String> {
super::lxc::parse_cgroup_limits(&self.nerdctl(&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.nerdctl(&crate::up::docker_state_argv(name))?;
crate::up::parse_container_state(&out)
.ok_or_else(|| format!("unexpected nerdctl inspect output: {out:?}"))
}
fn allocations(&self) -> Result<Vec<super::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.nerdctl(&argv)?))
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Mutex;
#[derive(Default)]
struct Rec {
calls: Mutex<Vec<String>>,
answer: Mutex<Vec<(&'static str, Result<String, 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()
}
}
impl LimaCli 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 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>) -> LimaRuntime {
LimaRuntime::new(rec.clone(), INSTANCE, Ok(size()), host()).with_mkdir(|_| Ok(()))
}
fn spec() -> StartSpec {
StartSpec {
name: "zc-share-w0".into(),
image: "img".into(),
network: Some("net".into()),
create_network: true,
labels: vec![],
mounts: vec![("/Users/jo/.zakuro/work".into(), "/work".into())],
publish: vec!["127.0.0.1:3960:3960".into()],
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, mounts: &str) -> String {
format!(
r#"{{"name":"zakuro","status":"{status}","vmType":"vz","cpus":{cpus},"memory":{},"disk":{},"config":{{"mounts":{mounts}}}}}"#,
mem_gib * 1024 * MIB,
disk_gib * 1024 * MIB
)
}
const WORK_MOUNT: &str = r#"[{"location":"/Users/jo/.zakuro","writable":true}]"#;
#[test]
fn create_argv_sizes_the_vm_from_the_budget_and_mounts_only_the_work_dir() {
let a = create_argv(INSTANCE, &size(), &host()).join(" ");
assert_eq!(
a,
"limactl create --tty=false --name zakuro --vm-type vz --rosetta --cpus 2 \
--memory 2 --disk 10 --containerd system --mount-type virtiofs \
--mount-only /Users/jo/.zakuro:w"
);
let mut intel = host();
intel.apple_silicon = false;
assert!(!create_argv(INSTANCE, &size(), &intel).contains(&"--rosetta".to_string()));
let mut none = host();
none.work_dir = None;
let a = create_argv(INSTANCE, &size(), &none);
assert!(a.contains(&"--mount-none".to_string()), "{a:?}");
assert!(!a.iter().any(|x| x.contains("/Users/jo")), "{a:?}");
}
#[test]
fn edit_argv_grows_the_disk_only_when_asked() {
assert_eq!(
edit_argv(INSTANCE, &size(), false).join(" "),
"limactl edit --tty=false --cpus 2 --memory 2 zakuro"
);
assert!(edit_argv(INSTANCE, &size(), true)
.join(" ")
.contains("--disk 10 zakuro"));
}
#[test]
fn gib_and_version_parsing() {
assert_eq!(gib_flag(2 * 1024 * MIB), "2");
assert_eq!(gib_flag(1536 * MIB), "1.5");
assert_eq!(gib_flag(256 * MIB), "0.25");
assert_eq!(parse_version("limactl version 2.2.1"), Some((2, 2, 1)));
assert_eq!(
parse_version("limactl version 2.0.0-beta.1"),
Some((2, 0, 0))
);
assert_eq!(parse_version("limactl version v1.2"), Some((1, 2, 0)));
assert_eq!(parse_version("nonsense"), None);
}
#[test]
fn list_output_is_parsed_from_ndjson_and_arrays() {
let one = list_line("Running", 2, 2, 10, WORK_MOUNT);
let nd = format!("{{\"name\":\"other\",\"status\":\"Stopped\"}}\n{one}\n");
let got = parse_list(&nd);
assert_eq!(got.len(), 2);
assert_eq!(got[1].cpus, 2);
assert_eq!(got[1].mounts, vec![("/Users/jo/.zakuro".to_string(), true)]);
assert_eq!(parse_list(&format!("[{one}]")).len(), 1);
assert!(parse_list("").is_empty());
}
#[test]
fn binary_resolution_prefers_the_override_then_path_then_homebrew() {
let get = |k: &str| match k {
"ZAKURO_LIMACTL" => Some(" /x/limactl ".to_string()),
"PATH" => Some("/usr/bin:/bin".to_string()),
_ => None,
};
assert_eq!(
resolve_binary("limactl", "ZAKURO_LIMACTL", &get, &|_| false),
"/x/limactl"
);
let get = |k: &str| (k == "PATH").then(|| "/usr/bin:/bin".to_string());
assert_eq!(
resolve_binary("limactl", "ZAKURO_LIMACTL", &get, &|p| p
== Path::new("/opt/homebrew/bin/limactl")),
"/opt/homebrew/bin/limactl"
);
assert_eq!(
resolve_binary("limactl", "ZAKURO_LIMACTL", &get, &|_| false),
"limactl"
);
}
#[test]
fn a_missing_instance_is_created_started_and_firewalled() {
let d = Arc::new(Rec::default());
rt(&d).ensure().unwrap();
let calls = d.calls();
assert_eq!(calls[0], "limactl list --json");
assert!(calls[1].starts_with("limactl create --tty=false --name zakuro --vm-type vz"));
assert_eq!(calls[2], "limactl start --tty=false --timeout 15m zakuro");
assert!(
calls[3].starts_with("limactl shell --workdir / zakuro -- sudo sh -c set -e;"),
"{}",
calls[3]
);
assert!(calls[3].contains("ZAKURO-EGRESS"), "{}", calls[3]);
assert_eq!(
calls[4],
"limactl shell --workdir / zakuro -- sudo nerdctl version"
);
}
#[test]
fn an_existing_matching_instance_is_adopted_untouched() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 2, 2, 10, WORK_MOUNT)),
);
rt(&d).ensure().unwrap();
let calls = d.calls();
assert!(
!calls.iter().any(|c| c.contains("create")
|| c.contains("edit")
|| c.contains("limactl stop")
|| c.contains("limactl start")),
"{calls:#?}"
);
}
#[test]
fn a_stopped_instance_is_started_and_resized_first_when_the_budget_changed() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Stopped", 1, 1, 5, WORK_MOUNT)),
);
rt(&d).ensure().unwrap();
let calls = d.calls();
assert_eq!(
calls[1],
"limactl edit --tty=false --cpus 2 --memory 2 --disk 10 zakuro"
);
assert_eq!(calls[2], "limactl start --tty=false --timeout 15m zakuro");
}
#[test]
fn a_running_idle_instance_is_stopped_resized_and_restarted() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 4, 8, 10, WORK_MOUNT)),
);
d.on("nerdctl ps -q", Ok(""));
rt(&d).ensure().unwrap();
let calls = d.calls();
let at = |p: &str| calls.iter().position(|c| c.starts_with(p)).unwrap();
assert!(at("limactl stop zakuro") < at("limactl edit"));
assert!(at("limactl edit") < at("limactl start"));
assert!(!calls[at("limactl edit")].contains("--disk"));
}
#[test]
fn a_busy_instance_is_not_resized_and_says_a_resize_is_pending() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 4, 8, 10, WORK_MOUNT)),
);
d.on("nerdctl ps -q", Ok("abc123"));
let r = rt(&d);
r.ensure().unwrap();
assert!(
!d.calls().iter().any(|c| c.contains("limactl stop")),
"{:#?}",
d.calls()
);
assert!(r.resize_pending().unwrap());
}
#[test]
fn an_instance_mounting_the_home_writable_is_refused() {
for loc in ["/Users/jo", "/Users", "/"] {
let d = Arc::new(Rec::default());
let m = format!(r#"[{{"location":"{loc}","writable":true}}]"#);
d.on("list --json", Ok(&list_line("Running", 2, 2, 10, &m)));
let e = rt(&d).ensure().unwrap_err();
assert!(e.contains("owner's home"), "{loc}: {e}");
assert!(
!d.calls().iter().any(|c| c.contains("shell")),
"nothing runs in a refused VM"
);
let p = rt(&d).probe();
assert!(!p.available, "{loc}: {}", p.detail);
}
let d = Arc::new(Rec::default());
let m = r#"[{"location":"/Users/jo","writable":false}]"#;
d.on("list --json", Ok(&list_line("Running", 2, 2, 10, m)));
assert!(rt(&d).ensure().is_ok());
}
#[test]
fn a_non_vz_instance_is_refused() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(r#"{"name":"zakuro","status":"Running","vmType":"qemu"}"#),
);
assert!(rt(&d)
.ensure()
.unwrap_err()
.contains("not Apple Virtualization"));
}
#[test]
fn the_owners_default_instance_is_never_used() {
let d = Arc::new(Rec::default());
let r = LimaRuntime::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("create")));
}
#[test]
fn a_gpu_request_is_refused_before_anything_runs() {
let d = Arc::new(Rec::default());
let mut sp = spec();
sp.limits = Limits::new(0.5, 1.0, Gpus::All);
let e = rt(&d).start(&sp).unwrap_err();
assert!(e.contains("no GPU passthrough"), "{e}");
assert!(d.calls().is_empty(), "{:?}", d.calls());
}
#[test]
fn start_runs_nerdctl_in_the_vm_with_the_workloads_own_limits() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 2, 2, 10, WORK_MOUNT)),
);
d.on("image inspect", Ok("arm64"));
d.on("nerdctl run", Ok("cid42"));
let id = rt(&d).start(&spec()).unwrap();
assert_eq!(id, "cid42");
let calls = d.calls();
let run = calls.iter().find(|c| c.contains("nerdctl run")).unwrap();
assert!(
run.starts_with(
"limactl shell --workdir / zakuro -- sudo nerdctl run -d --name zc-share-w0"
),
"{run}"
);
assert!(!run.contains("--rm"), "{run}");
assert!(
run.contains("--cpus 0.5 --memory 1024m --memory-swap 1024m"),
"{run}"
);
assert!(run.contains("-v /Users/jo/.zakuro/work:/work"), "{run}");
assert!(run.contains("-p 127.0.0.1:3960:3960"), "{run}");
assert!(calls
.iter()
.any(|c| c.contains("nerdctl network create net")));
}
#[test]
fn an_amd64_only_image_runs_as_linux_amd64_on_apple_silicon() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 2, 2, 10, WORK_MOUNT)),
);
d.on("image inspect", Ok("\n"));
rt(&d).start(&spec()).unwrap();
let run = d
.calls()
.into_iter()
.find(|c| c.contains("nerdctl run"))
.unwrap();
assert!(
run.contains("sudo nerdctl run --platform linux/amd64 -d --name zc-share-w0"),
"{run}"
);
assert!(run.ends_with(" img"), "{run}");
}
#[test]
fn a_native_missing_or_non_apple_silicon_image_gets_no_platform() {
for (arch, apple) in [
(Ok("arm64"), true),
(Err("no such image"), true),
(Ok(""), false),
] {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 2, 2, 10, WORK_MOUNT)),
);
d.on("image inspect", arch);
let mut h = host();
h.apple_silicon = apple;
LimaRuntime::new(d.clone(), INSTANCE, Ok(size()), h)
.with_mkdir(|_| Ok(()))
.start(&spec())
.unwrap();
let run = d
.calls()
.into_iter()
.find(|c| c.contains("nerdctl run"))
.unwrap();
assert!(!run.contains("--platform"), "{arch:?} {apple}: {run}");
}
}
#[test]
fn a_workload_is_clamped_to_the_vm_and_mounts_outside_the_work_dir_are_refused() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 2, 2, 10, WORK_MOUNT)),
);
let mut sp = spec();
sp.limits = Limits::new(8.0, 64.0, Gpus::None);
rt(&d).start(&sp).unwrap();
let run = d
.calls()
.into_iter()
.find(|c| c.contains("nerdctl run"))
.unwrap();
assert!(run.contains("--cpus 1.5 --memory 2048m"), "{run}");
for bad in ["/Users/jo", "/Users/jo/.zakuro/../.ssh", "/etc"] {
let d = Arc::new(Rec::default());
let mut sp = spec();
sp.mounts = vec![(bad.into(), "/x".into())];
let e = rt(&d).start(&sp).unwrap_err();
assert!(
e.contains("outside the zakuro work directory"),
"{bad}: {e}"
);
assert!(d.calls().is_empty());
}
}
#[test]
fn publish_needs_a_fixed_host_port_and_tcp_or_udp() {
let d = Arc::new(Rec::default());
let mut sp = spec();
sp.publish = vec!["127.0.0.1::8888".into()];
assert!(rt(&d).start(&sp).unwrap_err().contains("fixed host port"));
sp.publish = vec!["3960:3960/sctp".into()];
assert!(rt(&d).start(&sp).unwrap_err().contains("lima backend"));
}
#[test]
fn limits_are_read_back_from_the_workloads_cgroup() {
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, 500);
assert_eq!(l.memory_bytes, 1073741824);
assert_eq!(l.gpus, Gpus::None);
let d = Arc::new(Rec::default());
d.on("exec", Ok("max 100000\n1073741824\n0"));
assert!(rt(&d)
.limits("w")
.unwrap_err()
.contains("without a cpu limit"));
}
#[test]
fn stop_and_allocations_skip_a_vm_that_is_not_running() {
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Stopped", 2, 2, 10, WORK_MOUNT)),
);
rt(&d).stop("w").unwrap();
assert!(rt(&d).allocations().unwrap().is_empty());
assert!(!d.calls().iter().any(|c| c.contains("shell")));
let d = Arc::new(Rec::default());
d.on(
"list --json",
Ok(&list_line("Running", 2, 2, 10, WORK_MOUNT)),
);
d.on("rm -f", Err("Error: no such container: w"));
rt(&d).stop("w").unwrap();
d.on("nerdctl ps --filter", Ok("w|500m,1073741824"));
let a = rt(&d).allocations().unwrap();
assert_eq!(a.len(), 1);
assert_eq!(a[0].cpu_millis, 500);
}
#[test]
fn verify_image_checks_the_exact_digest_in_the_vm() {
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", None).is_ok());
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_precisely_why_it_is_unavailable() {
let d = Arc::new(Rec::default());
d.on("--version", Err("limactl is not installed (No such file)"));
let p = rt(&d).probe();
assert!(!p.available);
assert!(p.detail.contains("brew install lima"), "{}", p.detail);
let d = Arc::new(Rec::default());
d.on("--version", Ok("limactl version 1.2.0"));
assert!(rt(&d).probe().detail.contains("too old"));
let mut h = host();
h.macos = false;
let r = LimaRuntime::new(Arc::new(Rec::default()), INSTANCE, Ok(size()), h);
assert_eq!(r.probe().detail, "macOS only");
let d = Arc::new(Rec::default());
d.on("--version", Ok("limactl version 2.2.1"));
let p = rt(&d).probe();
assert!(p.available, "{}", p.detail);
assert!(p.detail.contains("not created yet"), "{}", p.detail);
d.on(
"list --json",
Ok(&list_line("Running", 2, 2, 10, WORK_MOUNT)),
);
let p = rt(&d).probe();
assert!(
p.detail.contains("running (2 cpu, 2.0 GiB memory)"),
"{}",
p.detail
);
}
#[test]
fn the_egress_script_blocks_the_lan_and_keeps_dns_and_the_internet() {
let s = egress_script();
for r in [
"10.0.0.0/8",
"172.16.0.0/12",
"192.168.0.0/16",
"169.254.0.0/16",
] {
assert!(s.contains(r), "{r}");
}
let dns = s.find("--dport 53").unwrap();
let ctr = s.find("-d $C -j RETURN").unwrap();
let rej = s.find("-j REJECT").unwrap();
assert!(dns < rej && ctr < rej);
assert!(s.contains("ESTABLISHED,RELATED"));
assert!(s.contains("-A CNI-ADMIN -s $C -j ZAKURO-EGRESS"));
assert!(s.contains("iptables -F ZAKURO-EGRESS"), "idempotent refill");
}
struct Cleanup(String);
impl Drop for Cleanup {
fn drop(&mut self) {
let _ = Command::new(LimaShell::new().bin.clone())
.args(["delete", "-f", &self.0])
.output();
eprintln!("[real-lima] deleted instance {}", self.0);
}
}
#[test]
#[ignore]
fn real_lima_vm_runs_a_limited_container_and_blocks_the_host() {
if std::env::var("ZAKURO_TEST_REAL_LIMA").as_deref() != Ok("1") {
return;
}
let name = format!("zctest-{}", std::process::id());
assert!(name != "zakuro" && name != "default");
let cli: Arc<dyn LimaCli> = Arc::new(LimaShell::new());
let before = cli.run(&s(&[
"limactl",
"list",
"--format",
"{{.Name}} {{.Status}}",
]));
eprintln!("[real-lima] existing instances (untouched): {before:?}");
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 = LimaRuntime::new(cli.clone(), &name, Ok(size), h);
eprintln!("[real-lima] 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-lima] started container {id}");
eprintln!("[real-lima] probe after: {:?}", r.probe());
let l = r.limits("zctest-w0").expect("limits");
eprintln!("[real-lima] 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-lima] 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(&[
"limactl",
"shell",
"--workdir",
"/",
&name,
"--",
"sh",
"-c",
cmd,
]))
};
let gw = guest("getent hosts host.lima.internal | cut -d' ' -f1").unwrap();
eprintln!("[real-lima] host gateway in the guest: {gw}");
eprintln!(
"[real-lima] guest rules: {:?}",
cli.run(&s(&[
"limactl",
"shell",
"--workdir",
"/",
&name,
"--",
"sudo",
"sh",
"-c",
"iptables -S FORWARD; iptables -S ZAKURO-EGRESS; ip -4 addr | grep inet"
]))
);
let base = guest(&format!(
"timeout 3 bash -c 'echo > /dev/tcp/{gw}/{port}' && echo reachable"
));
eprintln!("[real-lima] guest -> mac listener (baseline): {base:?}");
let ctr = r.exec(
"zctest-w0",
&s(&[
"sh",
"-c",
&format!("nc -z -w 3 {gw} {port} && echo reachable || echo blocked"),
]),
false,
);
eprintln!("[real-lima] container -> mac listener: {ctr:?}");
let net = r.exec(
"zctest-w0",
&s(&[
"sh",
"-c",
"nc -z -w 5 1.1.1.1 443 && echo internet-ok || echo internet-blocked",
]),
false,
);
eprintln!("[real-lima] container -> 1.1.1.1:443: {net:?}");
let dns = r.exec(
"zctest-w0",
&s(&[
"sh",
"-c",
"nslookup example.com >/dev/null 2>&1 && echo dns-ok || echo dns-failed",
]),
false,
);
eprintln!("[real-lima] 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-lima] stopped; allocations now {:?}",
r.allocations().unwrap()
);
}
}