use std::collections::HashMap;
use std::process::Command;
use std::time::Duration;
use super::{Healthcheck, Port};
pub struct RunSpec<'a> {
pub name: String,
pub image: &'a str,
pub cmd: Option<&'a str>,
pub ports: &'a [Port],
pub env: &'a HashMap<String, String>,
pub labels: Vec<(String, String)>,
pub mounts: Vec<(String, String)>,
pub cpus: Option<f64>,
pub memory_gb: Option<f64>,
pub gpus: Option<u32>,
pub network: Option<String>,
pub hardened: bool,
}
pub fn build_run_args(spec: &RunSpec, default_network: &str) -> Vec<String> {
let network = spec
.network
.clone()
.unwrap_or_else(|| default_network.to_string());
let mut args: Vec<String> = vec![
"run".into(),
"-d".into(),
"--name".into(),
spec.name.clone(),
"--network".into(),
network,
];
for (k, v) in &spec.labels {
args.push("--label".into());
args.push(format!("{k}={v}"));
}
for (host, container) in &spec.mounts {
args.push("-v".into());
args.push(format!("{host}:{container}"));
}
if spec.hardened {
args.push("--pids-limit".into());
args.push("4096".into());
args.push("--security-opt".into());
args.push("no-new-privileges".into());
}
if let Some(c) = spec.cpus {
args.push("--cpus".into());
args.push(format!("{c}"));
}
if let Some(m) = spec.memory_gb {
args.push("--memory".into());
args.push(format!("{}m", (m * 1024.0).round() as u64));
}
if let Some(g) = spec.gpus.filter(|g| *g > 0) {
args.push("--gpus".into());
args.push(g.to_string());
}
for (k, v) in spec.env {
args.push("-e".into());
args.push(format!("{k}={v}"));
}
args.push(spec.image.to_string());
if let Some(cmd) = spec.cmd {
args.extend(cmd.split_whitespace().map(|s| s.to_string()));
}
args
}
pub fn deploy_network() -> String {
std::env::var("ZAKURO_DEPLOY_NETWORK")
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "bridge".to_string())
}
pub fn isolated_network() -> String {
std::env::var("ZAKURO_DEPLOY_ISOLATED_NETWORK")
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "zc-isolated".to_string())
}
pub fn deploy_gpus() -> Option<String> {
std::env::var("ZAKURO_DEPLOY_GPUS")
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
}
pub trait ContainerRuntime {
fn available(&self) -> bool;
fn pull(&self, image: &str) -> Result<(), String>;
fn run(&self, spec: &RunSpec) -> Result<String, String>;
fn stop(&self, container_id: &str) -> Result<(), String>;
fn rm(&self, container_id: &str) -> Result<(), String>;
fn restart(&self, container_id: &str) -> Result<(), String>;
fn is_running(&self, container_id: &str) -> bool;
fn container_ip(&self, container_id: &str) -> Result<String, String>;
fn health_check(&self, container_id: &str, hc: &Healthcheck) -> bool;
fn logs_tail(&self, container_id: &str, lines: u32) -> String;
fn list_by_label(&self, id: &str) -> Vec<String>;
fn list_by_label_key(&self, _key: &str) -> Vec<String> {
Vec::new()
}
fn login_in(
&self,
_config_dir: &std::path::Path,
registry: &str,
username: &str,
password: &str,
) -> Result<(), String> {
self.login(registry, username, password)
}
fn pull_in(&self, _config_dir: &std::path::Path, image: &str) -> Result<(), String> {
self.pull(image)
}
fn login(&self, _registry: &str, _username: &str, _password: &str) -> Result<(), String> {
Ok(())
}
fn image_digest(&self, _container_id: &str) -> Result<String, String> {
Err("image_digest not supported by this runtime".to_string())
}
}
pub fn container_name(id: &str, version: u64) -> String {
format!("zk-dep-{id}-v{version}")
}
pub fn deployment_labels(id: &str, version: u64) -> Vec<(String, String)> {
vec![
("zakuro.deployment".to_string(), id.to_string()),
("zakuro.version".to_string(), version.to_string()),
]
}
pub fn health_http_url(host: &str, hc: &Healthcheck) -> String {
let path = hc.path.as_deref().unwrap_or("/");
let path = if path.starts_with('/') {
path.to_string()
} else {
format!("/{path}")
};
format!("http://{host}:{}{path}", hc.port)
}
pub struct DockerCli;
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum RuntimeError {
SocketMissing,
PermissionDenied,
DaemonDown,
NotInstalled,
Other,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
pub struct RuntimeProbe {
pub available: bool,
pub runtime: Option<&'static str>,
pub error: Option<RuntimeError>,
pub detail: String,
pub checked_at: String,
}
#[derive(Debug, Clone)]
pub enum CliOutcome {
SpawnFailed(std::io::ErrorKind, String),
Exited { success: bool, stderr: String },
}
#[derive(Debug, Clone)]
pub struct HostFacts {
pub socket_path: String,
pub socket_exists: bool,
pub containerd_socket: bool,
}
fn default_socket_path() -> String {
match std::env::var("DOCKER_HOST") {
Ok(h) if h.starts_with("unix://") => h["unix://".len()..].to_string(),
_ => "/var/run/docker.sock".to_string(),
}
}
fn host_facts() -> HostFacts {
let socket_path = default_socket_path();
HostFacts {
socket_exists: std::path::Path::new(&socket_path).exists(),
socket_path,
containerd_socket: std::path::Path::new("/run/containerd/containerd.sock").exists(),
}
}
pub fn classify_probe(outcome: CliOutcome, facts: &HostFacts, checked_at: String) -> RuntimeProbe {
let fail = |runtime, error, detail: String| RuntimeProbe {
available: false,
runtime,
error: Some(error),
detail,
checked_at: checked_at.clone(),
};
match outcome {
CliOutcome::Exited { success: true, .. } => RuntimeProbe {
available: true,
runtime: Some("docker"),
error: None,
detail: "docker daemon responding".into(),
checked_at,
},
CliOutcome::SpawnFailed(kind, msg) => {
if kind == std::io::ErrorKind::NotFound {
let (rt, extra) = if facts.containerd_socket {
(
Some("containerd"),
" (containerd is present, but zc deploys through docker)",
)
} else {
(None, "")
};
fail(
rt,
RuntimeError::NotInstalled,
format!("`docker` binary not found on PATH{extra}"),
)
} else {
fail(
None,
RuntimeError::Other,
format!("could not run `docker`: {msg}"),
)
}
}
CliOutcome::Exited { stderr, .. } => {
let low = stderr.to_lowercase();
let sock = &facts.socket_path;
if low.contains("permission denied") {
fail(
Some("docker"),
RuntimeError::PermissionDenied,
format!("permission denied on {sock}"),
)
} else if !facts.socket_exists || low.contains("no such file or directory") {
fail(
None,
RuntimeError::SocketMissing,
format!("docker socket {sock} does not exist"),
)
} else if low.contains("cannot connect")
|| low.contains("daemon running")
|| low.contains("connection refused")
{
fail(
Some("docker"),
RuntimeError::DaemonDown,
format!("docker daemon is not responding on {sock}"),
)
} else {
let first = stderr.lines().next().unwrap_or("docker info failed");
fail(
Some("docker"),
RuntimeError::Other,
format!("docker info failed: {first}"),
)
}
}
}
}
impl RuntimeProbe {
pub fn next_step(&self) -> Option<String> {
Some(match self.error? {
RuntimeError::PermissionDenied => {
"add the zc service user to the docker group (usermod -aG docker <user>) and restart zc".into()
}
RuntimeError::SocketMissing => "start the docker service (systemctl enable --now docker) or set DOCKER_HOST".into(),
RuntimeError::DaemonDown => "start the docker daemon (systemctl start docker)".into(),
RuntimeError::NotInstalled => "install docker on this host".into(),
RuntimeError::Other => "run `zc doctor` on this host for details".into(),
})
}
pub fn failure_message(&self) -> String {
match self.next_step() {
None => "container runtime available".into(),
Some(step) => format!(
"no container runtime on this host: {} — {step}",
self.detail
),
}
}
pub fn to_json(&self) -> serde_json::Value {
serde_json::to_value(self).unwrap_or(serde_json::Value::Null)
}
}
pub fn doctor_report(p: &RuntimeProbe) -> String {
let mut out = format!(
"container runtime: {}\n runtime: {}\n detail: {}\n checked_at: {}",
if p.available { "OK" } else { "UNAVAILABLE" },
p.runtime.unwrap_or("none"),
p.detail,
p.checked_at
);
if let Some(e) = p.error {
out.push_str(&format!(
"\n error: {}",
serde_json::to_value(e)
.ok()
.and_then(|v| v.as_str().map(String::from))
.unwrap_or_default()
));
}
if let Some(step) = p.next_step() {
out.push_str(&format!("\n next step: {step}"));
}
out
}
pub fn runtime_probe() -> RuntimeProbe {
let outcome = match Command::new("docker").arg("info").output() {
Ok(o) => CliOutcome::Exited {
success: o.status.success(),
stderr: String::from_utf8_lossy(&o.stderr).trim().to_string(),
},
Err(e) => CliOutcome::SpawnFailed(e.kind(), e.to_string()),
};
classify_probe(outcome, &host_facts(), chrono::Utc::now().to_rfc3339())
}
pub fn runtime_available() -> bool {
runtime_probe().available
}
fn docker(args: &[&str]) -> Result<String, String> {
let out = Command::new("docker")
.args(args)
.output()
.map_err(|e| format!("docker not available: {e}"))?;
if out.status.success() {
Ok(String::from_utf8_lossy(&out.stdout).trim().to_string())
} else {
let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
Err(if stderr.is_empty() {
format!("docker {} failed", args.first().copied().unwrap_or(""))
} else {
stderr
})
}
}
fn docker_login(
config_dir: Option<&std::path::Path>,
registry: &str,
username: &str,
password: &str,
) -> Result<(), String> {
use std::io::Write;
let mut cmd = Command::new("docker");
if let Some(d) = config_dir {
cmd.arg("--config").arg(d);
}
let mut child = cmd
.args(["login", "-u", username, "--password-stdin", registry])
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::piped())
.spawn()
.map_err(|e| format!("docker not available: {e}"))?;
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(password.as_bytes());
}
let out = child.wait_with_output().map_err(|e| e.to_string())?;
if out.status.success() {
Ok(())
} else {
Err(String::from_utf8_lossy(&out.stderr).trim().to_string())
}
}
const CONTAINER_IP_RETRIES: u32 = 10;
const CONTAINER_IP_RETRY_DELAY: Duration = Duration::from_millis(300);
impl ContainerRuntime for DockerCli {
fn available(&self) -> bool {
runtime_available()
}
fn pull(&self, image: &str) -> Result<(), String> {
docker(&["pull", image]).map(|_| ())
}
fn run(&self, spec: &RunSpec) -> Result<String, String> {
let _ = docker(&["rm", "-f", &spec.name]);
if spec.network.as_deref() == Some(isolated_network().as_str())
&& docker(&["network", "inspect", &isolated_network()]).is_err()
{
docker(&["network", "create", "--internal", &isolated_network()])
.map_err(|e| format!("cannot create isolated network: {e}"))?;
}
let mut args = build_run_args(spec, &deploy_network());
if spec.gpus.is_none() {
if let Some(gpus) = deploy_gpus() {
args.splice(6..6, ["--gpus".to_string(), gpus]);
}
}
let arg_refs: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
docker(&arg_refs)
}
fn stop(&self, container_id: &str) -> Result<(), String> {
docker(&["stop", container_id]).map(|_| ())
}
fn rm(&self, container_id: &str) -> Result<(), String> {
docker(&["rm", "-f", container_id]).map(|_| ())
}
fn restart(&self, container_id: &str) -> Result<(), String> {
docker(&["start", container_id]).map(|_| ())
}
fn is_running(&self, container_id: &str) -> bool {
docker(&["inspect", "-f", "{{.State.Running}}", container_id])
.map(|out| out == "true")
.unwrap_or(false)
}
fn container_ip(&self, container_id: &str) -> Result<String, String> {
for attempt in 0..CONTAINER_IP_RETRIES {
let out = docker(&[
"inspect",
"-f",
"{{range .NetworkSettings.Networks}}{{.IPAddress}} {{end}}",
container_id,
])?;
if let Some(ip) = out.split_whitespace().find(|s| !s.is_empty()) {
return Ok(ip.to_string());
}
if attempt + 1 < CONTAINER_IP_RETRIES {
std::thread::sleep(CONTAINER_IP_RETRY_DELAY);
}
}
Err(format!(
"container {container_id} has no network IP after {CONTAINER_IP_RETRIES} attempts \
(host network mode, or the container exited)"
))
}
fn health_check(&self, container_id: &str, hc: &Healthcheck) -> bool {
let host = self
.container_ip(container_id)
.unwrap_or_else(|_| "127.0.0.1".to_string());
match hc.kind.as_str() {
"tcp" => std::net::TcpStream::connect((host.as_str(), hc.port)).is_ok(),
_ => ureq::get(health_http_url(&host, hc))
.config()
.timeout_global(Some(Duration::from_secs(3)))
.http_status_as_error(false)
.build()
.call()
.map(|r| (200..300).contains(&r.status().as_u16()))
.unwrap_or(false),
}
}
fn logs_tail(&self, container_id: &str, lines: u32) -> String {
docker(&["logs", "--tail", &lines.to_string(), container_id]).unwrap_or_default()
}
fn list_by_label_key(&self, key: &str) -> Vec<String> {
docker(&["ps", "-a", "-q", "--filter", &format!("label={key}")])
.map(|out| {
out.lines()
.map(|l| l.trim().to_string())
.filter(|l| !l.is_empty())
.collect()
})
.unwrap_or_default()
}
fn login_in(
&self,
config_dir: &std::path::Path,
registry: &str,
username: &str,
password: &str,
) -> Result<(), String> {
docker_login(Some(config_dir), registry, username, password)
}
fn pull_in(&self, config_dir: &std::path::Path, image: &str) -> Result<(), String> {
docker(&["--config", &config_dir.display().to_string(), "pull", image]).map(|_| ())
}
fn login(&self, registry: &str, username: &str, password: &str) -> Result<(), String> {
docker_login(None, registry, username, password)
}
fn image_digest(&self, container_id: &str) -> Result<String, String> {
let image_id = docker(&["inspect", "-f", "{{.Image}}", container_id])?;
let digests = docker(&[
"image",
"inspect",
"-f",
"{{range .RepoDigests}}{{.}} {{end}}",
&image_id,
])
.unwrap_or_default();
let found: Vec<String> = digests
.split_whitespace()
.filter_map(|d| d.rsplit_once('@').map(|(_, h)| h.to_string()))
.collect();
if found.is_empty() {
Ok(image_id)
} else {
Ok(found.join(","))
}
}
fn list_by_label(&self, id: &str) -> Vec<String> {
docker(&[
"ps",
"-a",
"-q",
"--filter",
&format!("label=zakuro.deployment={id}"),
])
.map(|out| out.lines().map(|l| l.trim().to_string()).collect())
.unwrap_or_default()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn run_spec_new_fields_map_to_docker_args() {
let env = HashMap::from([("K".to_string(), "V".to_string())]);
let spec = RunSpec {
name: "n".into(),
image: "img@sha256:ab",
cmd: None,
ports: &[],
env: &env,
labels: vec![("a".into(), "b".into())],
mounts: vec![("/h/s.sock".into(), "/run/zakuro/space.sock".into())],
cpus: Some(2.5),
memory_gb: Some(8.0),
gpus: Some(1),
network: Some("egress".into()),
hardened: true,
};
let args = build_run_args(&spec, "bridge");
let joined = args.join(" ");
assert!(joined.contains("--network egress"));
assert!(joined.contains("-v /h/s.sock:/run/zakuro/space.sock"));
assert!(joined.contains("--cpus 2.5"));
assert!(joined.contains("--memory 8192m"));
assert!(joined.contains("--gpus 1"));
assert!(joined.contains("--pids-limit 4096"));
assert!(joined.contains("--security-opt no-new-privileges"));
assert!(joined.contains("--label a=b"));
assert!(joined.contains("-e K=V"));
assert_eq!(args.last().unwrap(), "img@sha256:ab");
let plain = RunSpec {
mounts: vec![],
cpus: None,
memory_gb: None,
gpus: Some(0),
network: None,
hardened: false,
..spec
};
let j = build_run_args(&plain, "bridge").join(" ");
assert!(j.contains("--network bridge"));
assert!(!j.contains("--gpus") && !j.contains("--cpus") && !j.contains("--memory"));
assert!(!j.contains(" -v "));
assert!(!j.contains("--pids-limit") && !j.contains("no-new-privileges"));
}
#[test]
fn container_name_is_unique_per_version() {
assert_eq!(container_name("dep_1", 3), "zk-dep-dep_1-v3");
assert_ne!(container_name("dep_1", 3), container_name("dep_1", 4));
}
#[test]
fn deployment_labels_carry_id_and_version() {
let labels = deployment_labels("dep_1", 3);
assert!(labels.contains(&("zakuro.deployment".to_string(), "dep_1".to_string())));
assert!(labels.contains(&("zakuro.version".to_string(), "3".to_string())));
}
fn hc(kind: &str, path: Option<&str>) -> Healthcheck {
Healthcheck {
kind: kind.to_string(),
port: 8000,
path: path.map(|s| s.to_string()),
timeout_s: 60,
}
}
#[test]
fn health_http_url_defaults_path_to_root() {
assert_eq!(
health_http_url("172.17.0.5", &hc("http", None)),
"http://172.17.0.5:8000/"
);
}
#[test]
fn health_http_url_tolerates_a_path_without_leading_slash() {
assert_eq!(
health_http_url("172.17.0.5", &hc("http", Some("healthz"))),
"http://172.17.0.5:8000/healthz"
);
}
#[test]
fn health_http_url_keeps_an_already_leading_slash() {
assert_eq!(
health_http_url("172.17.0.5", &hc("http", Some("/api/health"))),
"http://172.17.0.5:8000/api/health"
);
}
#[test]
fn health_http_url_uses_the_container_ip_not_loopback() {
let url = health_http_url("10.13.13.10", &hc("http", None));
assert!(url.starts_with("http://10.13.13.10:"));
assert!(!url.contains("127.0.0.1"));
}
#[test]
fn isolated_spec_runs_on_the_isolated_network() {
let env = HashMap::new();
let spec = RunSpec {
name: "n".into(),
image: "img",
cmd: None,
ports: &[],
env: &env,
labels: vec![],
mounts: vec![],
cpus: None,
memory_gb: None,
gpus: None,
network: Some("zc-isolated".into()),
hardened: false,
};
assert!(build_run_args(&spec, "bridge")
.join(" ")
.contains("--network zc-isolated"));
}
#[test]
fn deploy_network_defaults_to_bridge_when_unset() {
let _lock = crate::credentials::HOME_ENV_LOCK.lock();
let prev = std::env::var_os("ZAKURO_DEPLOY_NETWORK");
std::env::remove_var("ZAKURO_DEPLOY_NETWORK");
assert_eq!(deploy_network(), "bridge");
if let Some(v) = prev {
std::env::set_var("ZAKURO_DEPLOY_NETWORK", v);
}
}
#[test]
fn deploy_network_honours_the_env_override() {
let _lock = crate::credentials::HOME_ENV_LOCK.lock();
let prev = std::env::var_os("ZAKURO_DEPLOY_NETWORK");
std::env::set_var("ZAKURO_DEPLOY_NETWORK", "hubnet");
assert_eq!(deploy_network(), "hubnet");
match prev {
Some(v) => std::env::set_var("ZAKURO_DEPLOY_NETWORK", v),
None => std::env::remove_var("ZAKURO_DEPLOY_NETWORK"),
}
}
#[test]
fn deploy_gpus_is_none_when_unset_or_blank() {
let _lock = crate::credentials::HOME_ENV_LOCK.lock();
let prev = std::env::var_os("ZAKURO_DEPLOY_GPUS");
std::env::remove_var("ZAKURO_DEPLOY_GPUS");
assert_eq!(deploy_gpus(), None);
std::env::set_var("ZAKURO_DEPLOY_GPUS", " ");
assert_eq!(deploy_gpus(), None);
match prev {
Some(v) => std::env::set_var("ZAKURO_DEPLOY_GPUS", v),
None => std::env::remove_var("ZAKURO_DEPLOY_GPUS"),
}
}
#[test]
fn deploy_gpus_honours_the_env_value() {
let _lock = crate::credentials::HOME_ENV_LOCK.lock();
let prev = std::env::var_os("ZAKURO_DEPLOY_GPUS");
std::env::set_var("ZAKURO_DEPLOY_GPUS", " all ");
assert_eq!(deploy_gpus().as_deref(), Some("all"));
match prev {
Some(v) => std::env::set_var("ZAKURO_DEPLOY_GPUS", v),
None => std::env::remove_var("ZAKURO_DEPLOY_GPUS"),
}
}
#[test]
fn deploy_network_blank_value_falls_back_to_bridge() {
let _lock = crate::credentials::HOME_ENV_LOCK.lock();
let prev = std::env::var_os("ZAKURO_DEPLOY_NETWORK");
std::env::set_var("ZAKURO_DEPLOY_NETWORK", " ");
assert_eq!(deploy_network(), "bridge");
match prev {
Some(v) => std::env::set_var("ZAKURO_DEPLOY_NETWORK", v),
None => std::env::remove_var("ZAKURO_DEPLOY_NETWORK"),
}
}
}
#[cfg(test)]
mod probe_tests {
use super::*;
fn facts(exists: bool, containerd: bool) -> HostFacts {
HostFacts {
socket_path: "/var/run/docker.sock".into(),
socket_exists: exists,
containerd_socket: containerd,
}
}
fn exited(stderr: &str) -> CliOutcome {
CliOutcome::Exited {
success: false,
stderr: stderr.into(),
}
}
fn probe(o: CliOutcome, f: HostFacts) -> RuntimeProbe {
classify_probe(o, &f, "t".into())
}
#[test]
fn available_when_info_succeeds() {
let p = probe(
CliOutcome::Exited {
success: true,
stderr: String::new(),
},
facts(true, false),
);
assert!(p.available && p.error.is_none() && p.runtime == Some("docker"));
assert!(p.next_step().is_none());
}
#[test]
fn binary_missing_is_not_installed() {
let p = probe(
CliOutcome::SpawnFailed(std::io::ErrorKind::NotFound, "nf".into()),
facts(false, false),
);
assert_eq!(p.error, Some(RuntimeError::NotInstalled));
assert_eq!(p.runtime, None);
}
#[test]
fn containerd_only_is_reported_as_containerd_not_installed() {
let p = probe(
CliOutcome::SpawnFailed(std::io::ErrorKind::NotFound, "nf".into()),
facts(false, true),
);
assert_eq!(p.error, Some(RuntimeError::NotInstalled));
assert_eq!(p.runtime, Some("containerd"));
assert!(!p.available);
}
#[test]
fn socket_missing() {
let p = probe(exited("Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?"), facts(false, false));
assert_eq!(p.error, Some(RuntimeError::SocketMissing));
}
#[test]
fn permission_denied_names_socket_and_group_fix() {
let p = probe(exited("permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock"), facts(true, false));
assert_eq!(p.error, Some(RuntimeError::PermissionDenied));
let m = p.failure_message();
assert!(m.starts_with("no container runtime on this host"));
assert!(m.contains("permission denied on /var/run/docker.sock"));
assert!(m.contains("docker group"));
}
#[test]
fn daemon_down_when_socket_exists_but_refuses() {
let p = probe(exited("Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?"), facts(true, false));
assert_eq!(p.error, Some(RuntimeError::DaemonDown));
}
#[test]
fn unknown_failure_is_other_with_first_line() {
let p = probe(exited("boom\nsecond"), facts(true, false));
assert_eq!(p.error, Some(RuntimeError::Other));
assert!(p.detail.contains("boom") && !p.detail.contains("second"));
}
#[test]
fn recovery_flips_to_available() {
let down = probe(
exited("Cannot connect to the Docker daemon"),
facts(true, false),
);
let up = probe(
CliOutcome::Exited {
success: true,
stderr: String::new(),
},
facts(true, false),
);
assert!(!down.available && up.available);
}
#[test]
fn doctor_report_prints_reason_and_next_step() {
let p = probe(exited("permission denied"), facts(true, false));
let r = doctor_report(&p);
assert!(
r.contains("UNAVAILABLE") && r.contains("permission_denied") && r.contains("next step")
);
}
}