use std::time::Duration;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MeshBroker {
pub fp: String,
pub endpoint: Option<String>,
pub revoked: bool,
}
impl MeshBroker {
pub fn node_uri(&self) -> String {
format!("zc://node-{}", self.fp)
}
}
#[derive(Debug, Clone)]
pub struct BrokerProbe {
pub broker: MeshBroker,
pub reachable: bool,
pub node_name: Option<String>,
pub mesh_tunnel: Option<String>,
pub build: Option<crate::build_id::BuildId>,
pub owner_user_id: Option<String>,
}
pub fn parse_roster(body: &str) -> Vec<MeshBroker> {
let v: serde_json::Value = match serde_json::from_str(body) {
Ok(v) => v,
Err(_) => return Vec::new(),
};
v.as_array()
.map(|arr| {
arr.iter()
.filter_map(|e| {
let pk = e.get("node_pubkey")?.as_str()?;
let fp = crate::broker::node_identity::fingerprint_of_pubkey_b64(pk)?;
let revoked = e.get("revoked").and_then(|r| r.as_bool()).unwrap_or(false);
let endpoint = e
.get("mesh_endpoint")
.and_then(|m| m.as_str())
.map(str::trim)
.filter(|s| !s.is_empty())
.map(str::to_string);
Some(MeshBroker {
fp,
endpoint,
revoked,
})
})
.collect()
})
.unwrap_or_default()
}
pub fn fetch_from_hub() -> Result<Vec<MeshBroker>, String> {
crate::credentials::load_into_env();
let api_key = std::env::var("ZAKURO_API_KEY")
.ok()
.filter(|k| !k.trim().is_empty())
.ok_or_else(|| "not signed in (run `zc login` or set ZAKURO_API_KEY)".to_string())?;
let api_url = crate::credentials::default_api_url();
let endpoint = format!("{}/api/broker/node/roster", api_url.trim_end_matches('/'));
let resp = ureq::get(&endpoint)
.config()
.timeout_global(Some(Duration::from_secs(10)))
.http_status_as_error(false)
.build()
.header("X-Broker-Api-Key", &api_key)
.call()
.map_err(|e| format!("roster request failed: {e}"))?;
let status = resp.status().as_u16();
if status != 200 {
return Err(format!("roster HTTP {status} from {api_url}"));
}
let body = resp
.into_body()
.read_to_string()
.map_err(|e| format!("roster read failed: {e}"))?;
Ok(parse_roster(&body))
}
pub fn load_cached() -> Vec<MeshBroker> {
let cache = crate::broker::roster_cache::RosterCache::load();
cache
.entries()
.into_iter()
.filter_map(|(pk, revoked)| {
let fp = crate::broker::node_identity::fingerprint_of_pubkey_b64(&pk)?;
let endpoint = cache.endpoint_for_fingerprint(&fp);
Some(MeshBroker {
fp,
endpoint,
revoked,
})
})
.collect()
}
pub fn directory() -> Result<Vec<MeshBroker>, String> {
match fetch_from_hub() {
Ok(list) => Ok(list),
Err(e) => {
let cached = load_cached();
if cached.is_empty() {
Err(e)
} else {
crate::vpn::vlog(&format!(
"hub roster unavailable ({e}); using cached roster"
));
Ok(cached)
}
}
}
}
pub fn endpoint_for(arg: &str) -> Option<String> {
let fp = crate::broker::node_identity::strip_node_arg(arg);
directory()
.ok()?
.into_iter()
.find(|b| b.fp == fp && !b.revoked)
.and_then(|b| b.endpoint)
}
pub fn looks_like_fingerprint(s: &str) -> bool {
s.len() == 16
&& s.bytes()
.all(|b| b.is_ascii_hexdigit() && !b.is_ascii_uppercase())
}
fn owner_via_peer_identity(agent: &ureq::Agent, endpoint: &str) -> Option<String> {
let key = crate::credentials::load_mesh_peer_key()?;
let url = format!("http://{}/peer/identity", endpoint);
let body = agent
.get(&url)
.header("X-Peer-Key", &key)
.call()
.ok()?
.into_body()
.read_to_string()
.ok()?;
let json: serde_json::Value = serde_json::from_str(&body).ok()?;
json.get("owner_user_id")?
.as_str()
.filter(|s| !s.trim().is_empty())
.map(str::to_string)
}
pub fn probe_all(brokers: Vec<MeshBroker>, timeout: Duration) -> Vec<BrokerProbe> {
probe_all_within(brokers, timeout, timeout)
}
pub const LISTING_DEADLINE: Duration = Duration::from_millis(1500);
pub fn probe_all_within(
brokers: Vec<MeshBroker>,
timeout: Duration,
deadline: Duration,
) -> Vec<BrokerProbe> {
let started = std::time::Instant::now();
let (tx, rx) = std::sync::mpsc::channel::<BrokerProbe>();
let expected: Vec<MeshBroker> = brokers.clone();
for b in brokers {
let tx = tx.clone();
std::thread::spawn(move || {
let _ = tx.send((move || {
let Some(ep) = b.endpoint.clone() else {
return BrokerProbe {
broker: b,
reachable: false,
node_name: None,
mesh_tunnel: None,
build: None,
owner_user_id: None,
};
};
let url = format!("http://{}/health", ep);
let agent = crate::vpn::mesh_agent_for(&url, timeout);
let json: Option<serde_json::Value> = agent
.get(&url)
.call()
.ok()
.and_then(|r| r.into_body().read_to_string().ok())
.and_then(|t| serde_json::from_str(&t).ok());
let is_broker = json
.as_ref()
.and_then(|j| j.get("service"))
.and_then(|s| s.as_str())
== Some("zakuro-broker");
BrokerProbe {
node_name: json
.as_ref()
.and_then(|j| j.get("node_name"))
.and_then(|s| s.as_str())
.map(str::to_string),
mesh_tunnel: json
.as_ref()
.and_then(|j| j.get("mesh_tunnel"))
.and_then(|s| s.as_str())
.map(str::to_string),
build: json
.as_ref()
.and_then(|j| j.get("build"))
.cloned()
.and_then(|b| serde_json::from_value(b).ok())
.filter(crate::build_id::BuildId::is_known),
owner_user_id: json
.as_ref()
.and_then(|j| j.get("owner_user_id"))
.and_then(|s| s.as_str())
.filter(|s| !s.trim().is_empty())
.map(str::to_string)
.or_else(|| {
is_broker
.then(|| owner_via_peer_identity(&agent, &ep))
.flatten()
}),
reachable: is_broker,
broker: b,
}
})());
});
}
drop(tx);
let mut out: Vec<BrokerProbe> = Vec::new();
while out.len() < expected.len() {
let left = deadline.saturating_sub(started.elapsed());
match rx.recv_timeout(left) {
Ok(p) => out.push(p),
Err(_) => break,
}
}
for b in expected {
if !out.iter().any(|p| p.broker.fp == b.fp) {
out.push(BrokerProbe {
broker: b,
reachable: false,
node_name: None,
mesh_tunnel: None,
build: None,
owner_user_id: None,
});
}
}
out.sort_by(|a, b| {
b.reachable
.cmp(&a.reachable)
.then_with(|| a.broker.fp.cmp(&b.broker.fp))
});
out
}
const NAME_WIDTH: usize = 24;
const OWNER_WIDTH: usize = 13;
fn truncate_to(s: &str, width: usize) -> String {
if s.chars().count() <= width {
return s.to_string();
}
s.chars().take(width.saturating_sub(1)).collect::<String>() + "…"
}
pub fn reconcile_builds(probes: &[BrokerProbe]) -> String {
use colored::Colorize;
let reachable: Vec<&BrokerProbe> = probes.iter().filter(|p| p.reachable).collect();
if reachable.is_empty() {
return String::new();
}
let mut labels: Vec<String> = reachable
.iter()
.filter_map(|p| p.build.as_ref())
.map(|b| b.label())
.collect();
let undisclosed = reachable.len() - labels.len();
labels.sort();
labels.dedup();
let mut line = match labels.len() {
0 => format!(
" {} none of the {} reachable broker(s) disclose a build\n",
"⚠".yellow(),
reachable.len()
),
1 => format!(
" {} all {} reachable broker(s) on {}\n",
"✓".green(),
reachable.len() - undisclosed,
labels[0].bold()
),
n => {
let mut s = format!(
" {} {} distinct builds across {} reachable broker(s):\n",
"⚠".yellow(),
n,
reachable.len()
);
for l in &labels {
let count = reachable
.iter()
.filter(|p| p.build.as_ref().map(|b| b.label()).as_deref() == Some(l))
.count();
s.push_str(&format!(" {:>2} × {}\n", count, l));
}
s
}
};
if undisclosed > 0 && !labels.is_empty() {
line.push_str(&format!(
" {:>2} × {}\n",
undisclosed,
"build undisclosed".dimmed()
));
}
line
}
pub fn render(
probes: &[BrokerProbe],
self_fp: Option<&str>,
offline_without_endpoint: usize,
) -> String {
use colored::Colorize;
let mut out = String::new();
let live: Vec<&BrokerProbe> = probes
.iter()
.filter(|p| p.broker.endpoint.is_some())
.collect();
if live.is_empty() {
out.push_str(" No brokers currently advertise a mesh endpoint.\n");
} else {
out.push_str(&format!(
" {} broker(s) on the mesh:\n",
live.iter().filter(|p| p.reachable).count()
));
for p in live {
let mark = if p.reachable {
"✓".green().to_string()
} else {
"✗".red().to_string()
};
let me = if self_fp == Some(p.broker.fp.as_str()) {
" (this machine)".dimmed().to_string()
} else {
String::new()
};
let name = truncate_to(p.node_name.as_deref().unwrap_or("-"), NAME_WIDTH);
let tunnel = match p.mesh_tunnel.as_deref() {
Some("up") => "tunnel up".to_string(),
Some("down") => "tunnel down".yellow().to_string(),
_ if p.reachable => String::new(),
_ => "unreachable".dimmed().to_string(),
};
let build = match (&p.build, p.reachable) {
(Some(b), _) => b.label(),
(None, true) => "build undisclosed".to_string(),
(None, false) => "-".to_string(),
};
let owner = match (&p.owner_user_id, p.reachable) {
(Some(o), _) => truncate_to(o, OWNER_WIDTH),
(None, true) => "owner unset".to_string(),
(None, false) => "-".to_string(),
};
out.push_str(&format!(
" {} {} {:<name_w$} {:<32} {:<owner_w$} {}{}\n",
mark,
p.broker.node_uri().bold(),
name,
build,
owner,
tunnel,
me,
name_w = NAME_WIDTH,
owner_w = OWNER_WIDTH
));
}
out.push_str(&reconcile_builds(probes));
}
if offline_without_endpoint > 0 {
out.push_str(&format!(
" {} registered node(s) without a mesh endpoint (offline).\n",
offline_without_endpoint
));
}
out
}
#[cfg(test)]
mod tests {
use super::*;
const PK_A: &str = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
const PK_B: &str = "//////////////////////////////////////////8=";
#[test]
fn parses_roster_rows_into_fingerprints_and_endpoints() {
let body = format!(
r#"[{{"node_pubkey":"{PK_A}","revoked":false,"mesh_endpoint":"10.13.13.33:9000"}},
{{"node_pubkey":"{PK_B}","revoked":true,"mesh_endpoint":null}},
{{"node_pubkey":"not base64!!","revoked":false}}]"#
);
let list = parse_roster(&body);
assert_eq!(list.len(), 2, "undecodable pubkeys are dropped");
let a = &list[0];
assert!(looks_like_fingerprint(&a.fp), "fp={}", a.fp);
assert_eq!(a.endpoint.as_deref(), Some("10.13.13.33:9000"));
assert!(!a.revoked);
assert_eq!(
a.fp,
crate::broker::node_identity::fingerprint_of_pubkey_b64(PK_A).unwrap()
);
assert!(list[1].revoked);
assert!(list[1].endpoint.is_none());
assert_eq!(a.node_uri(), format!("zc://node-{}", a.fp));
}
#[test]
fn fingerprint_shape() {
assert!(looks_like_fingerprint("13a9551e881f7f8c"));
assert!(!looks_like_fingerprint("13A9551E881F7F8C"));
assert!(!looks_like_fingerprint("13a9551e881f7f8"));
assert!(!looks_like_fingerprint("localhost"));
assert!(!looks_like_fingerprint("zc-broker-1"));
}
#[test]
fn probe_marks_endpointless_nodes_unreachable_without_dialing() {
let list = vec![MeshBroker {
fp: "0123456789abcdef".into(),
endpoint: None,
revoked: false,
}];
let probes = probe_all(list, Duration::from_millis(50));
assert_eq!(probes.len(), 1);
assert!(!probes[0].reachable);
assert!(probes[0].node_name.is_none());
}
#[test]
fn probe_accepts_only_a_zakuro_broker_health_body() {
use std::io::{Read, Write};
use std::net::TcpListener;
let good = TcpListener::bind("127.0.0.1:0").unwrap();
let good_addr = good.local_addr().unwrap();
std::thread::spawn(move || {
if let Ok((mut s, _)) = good.accept() {
let mut buf = [0u8; 1024];
let _ = s.read(&mut buf);
let body = r#"{"status":"healthy","service":"zakuro-broker","node_name":"fake-1","mesh_tunnel":"up","build":{"version":"0.0.33","git":"0447049","binary_sha256":"aaaaaaaaaaaabbbbbbbbbbbbccccccccccccddddddddddddeeeeeeeeeeeeffff"}}"#;
let _ = write!(
s,
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
}
});
let bad = TcpListener::bind("127.0.0.1:0").unwrap();
let bad_addr = bad.local_addr().unwrap();
std::thread::spawn(move || {
if let Ok((mut s, _)) = bad.accept() {
let mut buf = [0u8; 1024];
let _ = s.read(&mut buf);
let body = "<!doctype html><html></html>";
let _ = write!(
s,
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
}
});
let list = vec![
MeshBroker {
fp: "aaaaaaaaaaaaaaaa".into(),
endpoint: Some(good_addr.to_string()),
revoked: false,
},
MeshBroker {
fp: "bbbbbbbbbbbbbbbb".into(),
endpoint: Some(bad_addr.to_string()),
revoked: false,
},
];
let probes = probe_all(list, Duration::from_secs(3));
let good_p = probes
.iter()
.find(|p| p.broker.fp == "aaaaaaaaaaaaaaaa")
.unwrap();
let bad_p = probes
.iter()
.find(|p| p.broker.fp == "bbbbbbbbbbbbbbbb")
.unwrap();
assert!(good_p.reachable);
assert_eq!(good_p.node_name.as_deref(), Some("fake-1"));
assert_eq!(good_p.mesh_tunnel.as_deref(), Some("up"));
let build = good_p.build.as_ref().expect("health disclosed a build");
assert_eq!(build.version, "0.0.33");
assert_eq!(build.git.as_deref(), Some("0447049"));
assert_eq!(build.short_hash(), Some("aaaaaaaaaaaa"));
assert!(!bad_p.reachable, "an HTML 200 is not a broker");
assert!(bad_p.build.is_none());
assert_eq!(probes[0].broker.fp, "aaaaaaaaaaaaaaaa");
}
#[test]
fn render_is_ip_free() {
let probes = vec![BrokerProbe {
owner_user_id: None,
broker: MeshBroker {
fp: "0123456789abcdef".into(),
endpoint: Some("10.13.13.33:9000".into()),
revoked: false,
},
reachable: true,
node_name: Some("zc-broker-1".into()),
mesh_tunnel: Some("up".into()),
build: None,
}];
let text = render(&probes, Some("0123456789abcdef"), 3);
assert!(text.contains("zc://node-0123456789abcdef"));
assert!(text.contains("zc-broker-1"));
assert!(text.contains("(this machine)"));
assert!(text.contains("3 registered node(s) without a mesh endpoint"));
assert!(
!text.contains("10.13.13"),
"must never print an address: {text}"
);
}
#[test]
fn the_table_names_the_owner_of_every_reachable_node() {
let mut owned = probe("aaaaaaaaaaaaaaaa", true, None);
owned.owner_user_id = Some("5492316032".into());
owned.broker.endpoint = Some("10.13.13.35:9000".into());
let mut unowned = probe("bbbbbbbbbbbbbbbb", true, None);
unowned.owner_user_id = None;
unowned.broker.endpoint = Some("10.13.13.36:9000".into());
let text = render(&[owned, unowned], None, 0);
assert!(text.contains("5492316032"), "owner id must appear: {text}");
assert!(
text.contains("owner unset"),
"an unowned node says so: {text}"
);
assert!(!text.contains("10.13.13."), "no addresses: {text}");
}
fn probe(fp: &str, reachable: bool, build: Option<crate::build_id::BuildId>) -> BrokerProbe {
BrokerProbe {
owner_user_id: None,
broker: MeshBroker {
fp: fp.into(),
endpoint: Some("10.13.13.33:9000".into()),
revoked: false,
},
reachable,
node_name: Some(format!("zc-broker-{fp}")),
mesh_tunnel: Some("up".into()),
build,
}
}
fn build(version: &str, git: &str, hash_byte: &str) -> Option<crate::build_id::BuildId> {
Some(crate::build_id::BuildId {
version: version.into(),
git: Some(git.into()),
binary_sha256: Some(hash_byte.repeat(32)),
})
}
#[test]
fn a_silent_broker_costs_the_deadline_not_the_timeout() {
let l = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let ep = l.local_addr().unwrap().to_string();
let held = std::thread::spawn(move || {
let _c = l.accept();
std::thread::sleep(Duration::from_secs(3));
});
let started = std::time::Instant::now();
let probes = probe_all_within(
vec![MeshBroker {
fp: "aaaaaaaaaaaaaaaa".into(),
endpoint: Some(ep),
revoked: false,
}],
Duration::from_secs(5),
Duration::from_millis(300),
);
assert!(
started.elapsed() < Duration::from_secs(2),
"{:?}",
started.elapsed()
);
assert_eq!(probes.len(), 1);
assert!(!probes[0].reachable);
drop(held);
}
#[test]
fn a_uniform_mesh_is_reported_as_uniform() {
let probes = vec![
probe("aaaaaaaaaaaaaaaa", true, build("0.0.33", "0447049", "ab")),
probe("bbbbbbbbbbbbbbbb", true, build("0.0.33", "0447049", "ab")),
];
let text = reconcile_builds(&probes);
assert!(text.contains("all 2 reachable broker(s) on"), "{text}");
assert!(text.contains("0.0.33 (0447049) sha:ababababab"), "{text}");
assert!(!text.contains("distinct builds"), "{text}");
}
#[test]
fn differing_builds_are_counted_and_listed() {
let probes = vec![
probe("aaaaaaaaaaaaaaaa", true, build("0.0.33", "0447049", "ab")),
probe("bbbbbbbbbbbbbbbb", true, build("0.0.33", "0447049", "ab")),
probe("cccccccccccccccc", true, build("0.0.31", "9911223", "cd")),
];
let text = reconcile_builds(&probes);
assert!(
text.contains("2 distinct builds across 3 reachable broker(s)"),
"{text}"
);
assert!(text.contains(" 2 × 0.0.33 (0447049)"), "{text}");
assert!(text.contains(" 1 × 0.0.31 (9911223)"), "{text}");
}
#[test]
fn two_artifacts_of_one_commit_count_as_two_builds() {
let probes = vec![
probe("aaaaaaaaaaaaaaaa", true, build("0.0.33", "0447049", "ab")),
probe("bbbbbbbbbbbbbbbb", true, build("0.0.33", "0447049", "cd")),
];
let text = reconcile_builds(&probes);
assert!(text.contains("2 distinct builds"), "{text}");
}
#[test]
fn undisclosed_builds_are_counted_apart_from_real_skew() {
let probes = vec![
probe("aaaaaaaaaaaaaaaa", true, build("0.0.33", "0447049", "ab")),
probe("bbbbbbbbbbbbbbbb", true, None),
];
let text = reconcile_builds(&probes);
assert!(text.contains("all 1 reachable broker(s) on"), "{text}");
assert!(text.contains("1 × build undisclosed"), "{text}");
assert!(!text.contains("distinct builds"), "{text}");
}
#[test]
fn unreachable_brokers_do_not_count_towards_skew() {
let probes = vec![
probe("aaaaaaaaaaaaaaaa", true, build("0.0.33", "0447049", "ab")),
probe("bbbbbbbbbbbbbbbb", false, build("0.0.31", "9911223", "cd")),
];
let text = reconcile_builds(&probes);
assert!(text.contains("all 1 reachable broker(s) on"), "{text}");
assert!(!text.contains("0.0.31"), "{text}");
}
#[test]
fn nothing_reachable_reconciles_to_nothing() {
let probes = vec![probe("aaaaaaaaaaaaaaaa", false, None)];
assert_eq!(reconcile_builds(&probes), "");
}
#[test]
fn a_long_node_name_is_ellipsized_so_the_build_column_stays_put() {
let mut long = probe("aaaaaaaaaaaaaaaa", true, build("0.0.33", "0447049", "ab"));
long.node_name = Some("ip-192-168-120-124.ap-northeast-1.compute.internal".into());
let short = probe("bbbbbbbbbbbbbbbb", true, build("0.0.33", "0447049", "ab"));
let text = render(&[long, short], None, 0);
let col = |line: &str| line.find("0.0.33 (0447049)").expect("build on the row");
let rows: Vec<&str> = text.lines().filter(|l| l.contains("zc://node-")).collect();
assert_eq!(rows.len(), 2, "{text}");
assert_eq!(
col(rows[0]),
col(rows[1]),
"the build column must line up:\n{text}"
);
assert!(
text.contains('…'),
"the long name was not ellipsized: {text}"
);
}
#[test]
fn truncate_to_leaves_a_short_name_alone_and_counts_chars() {
assert_eq!(truncate_to("zc-broker-1", 24), "zc-broker-1");
assert_eq!(truncate_to("abcdef", 4), "abc…");
assert_eq!(truncate_to("ノードいちにさん", 4), "ノード…");
}
#[test]
fn render_prints_the_build_column_and_the_summary() {
let probes = vec![
probe("aaaaaaaaaaaaaaaa", true, build("0.0.33", "0447049", "ab")),
probe("bbbbbbbbbbbbbbbb", true, build("0.0.31", "9911223", "cd")),
];
let text = render(&probes, None, 0);
assert!(text.contains("0.0.33 (0447049) sha:ababababab"), "{text}");
assert!(text.contains("0.0.31 (9911223) sha:cdcdcdcdcd"), "{text}");
assert!(text.contains("2 distinct builds"), "{text}");
assert!(!text.contains("10.13.13"), "still IP-free: {text}");
}
}