zc2 0.0.51

P2P compute broker with yen-denominated billing, WAL, and broker mesh support
//! `zc node …`: this machine's nodes from a terminal.

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(),
    )
}

/// The container `zc node shell` enters: the named one when it is the
/// node's, else its environment, else its first running worker.
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)"
            )
        })
}

/// The interactive shell command inside `container`, as engine args.
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(&reg.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 &reg.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),
        ];
        // The environment first, then a worker.
        assert_eq!(
            pick_container(&list, "pytorch", None).unwrap(),
            "zk-dep-1-v1"
        );
        assert_eq!(
            pick_container(&list, "main", None).unwrap(),
            "zc-share-aa-w0"
        );
        // A named container must be this node's and running.
        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"));
    }
}