use std::io::{Read, Write};
use std::path::PathBuf;
use std::sync::atomic::AtomicBool;
use serde_json::json;
use crate::registry::mailbox::stream::offsets_value;
use crate::registry::mailbox::{Offsets, Standing};
use crate::registry::{Client, roster, seen};
use crate::tool_host::ask::Budget;
use crate::tool_host::remote;
use crate::xdg::Env;
pub(crate) const TOOL: &str = "bz";
const PROVIDER: &str = "--provider";
const KIND: &str = "far_call";
pub(super) fn split(provider: &str, clients: &[String]) -> Option<(String, String)> {
clients
.iter()
.filter_map(|client| {
let row = provider.strip_suffix(client.as_str())?.strip_suffix('@')?;
(!row.is_empty()).then(|| (row.to_owned(), client.clone()))
})
.max_by_key(|(_, client)| client.len())
}
pub(super) struct Far {
pub(super) state_root: PathBuf,
pub(super) client: String,
pub(super) argv: Vec<String>,
pub(super) budget: Budget,
pub(super) patience: Budget,
}
pub(super) fn of(argv: &[String], env: &Env) -> Option<Far> {
if !matches!(brazen::route(argv), brazen::Route::Run) {
return None;
}
let at = argv.iter().position(|arg| arg == PROVIDER)? + 1;
let workspace = crate::naming::leaf(&env.wall()?);
let state_root = env.yog_state_root();
let clients: Vec<String> = roster::members(&state_root, &workspace)
.iter()
.map(Client::name)
.collect();
let (row, client) = split(argv.get(at)?, &clients)?;
let argv = argv
.iter()
.enumerate()
.map(|(i, arg)| if i == at { row.clone() } else { arg.clone() })
.collect();
Some(Far {
state_root,
client,
argv,
budget: Budget::default(),
patience: remote::patience(),
})
}
fn pass(
stdout: &mut dyn Write,
stderr: &mut dyn Write,
held: &mut Offsets,
piece: (&str, &str),
) -> Result<(), String> {
held.stdout += piece.0.len() as u64;
held.stderr += piece.1.len() as u64;
stdout
.write_all(piece.0.as_bytes())
.and_then(|()| stdout.flush())
.and_then(|()| stderr.write_all(piece.1.as_bytes()))
.map_err(|e| format!("relaying the stream: {e}"))
}
impl Far {
pub(super) fn run(
&self,
stdin: &mut dyn Read,
stdout: &mut dyn Write,
stderr: &mut dyn Write,
) -> i32 {
let mut held = Offsets::default();
match self.call(stdin, stdout, stderr, &mut held) {
Ok(code) => code,
Err(reason) if held.stdout > 0 => {
let _ = writeln!(stderr, "yog bz: {reason}");
1
}
Err(reason) => refuse(stdout, reason),
}
}
fn call(
&self,
stdin: &mut dyn Read,
stdout: &mut dyn Write,
stderr: &mut dyn Write,
held: &mut Offsets,
) -> Result<i32, String> {
let mut request = String::new();
stdin
.read_to_string(&mut request)
.map_err(|e| format!("reading the request: {e}"))?;
let stop = AtomicBool::new(false);
let ask = |gesture: serde_json::Value| -> Result<(String, Standing), String> {
remote::routed(&self.state_root, self.budget, &gesture, &self.client, &stop)
};
let (invocation, _) = ask(json!({
"op": "invoke", "client": self.client, "tool": TOOL,
"input": { "args": self.argv, "stdin": request },
}))?;
let (mut taken, mut waited) = (false, 0);
loop {
let (_, standing) = ask(json!({
"op": "capture", "invocation": invocation,
"since": offsets_value(*held),
}))?;
if let Some(piece) = standing.partial {
taken = true;
pass(stdout, stderr, held, (&piece.stdout, &piece.stderr))?;
}
if let Some(capture) = standing.capture {
pass(stdout, stderr, held, (&capture.stdout, &capture.stderr))?;
return Ok(capture.exit_code);
}
waited += u32::from(!taken);
if waited >= self.patience.waits {
return Err(self.untaken());
}
std::thread::sleep(self.patience.tick);
}
}
fn untaken(&self) -> String {
let last = Client::parse(&self.client)
.ok()
.and_then(|client| seen::read(&self.state_root, &client))
.map_or_else(
|| "it has never connected".to_owned(),
|at| {
format!(
"it last connected at {}",
crate::ui_state::iso8601_extended(at)
)
},
);
format!(
"client {:?} did not take this model call within {} seconds; {last}. It may be \
asleep, or busy with another call. Nothing ran, and nothing was sent to this \
server's own provider instead",
self.client,
self.patience.span().as_secs()
)
}
}
fn refuse(stdout: &mut dyn Write, message: String) -> i32 {
let error = brazen::CanonicalError {
kind: brazen::ErrorKind::Other(KIND.to_owned()),
message,
provider_detail: None,
retry_after_seconds: None,
};
let code = i32::from(error.exit_code());
for event in [brazen::Event::Error(error), brazen::Event::End] {
let line = serde_json::to_string(&event).unwrap_or_default();
let _ = writeln!(stdout, "{line}");
}
code
}
#[cfg(test)]
mod tests;