dd859ca9

test: the dribble is written across pumps, not in one blocking write

a73x 2026-09-03 19:16

Commit message

test: the dribble is written across pumps, not in one blocking write

The observer-cap test pushed the whole over-cap dribble in a single
writeAllFd and only then pumped. Nobody reads that socket except the
pump, so the write only returns if the send buffer swallows the lot: a
few hundred KB on Linux, about 8 KB on Darwin, which is the cap itself.
The Mac suite wedged in write with no output. The peer end is
non-blocking now and the loop alternates write and pump, which is also
what a real dribbling peer looks like, stopping the moment the daemon
drops the observer.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SakwJEwD9dXBoRP5kWbemW

src/server/server_test_attach.zig

+    const dribble = try alloc.alloc(u8, srv_mod.observer_inbound_max + 1);
+    defer alloc.free(dribble);
+    @memset(dribble, 'x');
+    // Dribble it the way a real peer does — write, let the daemon pump,
+    // write again — rather than in one blocking writeAllFd. Nobody reads
+    // this socket except `pumpOnce`, so the whole dribble has to fit in the
+    // send buffer for a single write to return, and it does not everywhere:
+    // a unix stream socket holds a few hundred KB on Linux and about 8 KB on
+    // Darwin, which is the cap itself. The one write wedged the Mac suite in
+    // `write` with no output. Non-blocking so a full buffer is a short write
+    // to hand back to the pump instead of a stall, and the loop stops the
+    // moment the daemon drops the observer, which is the whole point.
+    const fl = try std.posix.fcntl(peer.handle, std.posix.F.GETFL, 0);
+    const nb: u32 = @bitCast(std.posix.O{ .NONBLOCK = true });
+    _ = try std.posix.fcntl(peer.handle, std.posix.F.SETFL, fl | nb);
+    var off: usize = 0;
+    // Bounded: every iteration either moves bytes or gives the daemon a pump
+    // to drain them, so a run that spends this many without the drop has
+    // stopped making progress and should fail rather than hang.
+    for (0..1000) |_| {
+        if (off == dribble.len or td.srv.observers[0] == null) break;
+        off += std.posix.write(peer.handle, dribble[off..]) catch |e| switch (e) {
+            // The drop closes the socket under us; that IS the outcome.
+            error.WouldBlock => @as(usize, 0),
+            error.BrokenPipe, error.ConnectionResetByPeer => break,
+            else => return e,
+        };
+        try td.srv.pumpOnce(20);
+    }
+    try td.srv.pumpOnce(20);
+    try std.testing.expect(td.srv.observers[0] == null);