60970c6c

test: a flooded stderr is a session that stops, and the drain is why it doesn't

a73x 2026-08-30 10:58

Commit message

test: a flooded stderr is a session that stops, and the drain is why it doesn't

The hazard the third poll fd exists for, asserted with a real child: a
pipe holds 64k, and ssh blocked writing past that is ssh not moving the
session's bytes either — a tile that stops with nothing on screen to say
so. The fixture floods before it serves, so an owner that never drains
cannot get past it.

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

src/client/client.zig

+// fail in a real terminal, which is why none of it was pinned at all.
+// `openFailure` is pure, so each class is one call with a literal answer.
+test "Transport.drainErr: a session whose ssh floods stderr keeps serving" {
+    // The reason the poll set grew a third fd rather than the reason
+    // growing a sentence. A pipe holds 64k; past that the writer BLOCKS,
+    // and ssh blocked on stderr is ssh not moving the session's bytes
+    // either. Nothing on screen says so — the tile simply stops.
+    //
+    // The fixture floods in the FOREGROUND, before it starts serving, so
+    // an owner that never drains cannot get past it. (Backgrounding the
+    // flood would let `cat` serve regardless, and the test would pass with
+    // the drain deleted — which is the shape this claim exists to catch.)
+    // Verified by deleting the `drainErr` call below: the round trip then
+    // never completes and the 2 s budget is what ends the test.
+    const alloc = std.testing.allocator;
+    var tmp = try TmpDir.make();
+    defer tmp.cleanup();
+    var carry: std.ArrayList(u8) = .empty;
+    defer carry.deinit(alloc);
+    var t = try Transport.open(alloc, .{ .hand = .{
+        .host = "flood",
+        .ssh_argv = &.{
+            "/bin/sh", "-c",
+            \\printf 'endpoint none\n'
+            \\head -c 1048576 /dev/zero >&2
+            \\cat
+            ,
+        },
+        .cache_path = null,
+        .deadline_ms = 200,
+    } }, &carry, -1, null);
+    defer t.close();
+    try std.testing.expect(t.link == .pipe);
+    // The whole point of the fd being on the Transport: whoever owns the
+    // link can find it without knowing how the handoff went.
+    try std.testing.expect(t.errFd() != null);
+    // `cat` echoes, so a frame written comes back as itself once the
+    // flood is out of the way.
+    const blob = "z" ** 4096;
+    try t.writeFrame(.input, blob);
+    const deadline = std.time.milliTimestamp() + 2000;
+    var echoed = false;
+    while (!echoed and std.time.milliTimestamp() < deadline) {
+        var fds: [2]std.posix.pollfd = undefined;
+        fds[0] = .{ .fd = t.pollFd(), .events = std.posix.POLL.IN, .revents = 0 };
+        var n: usize = 1;
+        if (t.errFd()) |efd| {
+            fds[1] = .{ .fd = efd, .events = std.posix.POLL.IN, .revents = 0 };
+            n = 2;
+        }
+        _ = std.posix.poll(fds[0..n], 50) catch break;
+        if (n == 2 and fds[1].revents != 0) t.drainErr();
+        if (fds[0].revents == 0) continue;
+        switch (t.readFrame(alloc) catch break) {
+            .incomplete => {},
+            .closed => break,
+            .frame => |f| {
+                defer f.deinit(alloc);
+                if (f.type == .input and std.mem.eql(u8, f.payload, blob)) echoed = true;
+            },
+        }
+    }
+    // The rule before the failure, since a bare `expect` names nothing:
+    // this test's whole subject is WHY no frame came back.
+    if (!echoed) std.debug.print(
+        "the tile stopped serving: with stderr undrained ssh blocks at the pipe's " ++
+            "64k and never runs the `cat` that carries the session\n",
+        .{},
+    );
+    try std.testing.expect(echoed);
+}
+test "openFailure: a quic:// target names the key or the address, and only an abort exits 0" {
+    var buf: [open_err_len]u8 = undefined;
+    const q: Target = .{ .quic = .{ .host_port = "box:4433", .key_path = "/etc/mux/key" } };