use std::path::Path;
use std::time::Duration;
use serde_json::json;
use crate::boundary::dispatch::Deps;
use crate::boundary::reply::{Place, Placed};
use crate::bz_host::far::{TOOL, machines, split};
use crate::config_edit::brazen::{BzOutcome, ProviderRow, ProviderRowView, provider_rows};
use crate::registry::mailbox::{Call, Capture};
use crate::registry::{Client, seen, tools};
const WAITS: u32 = 120;
const TICK: Duration = Duration::from_millis(25);
pub(crate) fn named(deps: &Deps, workspace: &Path, provider: &str) -> Option<Place> {
let registered = machines(&deps.state_root, &crate::naming::leaf(workspace));
split(provider, ®istered).map(|(row, client)| Place { client, row })
}
fn advertises(deps: &Deps, client: &str) -> bool {
Client::parse(client).is_ok_and(|client| {
tools::read(&deps.state_root, &client)
.iter()
.any(|tool| tool.name == TOOL)
})
}
pub(crate) fn judged(
deps: &Deps,
workspace: &Path,
mut rows: Vec<ProviderRow>,
names: &[&str],
) -> Vec<ProviderRow> {
if rows.is_empty() {
return rows;
}
for name in names {
let far = named(deps, workspace, name).is_some_and(|at| advertises(deps, &at.client));
if far && !rows.iter().any(|row| row.name == *name) {
rows.push(ProviderRow {
name: (*name).to_owned(),
protocol: String::new(),
auth: String::new(),
credential: String::new(),
effort: false,
priority: false,
tools: None,
device: String::new(),
});
}
}
rows
}
fn there(deps: &Deps, now: i64, client: &str) -> bool {
let mail = &deps.caller.mailbox;
mail.serving(client) || mail.busy(now, client) || seen::spoke(&deps.state_root, client, now)
}
fn asked(deps: &Deps, now: i64, clients: &[String], line: &[&str]) -> Vec<(String, Capture)> {
let mail = &deps.caller.mailbox;
let mut open: Vec<(Call, bool)> = clients
.iter()
.filter(|client| there(deps, now, client))
.map(|client| {
let call = Call {
client: client.clone(),
tool: TOOL.to_owned(),
input: json!({ "args": line }),
cwd: None,
};
let idle = !mail.busy(now, client);
mail.ask(now, &call);
(call, idle)
})
.collect();
for _ in 0..WAITS {
for (call, waiting) in open.iter_mut().filter(|(_, waiting)| *waiting) {
*waiting = mail.queued(now, call);
}
if !open.iter().any(|(_, waiting)| *waiting) {
break;
}
std::thread::sleep(TICK);
}
open.into_iter()
.filter_map(|(call, _)| {
let last = mail.known(&call)?;
Some((call.client, last))
})
.collect()
}
pub(crate) fn rows(
deps: &Deps,
now: i64,
workspace: &Path,
line: &[&str],
) -> Vec<Placed<ProviderRowView>> {
let hosts: Vec<String> = machines(&deps.state_root, &crate::naming::leaf(workspace))
.into_iter()
.filter(|client| advertises(deps, client))
.collect();
asked(deps, now, &hosts, line)
.into_iter()
.flat_map(|(client, capture)| {
provider_rows(&capture.stdout).into_iter().map(move |row| {
let name = format!("{}@{client}", row.name);
let at = Some(Place {
client: client.clone(),
row: row.name.clone(),
});
let row = ProviderRow { name, ..row }.view();
Placed { row, at }
})
})
.collect()
}
pub(crate) fn run(deps: &Deps, now: i64, client: &str, line: &[&str]) -> Result<BzOutcome, String> {
if !advertises(deps, client) {
return Err(format!(
"client {client:?} advertises no tool {TOOL:?} right now"
));
}
if !there(deps, now, client) {
return Err(format!(
"client {client:?} is not there right now — it is asleep, or gone; \
/clients says when it last connected"
));
}
let (_, capture) = asked(deps, now, &[client.to_owned()], line)
.pop()
.ok_or_else(|| {
format!(
"queued, not refused: this read is waiting on client {client:?} behind the \
call it is running, and the answer is kept here when it arrives — ask again"
)
})?;
Ok(BzOutcome {
success: capture.exit_code == 0,
stdout: capture.stdout,
stderr: capture.stderr,
})
}
#[cfg(test)]
mod tests;