SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Control channel: a timed-out request says it is still running, and its result can be asked for (#1618) (#1627)
DuBearte7f79443b4698
diff --git a/apps/solidcraft/src/control_server.rs b/apps/solidcraft/src/control_server.rsindex 2e566afccb..8680d0cd15 100644--- a/apps/solidcraft/src/control_server.rs+++ b/apps/solidcraft/src/control_server.rs@@ -4,7 +4,7 @@use std::io::{BufRead, BufReader, Write};use std::net::{TcpListener, TcpStream};use std::sync::atomic::{AtomicUsize, Ordering};-use std::sync::mpsc::{Receiver, Sender, channel};+use std::sync::mpsc::{Receiver, Sender, TryRecvError, channel};use std::time::Duration;use serde_json::{Value, json};@@ -160,12 +160,35 @@ fn refuse(out: &mut TcpStream, reader: &mut BufReader<TcpStream>) {let _ = std::io::copy(&mut reader.by_ref().take(64 * 1024), &mut std::io::sink());}+/// How long a request waits for the app's reply: most requests, and a batch (or every request,+/// on a patient connection).+#[derive(Clone, Copy)]+struct Waits {+ short: Duration,+ long: Duration,+}++const WAITS: Waits = Waits { short: Duration::from_secs(60), long: Duration::from_secs(3600) };++/// A request that timed out but is still running in the app (#1618): its id and method, and where+/// its reply will land.+struct Pending {+ id: Value,+ method: String,+ reply: Receiver<Value>,+}+fn serve(stream: TcpStream, token: &str, tx: Sender<ControlRequest>, ctx: egui::Context, patient: bool) {+ serve_with(stream, token, tx, ctx, patient, WAITS);+}++fn serve_with(stream: TcpStream, token: &str, tx: Sender<ControlRequest>, ctx: egui::Context, patient: bool, waits: Waits) {let Ok(read) = stream.try_clone() else { return };let mut out = stream;let mut reader = BufReader::new(read);let mut bad = 0usize;let mut authenticated = false;+ let mut pending: Option<Pending> = None;loop {let line = match read_line(&mut reader, MAX_LINE) {Ok(Some(l)) => String::from_utf8_lossy(&l).into_owned(),@@ -193,14 +216,46 @@ fn serve(stream: TcpStream, token: &str, tx: Sender<ControlRequest>, ctx: egui::let id = msg.get("id").cloned().unwrap_or(Value::Null);let method = msg.get("method").and_then(Value::as_str).unwrap_or("").to_string();let params = msg.get("params").cloned().unwrap_or(json!({}));- // A batch replaces many short requests: the whole of it may take long (#743).- let wait = Duration::from_secs(if patient || method == "engine.batch" { 3600 } else { 60 });- let (req, rrx) = ControlRequest::new(method, params);- if tx.send(req).is_err() {- break;- }- ctx.request_repaint();- let mut r = rrx.recv_timeout(wait).unwrap_or_else(|_| json!({"ok": false, "error": "timeout"}));+ // A request that timed out may have finished since (#1618).+ let late = pending.as_ref().and_then(|p| match p.reply.try_recv() {+ Ok(reply) => Some(reply),+ Err(TryRecvError::Disconnected) => Some(json!({"ok": false, "error": "the app ended the request without a reply"})),+ Err(TryRecvError::Empty) => None,+ });+ let mut r = if method == "control.pending" {+ match (pending.take(), late) {+ (None, _) => json!({"ok": true, "result": {"pending": null}}),+ (Some(p), Some(reply)) => json!({"ok": true, "result": {"pending": p.id, "method": p.method, "done": true, "reply": reply}}),+ (Some(p), None) => {+ let r = json!({"ok": true, "result": {"pending": p.id, "method": p.method, "done": false}});+ pending = Some(p);+ r+ }+ }+ } else if let Some(p) = pending.as_ref().filter(|_| late.is_none()) {+ // Nothing more is queued behind it, to run unseen when it ends.+ json!({"ok": false, "busy": true, "error": format!("busy: request {} (`{}`) is still running; ask `control.pending` for its result", p.id, p.method)})+ } else {+ if late.is_some() {+ // Finished, and the client moved on without asking: it is dropped.+ pending = None;+ }+ // A batch replaces many short requests: the whole of it may take long (#743).+ let wait = if patient || method == "engine.batch" { waits.long } else { waits.short };+ let (req, rrx) = ControlRequest::new(method.clone(), params);+ if tx.send(req).is_err() {+ break;+ }+ ctx.request_repaint();+ match rrx.recv_timeout(wait) {+ Ok(r) => r,+ Err(_) => {+ let r = json!({"ok": false, "running": true, "error": format!("timeout: `{method}` is still running in the app and will still apply; ask `control.pending` for its result")});+ pending = Some(Pending { id: id.clone(), method, reply: rrx });+ r+ }+ }+ };if let Some(o) = r.as_object_mut() {o.insert("id".into(), id);}@@ -228,6 +283,62 @@ fn serve(stream: TcpStream, token: &str, tx: Sender<ControlRequest>, ctx: egui::mod tests {use super::*;+ /// #1618: a request that outlasts its wait says it is still running; the connection keeps its+ /// reply for `control.pending`, and refuses other requests as `busy` until it lands, so none+ /// is queued to run unseen behind it.+ #[test]+ fn a_timed_out_request_can_be_asked_for_later() {+ let token = "0123456789abcdef0123456789abcdef";+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let addr = listener.local_addr().unwrap();+ let (tx, rx) = channel::<ControlRequest>();+ let ran = std::sync::Arc::new(std::sync::Mutex::new(Vec::<String>::new()));+ let seen = ran.clone();+ std::thread::spawn(move || {+ for req in rx {+ seen.lock().unwrap().push(req.method.clone());+ if req.method == "slow" {+ std::thread::sleep(Duration::from_millis(400));+ }+ let _ = req.reply.send(json!({"ok": true, "result": req.method}));+ }+ });+ let waits = Waits { short: Duration::from_millis(100), long: Duration::from_millis(100) };+ std::thread::spawn(move || {+ if let Some(stream) = listener.incoming().flatten().next() {+ serve_with(stream, token, tx, egui::Context::default(), false, waits);+ }+ });+ let s = TcpStream::connect(addr).unwrap();+ s.set_read_timeout(Some(Duration::from_secs(10))).unwrap();+ let mut out = s.try_clone().unwrap();+ let mut lines = BufReader::new(s);+ let mut ask = |v: Value| -> Value {+ writeln!(out, "{v}").unwrap();+ let mut l = String::new();+ lines.read_line(&mut l).unwrap();+ serde_json::from_str(&l).unwrap()+ };+ let r = ask(json!({"id": 1, "method": "slow", "token": token}));+ assert!(r["ok"] == false && r["running"] == true && r["error"].as_str().is_some_and(|e| e.starts_with("timeout")), "{r}");+ let r = ask(json!({"id": 2, "method": "ui.view"}));+ assert!(r["busy"] == true && r["id"] == 2, "{r}");+ let r = ask(json!({"id": 3, "method": "control.pending"}));+ assert_eq!((&r["result"]["pending"], &r["result"]["done"]), (&json!(1), &json!(false)), "{r}");+ std::thread::sleep(Duration::from_millis(600));+ let r = ask(json!({"id": 4, "method": "control.pending"}));+ assert_eq!(+ (&r["result"]["pending"], &r["result"]["done"], &r["result"]["reply"]["result"]),+ (&json!(1), &json!(true), &json!("slow")),+ "{r}"+ );+ let r = ask(json!({"id": 5, "method": "control.pending"}));+ assert_eq!(r["result"]["pending"], Value::Null, "{r}");+ let r = ask(json!({"id": 6, "method": "ui.view"}));+ assert_eq!((&r["ok"], &r["result"]), (&json!(true), &json!("ui.view")), "{r}");+ assert_eq!(*ran.lock().unwrap(), ["slow", "ui.view"], "the busy request never reached the app");+ }+/// #205: a connection runs nothing until a request carries the launch's token; a wrong or/// missing token, or garbage, is refused and the connection closed. Once shown, the token/// need not be repeated on that connection.diff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex 142ea26397..ebddf4c343 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -48,7 +48,16 @@ connections that send eight lines that are not JSON. At most 16 connections are(further ones get `{"ok": false, "error": "too many connections"}`), at most 64 queued requestsrun per frame so a flood cannot starve drawing, and a request that the UI thread has notanswered within 60 seconds (3600 seconds for `engine.batch`) is replied to with-`{"ok": false, "error": "timeout"}`. The same 16 MiB line limit applies to the MCP server.+`{"ok": false, "running": true, "error": "timeout: … is still running …"}`. The same 16 MiB line+limit applies to the MCP server.++A timed-out request has not failed: it is still running in the app and will still apply (a long+fillet, say), so don't simply send it again. The connection keeps its reply (#1618). Ask for it+with `control.pending`: `{"pending": <id>, "method": …, "done": false}` while it runs, then+`{"pending": <id>, "method": …, "done": true, "reply": {…}}` (its own reply, once), and+`{"pending": null}` when nothing is outstanding. Until it lands, any other request on that+connection is refused at once with `{"ok": false, "busy": true, "error": "busy: …"}` and not+run, so nothing is queued to apply unseen behind it.Any request's `params` may carry `allow_paths: ["/abs/folder", …]`: every file that requestreads, writes or deletes (command paths such as `file.export`'s `path` or `doc.recovery_*`'s