SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Control server: a subscribed connection is told of design changes (#8315) (#8333)
Homero Thompson32900556e070
diff --git a/apps/solidcraft/src/control_server.rs b/apps/solidcraft/src/control_server.rsindex f7635e17b3..b3a197edf3 100644--- a/apps/solidcraft/src/control_server.rs+++ b/apps/solidcraft/src/control_server.rs@@ -413,11 +413,37 @@ impl Lines {}}+/// A subscribed connection's seat on the watch: it leaves exactly once, whichever thread sees+/// the connection's end first — the connection's own thread at the end of the stream, or the+/// events thread at the first write a closed client refuses. The seat used to wait for the+/// events thread alone, and that thread only leaves its wait when the design moves, so the+/// count could outlive the connection by a second or more (#8315).+struct Seat(Mutex<Option<Subscriber>>);++impl Seat {+ fn new(counted: Subscriber) -> Self {+ Seat(Mutex::new(Some(counted)))+ }++ /// Leave the watch now: the seat goes once, whoever gets here first.+ fn release(&self) {+ let counted = self.0.lock().unwrap_or_else(PoisonError::into_inner).take();+ drop(counted);+ }+}++impl Drop for Seat {+ fn drop(&mut self) {+ self.release();+ }+}+/// A connection's `control.subscribe` (#6985): its `design.changed` lines, sent from a thread of/// their own until the connection ends.struct Subscription {lines: Arc<Lines>,stop: Arc<AtomicBool>,+ seat: Arc<Seat>,}impl Subscription {@@ -433,15 +459,17 @@ impl Subscription {) -> Option<(Self, std::io::Result<()>)> {let lines = Arc::new(Lines { socket: out.try_clone().ok()?, turn: Mutex::new(()) });let stop = Arc::new(AtomicBool::new(false));+ let seat = Arc::new(Seat::new(counted));let first = lines.turn.lock().unwrap_or_else(PoisonError::into_inner);- let (l, s) = (lines.clone(), stop.clone());+ let (l, s, watch_seat) = (lines.clone(), stop.clone(), Arc::clone(&seat));// The connection's seat on the watch rides the events thread: it leaves when the thread// does, so the next failed write to a closed client retires it even while the connection's- // own thread is slow to see the end of the stream (#7226).- std::thread::Builder::new().stack_size(64 * 1024).spawn(move || send_events(design, &l, &s, seen, counted)).ok()?;+ // own thread is slow to see the end of the stream (#7226). The connection's own thread+ // leaves it too, so a closed connection stops counting at once (#8315).+ std::thread::Builder::new().stack_size(64 * 1024).spawn(move || send_events(design, &l, &s, seen, watch_seat)).ok()?;let sent = send(&mut &lines.socket, reply);drop(first);- Some((Subscription { lines, stop }, sent))+ Some((Subscription { lines, stop, seat }, sent))}}@@ -454,6 +482,9 @@ fn design_of(reply: &Value) -> Option<(String, u64)> {impl Drop for Subscription {fn drop(&mut self) {self.stop.store(true, Ordering::Relaxed);+ // The seat on the watch goes now: the connection is over, and nothing counts it any more+ // (#8315).+ self.seat.release();// The socket closes now, not when the thread next looks; a line blocked on a client that// stopped reading ends too.let _ = self.lines.socket.shutdown(std::net::Shutdown::Both);@@ -461,10 +492,10 @@ impl Drop for Subscription {}/// The `design.changed` lines of a subscribed connection, each time the design differs from the-/// last one it was told of (`seen`), until `stop`. Owns the connection's seat on the watch-/// (`counted`), so the seat leaves exactly when this thread does: on `stop`, or on the first-/// write a closed client refuses (#7226).-fn send_events(design: &DesignWatch, lines: &Lines, stop: &AtomicBool, mut seen: (String, u64), _counted: Subscriber) {+/// last one it was told of (`seen`), until `stop`. Holds the connection's seat on the watch+/// (`seat`), which it leaves when the thread ends: on `stop`, or on the first write a closed+/// client refuses (#7226).+fn send_events(design: &DesignWatch, lines: &Lines, stop: &AtomicBool, mut seen: (String, u64), seat: Arc<Seat>) {while !stop.load(Ordering::Relaxed) {let Some(now) = design.wait(&seen, stop, Duration::from_secs(1)).filter(|now| *now != seen) else { continue };if lines.send(&json!({"event": "design.changed", "params": {"document_id": now.0, "revision": now.1}})).is_err() {@@ -473,6 +504,9 @@ fn send_events(design: &DesignWatch, lines: &Lines, stop: &AtomicBool, mut seen:seen = now;std::thread::sleep(EVENT_GAP);}+ // The client is gone: it is not counted on the watch any more, whatever the connection's own+ // thread still has to notice (#8315).+ seat.release();}/// What this app's control channel does beyond the methods every version has, for a client to@@ -905,6 +939,58 @@ mod tests {assert!(!WATCH.subscribed());}+ /// #8315: a closed connection leaves the watch at once. The seat of a subscribed connection+ /// goes when the connection's own thread sees the end of the stream, not only when the+ /// events thread notices: that thread waits for the design to move, so a connection that+ /// closed while the design stood still kept the watch counting it for a second or more.+ #[test]+ fn a_closed_connection_leaves_the_watch_at_once() {+ static RUNNING: Running = Running::new();+ static WATCH: DesignWatch = DesignWatch::new();+ let token = "0123456789abcdef0123456789abcdef";+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let addr = listener.local_addr().unwrap();+ let (tx, rx) = channel::<ControlRequest>();+ // The window names the design once and then leaves it alone: nothing moves it, so the+ // events thread has nothing to write and only the end of the connection can retire it.+ std::thread::spawn(move || {+ for req in rx {+ if req.method == "control.subscribe" {+ WATCH.publish("d-1", 3);+ let _ = req.reply.send(json!({"ok": true, "result": {"document_id": "d-1", "revision": 3}}));+ } else {+ let _ = req.reply.send(json!({"ok": true, "result": req.method}));+ }+ }+ });+ std::thread::spawn(move || {+ for stream in listener.incoming().flatten() {+ let tx = tx.clone();+ std::thread::spawn(move || serve_with(stream, token, tx, egui::Context::default(), false, WAITS, &RUNNING, &WATCH));+ }+ });+ 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);+ writeln!(out, "{}", json!({"id": 1, "method": "control.subscribe", "token": token})).unwrap();+ let mut l = String::new();+ lines.read_line(&mut l).unwrap();+ let reply: Value = serde_json::from_str(&l).unwrap();+ assert!(reply["ok"] == true, "{reply}");+ assert!(WATCH.subscribed(), "the connection is subscribed");+ // Let the events thread settle into its wait: the design stands still, so it has nothing+ // to write, and only the end of the connection can retire it.+ std::thread::sleep(Duration::from_millis(200));+ // The client goes away without asking anything else.+ drop((out, lines));+ let deadline = Instant::now() + Duration::from_millis(400);+ while WATCH.subscribed() && Instant::now() < deadline {+ std::thread::sleep(Duration::from_millis(10));+ }+ assert!(!WATCH.subscribed(), "a closed connection is not counted on the watch");+ }+/// A timed-out request that only reads is not said to "still apply", nor is one that only/// writes a file (an export, #1989); a change is, by name.#[test]