use super::app::{AgentState, Effect, Event, Write};
use super::model::MeshSnapshot;
use crate::agent::client::AgentClient;
use crate::agent::summary::Summary;
use std::path::{Path, PathBuf};
use std::sync::mpsc::{RecvTimeoutError, Sender};
use std::time::Duration;
pub const MESH_EVERY: Duration = Duration::from_secs(15);
pub const AGENT_EVERY: Duration = Duration::from_secs(5);
pub const AGENT_TIMEOUT: Duration = Duration::from_secs(2);
pub const WRITE_TIMEOUT: Duration = Duration::from_secs(5);
pub fn agent_dir() -> Option<PathBuf> {
crate::credentials::dir().map(|d| d.join("agent"))
}
pub fn mesh_once() -> MeshSnapshot {
let (brokers, listing) = live_listing(
crate::mesh_listing_from_directory,
crate::listing_cache::save,
crate::listing_cache::load_any,
);
let (workers, err) = local_workers();
let workers = crate::merge_mesh_workers(&brokers, &workers);
MeshSnapshot::from_listing(&brokers, &listing, &workers, err)
}
pub fn live_listing(
probe: impl FnOnce() -> Option<(Vec<crate::ListedBroker>, crate::Listing)>,
save: impl FnOnce(&[crate::ListedBroker], &crate::Listing),
cached: impl FnOnce() -> Option<(Vec<crate::ListedBroker>, crate::Listing)>,
) -> (Vec<crate::ListedBroker>, crate::Listing) {
if let Some((brokers, listing)) = probe() {
save(&brokers, &listing);
return (brokers, listing);
}
cached().unwrap_or_else(|| {
(
Vec::new(),
crate::Listing::LocalOnly("the hub directory is unavailable".into()),
)
})
}
fn local_workers() -> (Vec<serde_json::Value>, Option<String>) {
local_workers_from(
|| match std::env::var("ZAKURO_BROKER") {
Ok(b) if !b.trim().is_empty() => crate::broker::uri::resolve(&b).ok(),
_ => crate::autobroker::find_local_broker(),
},
crate::fetch_worker_list,
)
}
fn local_workers_from(
find: impl FnOnce() -> Option<String>,
fetch: impl FnOnce(&str) -> Result<Vec<serde_json::Value>, String>,
) -> (Vec<serde_json::Value>, Option<String>) {
let Some(url) = find() else {
return (
Vec::new(),
Some("no broker is running on this machine — :up starts one".into()),
);
};
match fetch(&url) {
Ok(w) => (w, None),
Err(e) => (Vec::new(), Some(e)),
}
}
pub fn mesh_cached() -> Option<MeshSnapshot> {
let (brokers, listing) = crate::listing_cache::load_any()?;
let (workers, err) = local_workers();
let workers = crate::merge_mesh_workers(&brokers, &workers);
Some(MeshSnapshot::from_listing(
&brokers, &listing, &workers, err,
))
}
fn client(dir: Option<&Path>) -> Option<AgentClient> {
AgentClient::from_dir(dir?)
}
fn parse_summary(v: serde_json::Value) -> Result<Summary, String> {
serde_json::from_value(v).map_err(|e| format!("agent summary: {e}"))
}
pub fn agent_once(dir: Option<&Path>) -> AgentState {
let Some(c) = client(dir) else {
return AgentState::NotRunning(None);
};
match c.summary(AGENT_TIMEOUT).and_then(parse_summary) {
Ok(s) => AgentState::Running(Box::new(s)),
Err(e) => AgentState::NotRunning(Some(e)),
}
}
pub fn write_request(w: &Write) -> (&'static str, serde_json::Value) {
match w {
Write::Sharing(on) => ("/v1/sharing", serde_json::json!({ "on": on })),
Write::Workers(n) => ("/v1/workers", serde_json::json!({ "count": n })),
Write::Price(p) => (
"/v1/price",
serde_json::json!({ "scope": "device", "price_per_hour": p }),
),
}
}
pub fn apply(dir: Option<&Path>, w: &Write) -> Result<Summary, String> {
let c = client(dir).ok_or_else(|| "zc agent is not running".to_string())?;
let (path, body) = write_request(w);
c.put(path, body, WRITE_TIMEOUT).and_then(parse_summary)
}
pub fn refresh_hub(dir: Option<&Path>) -> AgentState {
let Some(c) = client(dir) else {
return AgentState::NotRunning(None);
};
match c.post("/v1/refresh", WRITE_TIMEOUT).and_then(parse_summary) {
Ok(s) => AgentState::Running(Box::new(s)),
Err(e) => AgentState::NotRunning(Some(e)),
}
}
pub fn start_agent(dir: Option<&Path>) -> Result<(), String> {
let exe = std::env::current_exe().map_err(|e| e.to_string())?;
let mut cmd = std::process::Command::new(&exe);
cmd.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null());
if cfg!(target_os = "macos") {
let ok = cmd
.args(["agent", "install"])
.status()
.is_ok_and(|s| s.success());
return match ok {
true => Ok(()),
false => Err("`zc agent install` failed — run it in a shell to see why".into()),
};
}
cmd.args(["agent", "run"]);
#[cfg(unix)]
{
use std::os::unix::process::CommandExt;
cmd.process_group(0);
}
cmd.spawn().map_err(|e| format!("starting zc agent: {e}"))?;
for _ in 0..50 {
std::thread::sleep(Duration::from_millis(100));
if matches!(agent_once(dir), AgentState::Running(_)) {
return Ok(());
}
}
Err("zc agent did not answer within 5 s".into())
}
pub struct Pollers {
pub(crate) mesh: Sender<()>,
pub(crate) market: Sender<()>,
}
impl Pollers {
pub fn refresh_mesh(&self) {
let _ = self.mesh.send(());
}
}
pub fn spawn_pollers(tx: Sender<Event>, dir: Option<PathBuf>) -> Pollers {
let mut pollers = spawn_mesh_poller(tx.clone(), mesh_cached, mesh_once);
pollers.market =
super::market::spawn_poller(tx.clone(), crate::market::client::Client::from_env);
std::thread::spawn(move || loop {
if tx.send(Event::Agent(agent_once(dir.as_deref()))).is_err() {
return;
}
std::thread::sleep(AGENT_EVERY);
});
pollers
}
pub fn spawn_mesh_poller(
tx: Sender<Event>,
cached: impl FnOnce() -> Option<MeshSnapshot> + Send + 'static,
live: impl Fn() -> MeshSnapshot + Send + 'static,
) -> Pollers {
let (mesh_tx, mesh_rx) = std::sync::mpsc::channel::<()>();
std::thread::spawn(move || {
if let Some(snap) = cached() {
if tx.send(Event::Mesh(snap)).is_err() {
return;
}
}
loop {
if tx.send(Event::Mesh(live())).is_err() {
return;
}
if let Err(RecvTimeoutError::Disconnected) = mesh_rx.recv_timeout(MESH_EVERY) {
return;
}
}
});
Pollers {
mesh: mesh_tx,
market: std::sync::mpsc::channel().0,
}
}
pub fn execute(effect: Effect, tx: &Sender<Event>, pollers: &Pollers, dir: Option<PathBuf>) {
let tx = tx.clone();
match effect {
Effect::RefreshMesh => pollers.refresh_mesh(),
Effect::RefreshAgent => {
std::thread::spawn(move || {
let _ = tx.send(Event::Agent(refresh_hub(dir.as_deref())));
});
}
Effect::Apply(w) => {
std::thread::spawn(move || {
let r = apply(dir.as_deref(), &w).map(Box::new);
let _ = tx.send(Event::Done(w, r));
});
}
Effect::StartAgent => {
std::thread::spawn(move || {
let r = start_agent(dir.as_deref());
let _ = tx.send(Event::AgentStarted(r));
});
}
Effect::RefreshMarket | Effect::Hub(_) => {
super::market::execute(&effect, &tx, &pollers.market)
}
Effect::Copy(_) | Effect::OpenUrl(_) | Effect::Suspend(_) => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::agent::files::{save_json, AgentFile, AGENT_FILE};
use std::io::{BufRead, BufReader, Read, Write as _};
use std::sync::{Arc, Mutex};
const SUMMARY: &str = include_str!("../../docs/agent-api/summary.v1.json");
fn stub_agent(replies: Vec<(u16, String)>) -> (PathBuf, Arc<Mutex<Vec<String>>>) {
let dir = crate::agent::files::tests::tmp("session-data");
std::fs::create_dir_all(&dir).unwrap();
let l = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let port = l.local_addr().unwrap().port();
save_json(
&dir.join(AGENT_FILE),
&AgentFile {
v: 1,
port,
token: "tok".into(),
pid: 0,
version: "t".into(),
rev: 0,
},
)
.unwrap();
let seen = Arc::new(Mutex::new(Vec::new()));
let rec = seen.clone();
std::thread::spawn(move || {
for (code, body) in replies {
let Ok((mut s, _)) = l.accept() else { return };
let mut r = BufReader::new(s.try_clone().unwrap());
let mut first = String::new();
r.read_line(&mut first).unwrap();
let mut len = 0usize;
loop {
let mut h = String::new();
r.read_line(&mut h).unwrap();
if h.trim().is_empty() {
break;
}
if let Some(v) = h.to_ascii_lowercase().strip_prefix("content-length:") {
len = v.trim().parse().unwrap_or(0);
}
}
let mut b = vec![0; len];
r.read_exact(&mut b).unwrap();
let parts: Vec<&str> = first.split_whitespace().collect();
rec.lock().unwrap().push(format!(
"{} {} {}",
parts[0],
parts[1],
String::from_utf8_lossy(&b)
));
let _ = write!(
s,
"HTTP/1.1 {code} X\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
}
});
(dir, seen)
}
#[test]
fn no_agent_file_means_not_running_with_no_reason() {
let dir = crate::agent::files::tests::tmp("session-none");
assert_eq!(agent_once(Some(&dir)), AgentState::NotRunning(None));
assert_eq!(agent_once(None), AgentState::NotRunning(None));
}
#[test]
fn a_running_agent_yields_its_summary() {
let (dir, _) = stub_agent(vec![(200, SUMMARY.into())]);
match agent_once(Some(&dir)) {
AgentState::Running(s) => assert_eq!(s.this_mac.name, "jeans-mbp"),
other => panic!("{other:?}"),
}
}
#[test]
fn a_dead_agent_port_is_not_running_with_a_reason() {
let (dir, _) = stub_agent(vec![]);
std::thread::sleep(Duration::from_millis(50));
assert!(matches!(
agent_once(Some(&dir)),
AgentState::NotRunning(Some(_))
));
}
#[test]
fn writes_put_the_agent_contract_bodies() {
assert_eq!(
write_request(&Write::Sharing(true)),
("/v1/sharing", serde_json::json!({"on": true}))
);
assert_eq!(
write_request(&Write::Workers(3)),
("/v1/workers", serde_json::json!({"count": 3}))
);
assert_eq!(
write_request(&Write::Price(22.0)),
(
"/v1/price",
serde_json::json!({"scope": "device", "price_per_hour": 22.0})
)
);
}
#[test]
fn apply_returns_the_new_summary_or_the_agents_message() {
let err = r#"{"error":{"code":"invalid_input","message":"price must be at most 120"}}"#;
let (dir, seen) = stub_agent(vec![(200, SUMMARY.into()), (400, err.into())]);
assert!(apply(Some(&dir), &Write::Workers(2)).is_ok());
assert_eq!(
apply(Some(&dir), &Write::Price(999.0)).unwrap_err(),
"price must be at most 120"
);
let seen = seen.lock().unwrap();
let (head, body) = seen[0].split_at("PUT /v1/workers ".len());
assert_eq!(head, "PUT /v1/workers ");
assert_eq!(
serde_json::from_str::<serde_json::Value>(body).unwrap(),
serde_json::json!({"count": 2})
);
assert!(seen[1].starts_with("PUT /v1/price "));
}
#[test]
fn refresh_posts_to_the_agent() {
let (dir, seen) = stub_agent(vec![(200, SUMMARY.into())]);
assert!(matches!(refresh_hub(Some(&dir)), AgentState::Running(_)));
assert!(seen.lock().unwrap()[0].starts_with("POST /v1/refresh"));
}
#[test]
fn the_cached_mesh_goes_out_before_the_live_one() {
let (tx, rx) = std::sync::mpsc::channel();
let _p = spawn_mesh_poller(
tx,
|| {
Some(MeshSnapshot {
as_of_secs: Some(999),
..Default::default()
})
},
|| {
std::thread::sleep(Duration::from_millis(200));
MeshSnapshot::default()
},
);
let first = rx
.recv_timeout(Duration::from_millis(100))
.expect("cached at once");
assert!(
matches!(first, Event::Mesh(ref m) if m.as_of_secs == Some(999)),
"{first:?}"
);
let second = rx.recv_timeout(Duration::from_secs(2)).unwrap();
assert!(
matches!(second, Event::Mesh(ref m) if m.as_of_secs.is_none()),
"{second:?}"
);
}
#[test]
fn without_a_running_broker_there_are_no_workers_and_a_reason() {
let (w, err) = local_workers_from(|| None, |_| unreachable!("nothing to fetch"));
assert!(w.is_empty());
assert!(err
.unwrap()
.contains("no broker is running on this machine"));
let (w, err) = local_workers_from(
|| Some("http://127.0.0.1:9000".into()),
|u| Ok(vec![serde_json::json!({"name": u})]),
);
assert_eq!(w.len(), 1);
assert!(err.is_none());
}
#[test]
fn a_live_listing_saves_what_it_probed() {
use crate::{ListedBroker, Listing};
let saved = std::cell::Cell::new(false);
let fresh = (
vec![ListedBroker {
fp: "aaaa".into(),
name: None,
is_self: false,
..Default::default()
}],
Listing::Directory {
unreachable: 0,
offline: 0,
as_of_secs: None,
},
);
let (b, _) = live_listing(|| Some(fresh.clone()), |_, _| saved.set(true), || None);
assert_eq!(b[0].fp, "aaaa");
assert!(saved.get());
}
#[test]
fn without_the_hub_the_live_listing_falls_back_to_the_cache_then_local_only() {
use crate::{ListedBroker, Listing};
let cached = (
vec![ListedBroker {
fp: "cccc".into(),
name: None,
is_self: false,
..Default::default()
}],
Listing::Directory {
unreachable: 0,
offline: 0,
as_of_secs: Some(60),
},
);
let (b, _) = live_listing(
|| None,
|_, _| panic!("nothing to save"),
|| Some(cached.clone()),
);
assert_eq!(b[0].fp, "cccc");
let (b, l) = live_listing(|| None, |_, _| panic!("nothing to save"), || None);
assert!(b.is_empty());
assert!(matches!(l, Listing::LocalOnly(_)));
}
#[test]
fn execute_apply_sends_done() {
let (dir, _) = stub_agent(vec![(200, SUMMARY.into())]);
let (tx, rx) = std::sync::mpsc::channel();
let (ptx, _prx) = std::sync::mpsc::channel();
let pollers = Pollers {
mesh: ptx,
market: std::sync::mpsc::channel().0,
};
execute(
Effect::Apply(Write::Sharing(false)),
&tx,
&pollers,
Some(dir),
);
match rx.recv_timeout(Duration::from_secs(5)).unwrap() {
Event::Done(Write::Sharing(false), Ok(_)) => {}
other => panic!("{other:?}"),
}
}
}