c8463a07

feat: sessions_reply says how many clients hold each session

a73x 2026-09-03 05:20

Commit message

feat: sessions_reply says how many clients hold each session

src/engine/protocol.zig

@@ @@ -927,11 +927,57 @@ pub const sessions_meta_version_max = 32; @@
+/// `sessions_text_max`.
+pub const sessions_meta_max =
++ sessions_meta_prefix.len + sessions_meta_version_max + sessions_meta_stale_word.len;
+/// One `# holds NAME N` line per session, appended by a daemon that can
+/// count: how many clients hold that session. The picker's session list
+/// shows it, and the end key's first press is judged against it. Spelled
+/// as a `#` line so `sessionsIter`, which yields only valid session names,
+/// skips it on a client that predates it — exactly as it skips the meta
+/// line — and a daemon that predates it sends none, which
+/// `parseSessionsHolds` reads as unknown.
+pub const sessions_holds_prefix = "# holds ";
+/// `# holds NAME N\n` at its widest: N is a u8, so at most three digits.
+pub const sessions_holds_line_max = sessions_holds_prefix.len + session_name_max + 1 + 3 + 1;
+/// What a `sessions_reply` READER must have room for: every name, every
+/// holds line, and the meta line. `listSessions` refuses an overlong
+/// payload as a transport error, so a receiver sized to `sessions_text_max`
+/// alone would read a full daemon that states its version as an
+/// unreachable box.
+pub const sessions_reply_max = sessions_text_max + sessions_max * sessions_holds_line_max + sessions_meta_max;
+/// Append one holds line to the payload already in `buf[0..len]` and return
+/// the new length. Same join rule as `appendSessionsMeta` — a separator only
+/// when there is something to separate from — and the same tolerance for a
+/// buffer that cannot take the line: the payload is returned unchanged
+/// rather than truncated, so a reader sees the count as unknown instead of
+/// reading half a line. `sessions_reply_max` is sized so a daemon never
+/// reaches that branch.
+pub fn appendSessionsHolds(buf: []u8, len: usize, name: []const u8, holds: u8) usize {
+    var w = len;
+    if (w != 0) {
+        if (w >= buf.len) return len;
+        buf[w] = '\n';
+        w += 1;
+    }
+    const line = std.fmt.bufPrint(buf[w..], "{s}{s} {d}", .{ sessions_holds_prefix, name, holds }) catch return len;
+    return w + line.len;
+}
+/// The reader's half, across the same trust boundary as `sessionsIter`: the
+/// payload is a peer's bytes, so anything that is not this exact shape reads
+/// as absent. Null is "this daemon did not say", never zero — an old daemon
+/// sends no holds line at all, and a caller that painted null as 0 would
+/// claim nobody holds a session it cannot count.
+pub fn parseSessionsHolds(payload: []const u8, name: []const u8) ?u8 {
+    var lines = std.mem.splitScalar(u8, payload, '\n');
+    while (lines.next()) |line| {
+        if (!std.mem.startsWith(u8, line, sessions_holds_prefix)) continue;
+        const rest = line[sessions_holds_prefix.len..];
+        const sp = std.mem.lastIndexOfScalar(u8, rest, ' ') orelse continue;
+        if (!std.mem.eql(u8, rest[0..sp], name)) continue;
+        return std.fmt.parseInt(u8, rest[sp + 1 ..], 10) catch continue;
+    }
+    return null;
+}
+pub const SessionsMeta = struct { version: []const u8, stale: bool };
@@ @@ -1910,6 +1956,40 @@ test "sessions meta: junk is absent, never a version" { @@
+    try std.testing.expect(meta.stale);
+test "sessions holds: a holds line rides beside the names, old readers skip it, and a name reads its own count" {
+    var buf: [sessions_reply_max]u8 = undefined;
+    @memcpy(buf[0..4], "0\nwk");
+    var len: usize = 4;
+    len = appendSessionsHolds(&buf, len, "0", 1);
+    len = appendSessionsHolds(&buf, len, "wk", 0);
+    const payload = buf[0..len];
+    try std.testing.expectEqualStrings("0\nwk\n# holds 0 1\n# holds wk 0", payload);
+    // The iterator every old client walks yields the names and nothing else.
+    var it = sessionsIter(payload);
+    try std.testing.expectEqualStrings("0", it.next().?);
+    try std.testing.expectEqualStrings("wk", it.next().?);
+    try std.testing.expect(it.next() == null);
+    try std.testing.expectEqual(@as(?u8, 1), parseSessionsHolds(payload, "0"));
+    try std.testing.expectEqual(@as(?u8, 0), parseSessionsHolds(payload, "wk"));
+    // A name the daemon did not count, and an old daemon's payload with no
+    // holds lines at all, both read as unknown rather than zero.
+    try std.testing.expect(parseSessionsHolds(payload, "w") == null);
+    try std.testing.expect(parseSessionsHolds("0\nwk", "0") == null);
+    // The meta line and the holds lines coexist in either order.
+    const with_meta = appendSessionsMeta(&buf, len, "0.0.1-18", false);
+    try std.testing.expectEqual(@as(?u8, 1), parseSessionsHolds(buf[0..with_meta], "0"));
+    try std.testing.expectEqualStrings("0.0.1-18", parseSessionsMeta(buf[0..with_meta]).?.version);
+}
+test "sessions holds: sessions_reply_max holds every session's name, holds line and the meta line" {
+    // The daemon writes names, then one holds line per session, then meta,
+    // into ONE buffer of this size; the bound must cover the worst case.
+    const worst_line = sessions_holds_prefix.len + session_name_max + 1 + 3;
+    try std.testing.expect(sessions_reply_max >= sessions_text_max + sessions_max * (worst_line + 1) + sessions_meta_max);
+}
+test "wireName: the default session is spelled as the empty tail" {
+    try std.testing.expectEqualStrings("", wireName("0"));
+    try std.testing.expectEqualStrings("", wireName(resolveName("")));

src/server/server.zig

Old		New
@@ -1795,13 +1795,19 @@ pub const Server = struct {
1795	// activity, so it claims no grid.	1795	// activity, so it claims no grid.
1796	var buf: [proto.sessions_reply_max]u8 = undefined;	1796	var buf: [proto.sessions_reply_max]u8 = undefined;
1797	const names = self.sessions.text(buf[0..proto.sessions_text_max]);	1797	const names = self.sessions.text(buf[0..proto.sessions_text_max]);
1798	// A daemon with no version to state appends nothing, so a	1798	// The holds lines and the meta line ride the same gate: a
1799	// bare fixture's payload stays byte-identical to the old	1799	// daemon with no version to state appends nothing, so a bare
1800	// wire and the sibling exact-equality test keeps pinning it.	1800	// fixture's payload stays byte-identical to the old wire and
1801	const len = if (self.version.len != 0)	1801	// the sibling exact-equality test keeps pinning it.
1802	proto.appendSessionsMeta(&buf, names.len, self.version, selfImageStale())	1802	var len = names.len;
1803	else	1803	if (self.version.len != 0) {
1804	names.len;	1804	for (self.sessions.table, 0..) \|slot, si\| {
		1805	const s = slot orelse continue;
		1806	const holds: u8 = @intCast(@min(self.clientsInSession(si), std.math.maxInt(u8)));
		1807	len = proto.appendSessionsHolds(&buf, len, s.name(), holds);
		1808	}
		1809	len = proto.appendSessionsMeta(&buf, len, self.version, selfImageStale());
		1810	}
1805	self.replyTo(p, .sessions_reply, buf[0..len]);	1811	self.replyTo(p, .sessions_reply, buf[0..len]);
1806	},	1812	},
1807	.endpoint_req => {	1813	.endpoint_req => {

src/server/server_test_session.zig

+    try std.testing.expect(!meta.stale);
+/// "Every client of this session has gone" as a `pumpUntil` context. The
+/// close of a socket is the peer's act; the daemon only learns about it on a
+/// pump, so a test that asked for the count straight after `close()` would be
+/// racing the reap.
+const SessionEmptied = struct {
+    srv: *Server,
+    si: usize,
+    fn reached(s: SessionEmptied) bool {
+        return !s.srv.hasClientsIn(s.si);
+    }
+};
+test "Server: sessions_reply states how many clients hold each session" {
+    const alloc = std.testing.allocator;
+    var td = try h.TestDaemon.init(alloc, "sesshold", .{
+        .shell = "/bin/cat",
+        .version = "0.0.1-test",
+    });
+    defer td.deinit();
+    // One held session and one nobody holds: a fixture where every session
+    // had the same number of clients could not tell a real count from a
+    // constant.
+    const ca = try dial.dialAttach(td.sock_path, 80, 24);
+    defer ca.close();
+    (try awaitFrame(alloc, &td.srv, ca.handle, .snapshot, 400) orelse
+        return error.NoSnapshotA).deinit(alloc);
+    const cb = try dial.dialAttachNamed(td.sock_path, 80, 24, "wk");
+    (try awaitFrame(alloc, &td.srv, cb.handle, .snapshot, 400) orelse
+        return error.NoSnapshotB).deinit(alloc);
+    cb.close();
+    const wk = td.srv.sessions.find(proto.wireName("wk")) orelse return error.NoSession;
+    try std.testing.expect(try h.pumpUntil(&td.srv, 2000, SessionEmptied{
+        .srv = &td.srv,
+        .si = wk,
+    }, SessionEmptied.reached));
+    try proto.writeFrame(ca.handle, .sessions_req, "");
+    const reply = (try awaitFrame(alloc, &td.srv, ca.handle, .sessions_reply, 400)) orelse
+        return error.NoSessionsReply;
+    defer reply.deinit(alloc);
+    try std.testing.expectEqual(@as(?u8, 1), proto.parseSessionsHolds(reply.payload, proto.default_session));
+    try std.testing.expectEqual(@as(?u8, 0), proto.parseSessionsHolds(reply.payload, "wk"));
+    // The holds lines ride behind the names invisibly, exactly as the meta
+    // line does, and the meta line still parses out from beside them.
+    var names = proto.sessionsIter(reply.payload);
+    try std.testing.expectEqualStrings(proto.default_session, names.next() orelse return error.NameLost);
+    try std.testing.expectEqualStrings("wk", names.next() orelse return error.NameLost);
+    try std.testing.expect(names.next() == null);
+    const meta = proto.parseSessionsMeta(reply.payload) orelse return error.MetaAbsent;
+    try std.testing.expectEqualStrings("0.0.1-test", meta.version);
+}
+test "Server: an attached client's mismatched status tail is ignored" {
+    const alloc = std.testing.allocator;