Skip to content

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.rs
index 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]