SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Control channel: write each reply in one piece (#6389) (#6390)
JK3D492bba9242b3
diff --git a/apps/solidcraft/src/control_server.rs b/apps/solidcraft/src/control_server.rsindex 3cb96e3326..d66178578b 100644--- a/apps/solidcraft/src/control_server.rs+++ b/apps/solidcraft/src/control_server.rs@@ -127,7 +127,7 @@ fn listen_on_listener(listener: TcpListener, token: String, tx: Sender<ControlReif OPEN.fetch_add(1, Ordering::Relaxed) >= MAX_CONNECTIONS {OPEN.fetch_sub(1, Ordering::Relaxed);let mut refused = stream;- let _ = writeln!(refused, "{}", json!({"ok": false, "error": "too many connections"}));+ let _ = send(&mut refused, &json!({"ok": false, "error": "too many connections"}));continue;}let tx = tx.clone();@@ -174,6 +174,15 @@ fn read_line(r: &mut impl BufRead, max: usize) -> std::io::Result<Option<Vec<u8>}}+/// A reply line, written to the socket at once. `writeln!` with a JSON value hands the socket each+/// of its pieces apart, a system call for every string, number and comma: half a second for a+/// design's component tree when it has thousands of components.+fn send(out: &mut impl Write, reply: &Value) -> std::io::Result<()> {+ let mut line = serde_json::to_vec(reply).map_err(std::io::Error::other)?;+ line.push(b'\n');+ out.write_all(&line)+}+/// The reply to a connection that didn't show the token; the connection is then closed.fn unauthorized() -> Value {json!({"ok": false, "error": "unauthorized: send the control token as \"token\" (see docs/control-protocol.md)"})@@ -184,7 +193,7 @@ fn unauthorized() -> Value {/// the connection, and a reset can reach the client before it has read the refusal.fn refuse(out: &mut TcpStream, reader: &mut BufReader<TcpStream>) {use std::io::Read;- let _ = writeln!(out, "{}", unauthorized());+ let _ = send(out, &unauthorized());let _ = out.shutdown(std::net::Shutdown::Write);let _ = reader.get_ref().set_read_timeout(Some(Duration::from_millis(500)));let _ = std::io::copy(&mut reader.by_ref().take(64 * 1024), &mut std::io::sink());@@ -381,7 +390,7 @@ fn serve_with(Ok(Some(l)) => String::from_utf8_lossy(&l).into_owned(),Ok(None) => break,Err(e) => {- let _ = writeln!(out, "{}", json!({"ok": false, "error": e.to_string()}));+ let _ = send(&mut out, &json!({"ok": false, "error": e.to_string()}));break;}};@@ -463,7 +472,7 @@ fn serve_with(json!({"ok": false, "error": format!("bad JSON: {e}")})}};- if writeln!(out, "{reply}").is_err() {+ if send(&mut out, &reply).is_err() {break;}if bad >= MAX_BAD_LINES {@@ -750,4 +759,31 @@ mod tests {let mut r = BufReader::with_capacity(64, text.as_slice());assert!(read_line(&mut r, 1000).is_err());}++ /// A large reply reaches the socket in one write, not one per JSON piece (a component tree of+ /// thousands of components took half a second to send), and reads back as it was.+ #[test]+ fn a_large_reply_is_written_at_once() {+ struct Counted {+ writes: usize,+ bytes: Vec<u8>,+ }+ impl Write for Counted {+ fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {+ self.writes += 1;+ self.bytes.extend_from_slice(buf);+ Ok(buf.len())+ }+ fn flush(&mut self) -> std::io::Result<()> {+ Ok(())+ }+ }+ let components: Vec<Value> = (0..2000).map(|i| json!({"id": i, "name": format!("Part {i}"), "bodies": ["a", "b"], "parent": 0})).collect();+ let reply = json!({"ok": true, "id": 7, "result": {"components": components}});+ let mut out = Counted { writes: 0, bytes: Vec::new() };+ send(&mut out, &reply).unwrap();+ assert_eq!(out.writes, 1);+ assert_eq!(out.bytes.last(), Some(&b'\n'));+ assert_eq!(serde_json::from_slice::<Value>(&out.bytes).unwrap(), reply);+ }}