//! The owner's atirc mesh node: an AtircNode in the orchestrator's kcp (a HostProcess running the pinned //! `atirc mesh run` as the account), and `atirc mesh pub|peers|sub` against it. use std::path::PathBuf; use std::sync::Arc; use std::time::Duration; use anyhow::{Context, Result}; use serde_json::{Value, json}; use crate::kcp::Kcp; use crate::requester::Requester; use crate::{Ctx, eventually}; pub struct OwnerNode { pub name: String, pub handle: String, config_dir: String, bin: PathBuf, sub_log: PathBuf, _sub: tokio::process::Child, } impl OwnerNode { /// Apply AtircNode `name` as the account of `role` with `peers`, wait Running, start a `mesh sub --cursor 0` into a file. /// Deleted by a cleanup (with its password env file). pub async fn start( ctx: &Arc, r: &Arc, role: &str, name: &str, peers: &[String], ) -> Result { let a = ctx.role(role)?; let env = ctx.dir.join(format!("{name}-atp.env")); { use std::io::Write; use std::os::unix::fs::OpenOptionsExt; let mut f = std::fs::OpenOptions::new() .create(true) .truncate(true) .write(true) .mode(0o600) .open(&env)?; writeln!(f, "ATP_PASSWORD={}", a.password()?.expose())?; } let kcp = r.kcp().await?; let (del_r, del_name, del_env) = (r.clone(), name.to_string(), env.clone()); ctx.defer(&format!("delete AtircNode {name}"), async move { let _ = std::fs::remove_file(&del_env); del_r .kcp() .await? .delete("AtircNode", &del_name) .await .map(|_| ()) }); kcp.apply(&json!({ "apiVersion": "socialweb.computer/v1alpha1", "kind": "AtircNode", "metadata": { "name": name }, "spec": { "handle": a.handle, "nick": name, "peers": peers, "ircPort": 0, "passwordEnvFile": env } })) .await?; let o = kcp .wait_phase("AtircNode", name, "Running", Duration::from_secs(180)) .await?; let config_dir = o["status"]["configDir"] .as_str() .context("AtircNode without status.configDir")? .to_string(); let pid = hostprocess_pid(&kcp, &o).await?; let bin = std::fs::read_link(format!("/proc/{pid}/exe")) .context("the AtircNode's atirc runs on this host")?; let sub_log = ctx.dir.join(format!("{name}-sub.ndjson")); let sub = tokio::process::Command::new(&bin) .args(["mesh", "sub", "--cursor", "0"]) .env("ATIRC_CONFIG_DIR", &config_dir) .env("ATP_USERNAME", &a.handle) .stdout(std::fs::File::create(&sub_log)?) .stderr(std::process::Stdio::null()) .kill_on_drop(true) .spawn()?; Ok(Self { name: name.into(), handle: a.handle.clone(), config_dir, bin, sub_log, _sub: sub, }) } pub async fn mesh(&self, args: &[&str]) -> Result { let out = tokio::process::Command::new(&self.bin) .arg("mesh") .args(args) .env("ATIRC_CONFIG_DIR", &self.config_dir) .env("ATP_USERNAME", &self.handle) .output() .await?; Ok(format!( "{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr) )) } /// The messages the node has seen (ndjson of `mesh sub`). pub fn messages(&self) -> Vec { std::fs::read_to_string(&self.sub_log) .unwrap_or_default() .lines() .filter_map(|l| serde_json::from_str(l).ok()) .collect() } /// Wait for ` online` from the agent `identity` (.). pub async fn wait_online(&self, identity: &str, timeout: Duration) -> Result<()> { self.wait_message("the agent online", timeout, |m| { m["identity"] == identity && m["text"].as_str().is_some_and(|t| t.contains("online")) }) .await .map(|_| ()) } /// Prompt the agent `: uname -m` on the mesh; the seconds until it answers with the machine. pub async fn prompt_uname(&self, identity: &str, timeout: Duration) -> Result { let nick = identity.split('.').next().unwrap_or(identity); let seen = self.messages().len(); let t = std::time::Instant::now(); self.mesh(&["pub", &format!("{nick}: uname -m")]).await?; eventually( "the agent's answer", timeout, Duration::from_secs(1), || async { Ok(self.messages().into_iter().skip(seen).find(|m| { m["identity"] == identity && m["text"] .as_str() .is_some_and(|t| t.contains("x86_64") || t.contains("aarch64")) })) }, ) .await?; Ok(t.elapsed().as_secs_f64()) } pub async fn wait_message( &self, what: &str, timeout: Duration, pred: impl Fn(&Value) -> bool, ) -> Result { eventually(what, timeout, Duration::from_secs(1), || async { Ok(self.messages().into_iter().find(|m| pred(m))) }) .await } } async fn hostprocess_pid(kcp: &Kcp, node: &Value) -> Result { if let Some(pid) = node["status"]["runtime"]["pid"].as_i64() { return Ok(pid); } let hp = node["status"]["hostProcess"] .as_str() .context("AtircNode without status.hostProcess")?; let o = kcp .get("HostProcess", hp) .await? .context("the AtircNode's HostProcess is gone")?; o["status"]["runtime"]["pid"] .as_i64() .context("HostProcess without status.runtime.pid") } /// The pinned atirc (the requester's staged asset, newest first): token, sub, pub, revoke. pub fn atirc_bin() -> Result { let runtime = PathBuf::from(std::env::var("HOME")?).join(".cache/socialweb-computer/runtime"); let mut found: Vec<_> = std::fs::read_dir(&runtime)? .flatten() .map(|e| e.path().join("atirc-x86_64")) .filter(|p| p.is_file()) .collect(); found.sort_by_key(|p| std::fs::metadata(p).and_then(|m| m.modified()).ok()); found .pop() .context("no staged atirc-x86_64 (run any requester once)") } /// An observer on the atirc server: a token minted as the account (`atirc token `, the normal flow), a /// `sub` of the owner channel into a file, `pub` as the observer. A cleanup revokes the token. pub struct Observer { bin: PathBuf, endpoint: String, plc: String, token: String, log: PathBuf, _sub: tokio::process::Child, } impl Observer { pub async fn start(ctx: &Arc, role: &str, nick: &str) -> Result> { let a = ctx.role(role)?; let endpoint = ctx.target.atirc.clone().context("target atirc")?; let bin = atirc_bin()?; let out = tokio::process::Command::new(&bin) .args(["token", nick, "--endpoint", &endpoint]) .env("ATP_USERNAME", &a.handle) .env("ATP_PASSWORD", a.password()?.expose()) .env("ATIRC_PLC_DIRECTORY_URL", &ctx.target.plc) .stdin(std::process::Stdio::null()) .output() .await?; anyhow::ensure!(out.status.success(), "atirc token {nick} failed"); let token = String::from_utf8(out.stdout)?.trim().to_string(); anyhow::ensure!(!token.is_empty(), "atirc token printed no token"); let log = ctx.dir.join(format!("observer-{nick}.ndjson")); let sub = tokio::process::Command::new(&bin) .args(["sub", "--full", "--cursor", "-1"]) .env("ATIRC_TOKEN", &token) .env("ATIRC_ENDPOINT", &endpoint) .env("ATIRC_PLC_DIRECTORY_URL", &ctx.target.plc) .stdin(std::process::Stdio::null()) .stdout(std::fs::File::create(&log)?) .stderr(std::process::Stdio::null()) .kill_on_drop(true) .spawn()?; let o = Arc::new(Self { bin, endpoint, plc: ctx.target.plc.clone(), token, log, _sub: sub, }); let r = o.clone(); ctx.defer(&format!("revoke the observer token {nick}"), async move { r.revoke().await }); Ok(o) } async fn run(&self, args: &[&str]) -> Result { Ok(tokio::process::Command::new(&self.bin) .args(args) .env("ATIRC_TOKEN", &self.token) .env("ATIRC_ENDPOINT", &self.endpoint) .env("ATIRC_PLC_DIRECTORY_URL", &self.plc) .stdin(std::process::Stdio::null()) .stdout(std::process::Stdio::null()) .stderr(std::process::Stdio::null()) .status() .await? .success()) } pub async fn publish(&self, text: &str) -> Result { self.run(&["pub", text]).await } /// `atirc revoke` of the token's own subhandle; idempotent. pub async fn revoke(&self) -> Result<()> { self.run(&["revoke"]).await?; Ok(()) } pub fn messages(&self) -> Vec { std::fs::read_to_string(&self.log) .unwrap_or_default() .lines() .filter_map(|l| serde_json::from_str(l).ok()) .collect() } pub async fn wait_message( &self, what: &str, timeout: Duration, pred: impl Fn(&Value) -> bool, ) -> Result { eventually(what, timeout, Duration::from_secs(1), || async { Ok(self.messages().into_iter().find(|m| pred(m))) }) .await } }