use super::{runner, NewNode, NodePatch, NodeSpec, Registry, MAIN};
use std::path::Path;
const HELP: &str = "\
Usage: zc node <command>
A machine always runs its main node (the hub's jobs). Extra nodes are real
mesh nodes of their own, each with a fixed share of what you lend, and
optionally one hub environment they host.
ls [--json] this machine's nodes
add --cpus N --memory SIZE [--env TEMPLATE] [--workers N] [--disk SIZE] [--id NAME]
add a node (e.g. --cpus 2 --memory 4g --env pytorch)
set <id> [--workers N] [--cpus N] [--memory SIZE] [--disk SIZE]
rm <id> remove a node (its share returns to the main node)
shell <id> [container] a terminal inside one of the node's containers
compose <id> print the node's compose file
run <id> run one node in the foreground (the agent does this)
";
fn flag<'a>(args: &'a [String], name: &str) -> Option<&'a str> {
args.iter()
.position(|a| a == name)
.and_then(|i| args.get(i + 1))
.map(String::as_str)
}
fn bytes(v: &str, what: &str) -> Result<u64, String> {
match crate::sandbox::parse_memory(v) {
Ok(crate::sandbox::Amount::Absolute(b)) => Ok(b as u64),
_ => Err(format!("{what}: give a size such as 4g")),
}
}
fn cores(v: &str) -> Result<f64, String> {
v.parse::<f64>()
.ok()
.filter(|c| c.is_finite() && *c > 0.0)
.ok_or_else(|| "--cpus: give a number of cores such as 2".to_string())
}
fn gb(b: u64) -> String {
format!("{:.1} GB", b as f64 / (1u64 << 30) as f64)
}
fn row(home: &Path, n: &NodeSpec) -> String {
let st = runner::Status::load(&n.dir(home));
format!(
"{:<14} {:<16} {:<9} {:>7} {:>6.1} {:>9} :{:<5} {}",
n.id,
n.environment.as_deref().unwrap_or("hub jobs"),
st.as_ref().map(|s| s.state.as_str()).unwrap_or("stopped"),
n.workers,
f64::from(n.cpu_millis) / 1000.0,
gb(n.memory_bytes),
n.broker_port(),
st.as_ref()
.map(|s| s.fingerprint.as_str())
.unwrap_or_default(),
)
}
pub fn pick_container(
list: &[super::usage::ContainerUse],
node: &str,
wanted: Option<&str>,
) -> Result<String, String> {
let mine: Vec<_> = list
.iter()
.filter(|c| c.node == node && c.running)
.collect();
if let Some(w) = wanted {
return mine
.iter()
.find(|c| c.name == w)
.map(|c| c.name.clone())
.ok_or_else(|| format!("{w} is not a running container of node {node}"));
}
mine.iter()
.find(|c| c.role == "environment")
.or_else(|| mine.iter().find(|c| c.role == "worker"))
.or_else(|| mine.first())
.map(|c| c.name.clone())
.ok_or_else(|| {
format!(
"node {node} has nothing running to open a terminal in yet (no worker, and its environment has not started)"
)
})
}
pub fn shell_args(container: &str) -> Vec<String> {
[
"exec",
"-it",
container,
"sh",
"-c",
"command -v bash >/dev/null 2>&1 && exec bash -l || exec sh",
]
.map(String::from)
.to_vec()
}
fn shell(node: &str, wanted: Option<&str>) -> i32 {
let list = match super::usage::read() {
Ok(l) => l,
Err(e) => {
eprintln!("zc node shell: {e}");
return 1;
}
};
let container = match pick_container(&list, node, wanted) {
Ok(c) => c,
Err(e) => {
eprintln!("zc node shell: {e}");
return 1;
}
};
let mut cmd = match crate::sandbox::engine::command(&shell_args(&container)) {
Ok(c) => c,
Err(e) => {
eprintln!("zc node shell: {e}");
return 1;
}
};
#[cfg(unix)]
{
use std::os::unix::process::CommandExt;
let e = cmd.exec();
eprintln!("zc node shell: {e}");
1
}
#[cfg(not(unix))]
{
cmd.status().ok().and_then(|s| s.code()).unwrap_or(1)
}
}
pub fn run(args: &[String], json: bool) -> i32 {
let Some(home) = crate::credentials::machine_dir() else {
eprintln!("zc node: no zakuro home (HOME is not set)");
return 1;
};
let done = |r: Result<NodeSpec, String>, verb: &str| match r {
Ok(n) => {
if json {
println!("{}", serde_json::to_string(&n).unwrap_or_default());
} else {
println!("{verb} node {}", n.id);
}
0
}
Err(e) => {
eprintln!("zc node: {e}");
1
}
};
match args.first().map(String::as_str) {
None | Some("-h") | Some("--help") | Some("help") => {
print!("{HELP}");
0
}
Some("ls") | Some("list") => {
let reg = Registry::load(&home);
if json {
println!("{}", serde_json::to_string(®.nodes).unwrap_or_default());
return 0;
}
println!(
"{:<14} {:<16} {:<9} {:>7} {:>6} {:>9} {:<6} NODE",
"ID", "RUNS", "STATE", "WORKERS", "CPU", "MEMORY", "BROKER"
);
println!(
"{MAIN:<14} {:<16} (the agent: `zc agent status`)",
"hub jobs"
);
for n in ®.nodes {
println!("{}", row(&home, n));
}
0
}
Some("add") => {
let rest = &args[1..];
let req = (|| -> Result<NewNode, String> {
Ok(NewNode {
id: flag(rest, "--id").map(str::to_string),
environment: flag(rest, "--env").map(str::to_string),
environment_name: None,
workers: flag(rest, "--workers")
.map(|w| {
w.parse()
.map_err(|_| "--workers: give a number".to_string())
})
.transpose()?,
cpu_cores: cores(
flag(rest, "--cpus").ok_or("--cpus is required (e.g. --cpus 2)")?,
)?,
memory_bytes: bytes(
flag(rest, "--memory").ok_or("--memory is required (e.g. --memory 4g)")?,
"--memory",
)?,
disk_bytes: flag(rest, "--disk")
.map(|d| bytes(d, "--disk"))
.transpose()?,
})
})();
done(req.and_then(|r| super::add(&home, &r)), "added")
}
Some("set") => {
let Some(id) = args.get(1) else {
eprintln!("usage: zc node set <id> [--workers N] [--cpus N] [--memory SIZE] [--disk SIZE]");
return 2;
};
let rest = &args[2..];
let patch = (|| -> Result<NodePatch, String> {
Ok(NodePatch {
workers: flag(rest, "--workers")
.map(|w| {
w.parse()
.map_err(|_| "--workers: give a number".to_string())
})
.transpose()?,
cpu_cores: flag(rest, "--cpus").map(cores).transpose()?,
memory_bytes: flag(rest, "--memory")
.map(|m| bytes(m, "--memory"))
.transpose()?,
disk_bytes: flag(rest, "--disk")
.map(|d| bytes(d, "--disk"))
.transpose()?,
})
})();
done(patch.and_then(|p| super::patch(&home, id, &p)), "updated")
}
Some("rm") | Some("remove") => match args.get(1) {
Some(id) => done(super::remove(&home, id), "removed"),
None => {
eprintln!("usage: zc node rm <id>");
2
}
},
Some("compose") => {
let Some(spec) = args
.get(1)
.and_then(|id| Registry::load(&home).get(id).cloned())
else {
eprintln!("zc node: no such node");
return 1;
};
match runner::prepare(&home, &spec) {
Ok(key) => {
let fp8: String = key.fingerprint().chars().take(8).collect();
let image = crate::up::worker_container_image(&|k| std::env::var(k).ok());
print!("{}", super::compose_yaml(&spec, &fp8, &image));
0
}
Err(e) => {
eprintln!("zc node: {e}");
1
}
}
}
Some("shell") => match args.get(1) {
Some(id) => shell(id, args.get(2).map(String::as_str)),
None => {
eprintln!("usage: zc node shell <id> [container] (`main` is the main node)");
2
}
},
Some("run") => match args.get(1) {
Some(id) => runner::run(id),
None => {
eprintln!("usage: zc node run <id>");
2
}
},
Some(other) => {
eprintln!("zc node: unknown command {other:?}\n\n{HELP}");
2
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::nodes::usage::ContainerUse;
fn c(name: &str, node: &str, role: &'static str, running: bool) -> ContainerUse {
ContainerUse {
name: name.into(),
node: node.into(),
role,
what: None,
running,
limit_cpu_cores: None,
limit_memory_bytes: None,
cpu_cores: None,
memory_bytes: None,
}
}
#[test]
fn the_terminal_opens_in_the_nodes_own_containers_only() {
let list = vec![
c("zc-share-aa-w0", "main", "worker", true),
c("zc-share-bb-w0", "pytorch", "worker", true),
c("zk-dep-1-v1", "pytorch", "environment", true),
c("zk-dep-0-v9", "pytorch", "environment", false),
];
assert_eq!(
pick_container(&list, "pytorch", None).unwrap(),
"zk-dep-1-v1"
);
assert_eq!(
pick_container(&list, "main", None).unwrap(),
"zc-share-aa-w0"
);
assert_eq!(
pick_container(&list, "pytorch", Some("zc-share-bb-w0")).unwrap(),
"zc-share-bb-w0"
);
assert!(pick_container(&list, "pytorch", Some("zc-share-aa-w0")).is_err());
assert!(pick_container(&list, "pytorch", Some("zk-dep-0-v9")).is_err());
assert!(pick_container(&list, "empty", None)
.unwrap_err()
.contains("nothing running"));
}
#[test]
fn the_shell_is_interactive_and_prefers_bash() {
let a = shell_args("zc-share-aa-w0");
assert_eq!(&a[..3], ["exec", "-it", "zc-share-aa-w0"]);
assert!(a.last().unwrap().contains("exec bash"));
}
}