gitoriaLog in with ident

tracker

All repositories: gitoria

ReadmeCodePull requestsReleasesTicketsSettingsCommitdc40d859dc40d859tracker#31 (mission 026): duplicate titles merged — the 68 type+tmdbId pairs held by 157 records were the old tracker's (all migrated); merge.hl repair job (own clock, before the TMDB jobs) keeps one keeper per title (follows/watches > old short id > oldest), moves follows, watches, seasons, cast, credits, timelines, tombstones the rest (mergedInto, never deleted), slugs + short ids 301 to the keeper; stray seasons merged into their listed twin (Reacher S3 watches) or linked when watched; search import re-checks before its put; deploy.sh waits up to 90 s for 200; real copy 68 -> 0 dup ids, az5b2 follows/watches equal; gates 342/0, 32/0, 52/0mredc40d859/plugins/http/ws_common.zig

21.4 KB

  1. // Shared WebSocket core — RFC 6455 framing, transport-agnostic (decision D8).
  2. // Compiled into each HTTP plugin like http_common.zig; NOT a standalone .so.
  3. //
  4. // Responsibilities:
  5. // - Sec-WebSocket-Accept computation (SHA1 + base64 of key + RFC GUID)
  6. // - Frame encoding (unmasked, server → client) via a write callback
  7. // - Frame decoding + message assembly (client-masked inbound), fragmentation,
  8. // ping/pong surfacing, close handshake with codes, UTF-8 validation
  9. //
  10. // The per-protocol handshakes stay in each plugin: h1 = Upgrade/101 (http1.zig),
  11. // h2 = RFC 8441 extended CONNECT (future), h3 = RFC 9220 (future). Everything
  12. // after the handshake — the byte stream — goes through this module unchanged.
  13. //
  14. // Transport neutrality: encoding writes through `WriteFn` callbacks and decoding
  15. // consumes raw bytes via `Decoder.feed()`; the module never touches a socket.
  17. const std = @import("std");
  19. pub const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
  21. /// Write callback: return false on transport failure (peer gone).
  22. pub const WriteFn = *const fn (ctx: ?*anyopaque, data: []const u8) bool;
  24. pub const Opcode = enum(u4) {
  25. continuation = 0x0,
  26. text = 0x1,
  27. binary = 0x2,
  28. close = 0x8,
  29. ping = 0x9,
  30. pong = 0xA,
  31. _,
  33. pub fn isControl(self: Opcode) bool {
  34. return @intFromEnum(self) >= 0x8;
  35. }
  36. };
  38. // Close codes used by the core
  39. pub const CLOSE_NORMAL: u16 = 1000;
  40. pub const CLOSE_GOING_AWAY: u16 = 1001;
  41. pub const CLOSE_PROTOCOL_ERROR: u16 = 1002;
  42. pub const CLOSE_INVALID_PAYLOAD: u16 = 1007;
  43. pub const CLOSE_TOO_BIG: u16 = 1009;
  44. pub const CLOSE_NO_STATUS: u16 = 1005; // synthesized when close frame has no code — never sent on the wire
  46. /// Sec-WebSocket-Accept: base64(SHA1(key ++ GUID)). Output is always 28 chars.
  47. pub fn computeAcceptKey(key: []const u8, out: *[28]u8) []const u8 {
  48. var sha = std.crypto.hash.Sha1.init(.{});
  49. sha.update(key);
  50. sha.update(GUID);
  51. var digest: [20]u8 = undefined;
  52. sha.final(&digest);
  53. return std.base64.standard.Encoder.encode(out, &digest);
  54. }
  56. /// Encode a frame header into `buf` (needs >= 10 bytes). Returns header length.
  57. /// Server frames are unmasked (RFC 6455 §5.1).
  58. pub fn encodeFrameHeader(buf: *[10]u8, opcode: Opcode, payload_len: usize, fin: bool) usize {
  59. buf[0] = (if (fin) @as(u8, 0x80) else 0) | @as(u8, @intFromEnum(opcode));
  60. if (payload_len <= 125) {
  61. buf[1] = @intCast(payload_len);
  62. return 2;
  63. } else if (payload_len <= 65535) {
  64. buf[1] = 126;
  65. std.mem.writeInt(u16, buf[2..4], @intCast(payload_len), .big);
  66. return 4;
  67. } else {
  68. buf[1] = 127;
  69. std.mem.writeInt(u64, buf[2..10], payload_len, .big);
  70. return 10;
  71. }
  72. }
  74. /// Write one complete unmasked frame through the callback. True on success.
  75. pub fn writeFrame(write: WriteFn, ctx: ?*anyopaque, opcode: Opcode, payload: []const u8) bool {
  76. var hdr: [10]u8 = undefined;
  77. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, true);
  78. if (!write(ctx, hdr[0..hlen])) return false;
  79. if (payload.len > 0 and !write(ctx, payload)) return false;
  80. return true;
  81. }
  83. /// Write a close frame with a code and optional reason (reason truncated to 123).
  84. pub fn writeClose(write: WriteFn, ctx: ?*anyopaque, code: u16, reason: []const u8) bool {
  85. var payload: [125]u8 = undefined;
  86. std.mem.writeInt(u16, payload[0..2], code, .big);
  87. const rlen = @min(reason.len, 123);
  88. @memcpy(payload[2 .. 2 + rlen], reason[0..rlen]);
  89. return writeFrame(write, ctx, .close, payload[0 .. 2 + rlen]);
  90. }
  92. /// Write one complete MASKED frame — the client's half of RFC 6455 §5.1 ("a
  93. /// client MUST mask all frames"). The mask is fresh per frame from the kernel
  94. /// CSPRNG (`getrandom(2)`, not a seeded generator: a predictable mask is not
  95. /// a security property this module is willing to guess wrong about — same
  96. /// reasoning as hl:http1's session-token `randomToken`). A getrandom() short
  97. /// read is vanishingly rare for 4 bytes; the leftover is zeroed rather than
  98. /// left uninitialized, which only ever makes the mask weaker, never wrong.
  99. /// Masking is applied through a small stack buffer so a large payload needs
  100. /// no allocation.
  101. pub fn writeFrameMasked(write: WriteFn, ctx: ?*anyopaque, opcode: Opcode, payload: []const u8) bool {
  102. var hdr: [10]u8 = undefined;
  103. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, true);
  104. hdr[1] |= 0x80; // mask bit
  105. var mask: [4]u8 = .{ 0, 0, 0, 0 };
  106. _ = std.os.linux.getrandom(&mask, mask.len, 0);
  107. if (!write(ctx, hdr[0..hlen])) return false;
  108. if (!write(ctx, &mask)) return false;
  109. if (payload.len == 0) return true;
  111. var buf: [4096]u8 = undefined;
  112. var i: usize = 0;
  113. while (i < payload.len) {
  114. const n = @min(buf.len, payload.len - i);
  115. for (0..n) |j| buf[j] = payload[i + j] ^ mask[(i + j) % 4];
  116. if (!write(ctx, buf[0..n])) return false;
  117. i += n;
  118. }
  119. return true;
  120. }
  122. /// Masked `writeClose` — see `writeFrameMasked`.
  123. pub fn writeCloseMasked(write: WriteFn, ctx: ?*anyopaque, code: u16, reason: []const u8) bool {
  124. var payload: [125]u8 = undefined;
  125. std.mem.writeInt(u16, payload[0..2], code, .big);
  126. const rlen = @min(reason.len, 123);
  127. @memcpy(payload[2 .. 2 + rlen], reason[0..rlen]);
  128. return writeFrameMasked(write, ctx, .close, payload[0 .. 2 + rlen]);
  129. }
  131. /// A decoded inbound event. Payload slices are allocated with the decoder's
  132. /// allocator and owned by the CALLER (free after use).
  133. pub const Event = union(enum) {
  134. text: []u8,
  135. binary: []u8,
  136. ping: []u8, // payload to echo in the pong
  137. pong: []u8,
  138. close: Close,
  139. /// Protocol violation — caller should send a close frame with this code
  140. /// and drop the connection.
  141. protocol_error: u16,
  143. pub const Close = struct {
  144. code: u16, // CLOSE_NO_STATUS when the frame carried no code
  145. reason: []u8,
  146. };
  148. pub fn deinitPayload(self: *Event, alloc: std.mem.Allocator) void {
  149. switch (self.*) {
  150. .text, .binary, .ping, .pong => |p| alloc.free(p),
  151. .close => |cl| alloc.free(cl.reason),
  152. .protocol_error => {},
  153. }
  154. }
  155. };
  157. fn validCloseCode(code: u16) bool {
  158. return switch (code) {
  159. 1000...1003, 1007...1011 => true,
  160. 3000...4999 => true,
  161. else => false,
  162. };
  163. }
  165. /// Streaming frame decoder + message assembler. One per connection.
  166. /// feed() raw transport bytes, then loop next() until it returns null.
  167. pub const Decoder = struct {
  168. alloc: std.mem.Allocator,
  169. /// Client frames must be masked (server side). Set false for client use.
  170. require_masked: bool = true,
  171. max_message_size: usize = 16 * 1024 * 1024,
  173. buf: std.ArrayListUnmanaged(u8) = .empty, // raw incoming bytes
  174. read_pos: usize = 0,
  175. msg: std.ArrayListUnmanaged(u8) = .empty, // fragmented-message assembly
  176. msg_opcode: ?Opcode = null,
  177. failed: bool = false, // after a protocol error the stream is dead
  179. pub fn init(alloc: std.mem.Allocator) Decoder {
  180. return .{ .alloc = alloc };
  181. }
  183. pub fn deinit(self: *Decoder) void {
  184. self.buf.deinit(self.alloc);
  185. self.msg.deinit(self.alloc);
  186. }
  188. pub fn feed(self: *Decoder, bytes: []const u8) !void {
  189. // Compact consumed prefix before growing
  190. if (self.read_pos > 0) {
  191. const remaining = self.buf.items.len - self.read_pos;
  192. std.mem.copyForwards(u8, self.buf.items[0..remaining], self.buf.items[self.read_pos..]);
  193. self.buf.shrinkRetainingCapacity(remaining);
  194. self.read_pos = 0;
  195. }
  196. try self.buf.appendSlice(self.alloc, bytes);
  197. }
  199. fn fail(self: *Decoder, code: u16) Event {
  200. self.failed = true;
  201. return .{ .protocol_error = code };
  202. }
  204. /// Pop the next complete event, or null if more bytes are needed.
  205. pub fn next(self: *Decoder) !?Event {
  206. if (self.failed) return null;
  207. const data = self.buf.items[self.read_pos..];
  208. if (data.len < 2) return null;
  210. const b0 = data[0];
  211. const b1 = data[1];
  212. const fin = (b0 & 0x80) != 0;
  213. const rsv = b0 & 0x70;
  214. const opcode: Opcode = @enumFromInt(@as(u4, @truncate(b0 & 0x0F)));
  215. const masked = (b1 & 0x80) != 0;
  216. const len7: u8 = b1 & 0x7F;
  218. if (rsv != 0) return self.fail(CLOSE_PROTOCOL_ERROR); // no extensions negotiated
  219. switch (@intFromEnum(opcode)) {
  220. 0x0, 0x1, 0x2, 0x8, 0x9, 0xA => {},
  221. else => return self.fail(CLOSE_PROTOCOL_ERROR),
  222. }
  223. if (self.require_masked and !masked) return self.fail(CLOSE_PROTOCOL_ERROR);
  224. if (opcode.isControl() and (!fin or len7 > 125)) return self.fail(CLOSE_PROTOCOL_ERROR);
  226. var offset: usize = 2;
  227. var payload_len: u64 = len7;
  228. if (len7 == 126) {
  229. if (data.len < offset + 2) return null;
  230. payload_len = std.mem.readInt(u16, data[offset..][0..2], .big);
  231. offset += 2;
  232. if (payload_len <= 125) return self.fail(CLOSE_PROTOCOL_ERROR); // non-minimal encoding
  233. } else if (len7 == 127) {
  234. if (data.len < offset + 8) return null;
  235. payload_len = std.mem.readInt(u64, data[offset..][0..8], .big);
  236. offset += 8;
  237. if (payload_len <= 65535) return self.fail(CLOSE_PROTOCOL_ERROR);
  238. if (payload_len > (1 << 62)) return self.fail(CLOSE_PROTOCOL_ERROR); // MSB must be 0
  239. }
  240. if (payload_len > self.max_message_size or
  241. self.msg.items.len + payload_len > self.max_message_size)
  242. return self.fail(CLOSE_TOO_BIG);
  244. var mask: [4]u8 = .{ 0, 0, 0, 0 };
  245. if (masked) {
  246. if (data.len < offset + 4) return null;
  247. mask = data[offset..][0..4].*;
  248. offset += 4;
  249. }
  251. const plen: usize = @intCast(payload_len);
  252. if (data.len < offset + plen) return null; // frame incomplete
  254. // Unmask into an owned copy
  255. const payload = try self.alloc.alloc(u8, plen);
  256. errdefer self.alloc.free(payload);
  257. for (0..plen) |i| {
  258. payload[i] = data[offset + i] ^ mask[i % 4];
  259. }
  260. self.read_pos += offset + plen;
  262. switch (opcode) {
  263. .ping => return .{ .ping = payload },
  264. .pong => return .{ .pong = payload },
  265. .close => {
  266. if (plen == 0) return .{ .close = .{ .code = CLOSE_NO_STATUS, .reason = payload } };
  267. if (plen == 1) {
  268. self.alloc.free(payload);
  269. return self.fail(CLOSE_PROTOCOL_ERROR);
  270. }
  271. const code = std.mem.readInt(u16, payload[0..2], .big);
  272. if (!validCloseCode(code)) {
  273. self.alloc.free(payload);
  274. return self.fail(CLOSE_PROTOCOL_ERROR);
  275. }
  276. if (!std.unicode.utf8ValidateSlice(payload[2..])) {
  277. self.alloc.free(payload);
  278. return self.fail(CLOSE_INVALID_PAYLOAD);
  279. }
  280. const reason = try self.alloc.alloc(u8, plen - 2);
  281. @memcpy(reason, payload[2..]);
  282. self.alloc.free(payload);
  283. return .{ .close = .{ .code = code, .reason = reason } };
  284. },
  285. .text, .binary => {
  286. if (self.msg_opcode != null) {
  287. self.alloc.free(payload);
  288. return self.fail(CLOSE_PROTOCOL_ERROR); // new data frame while assembling
  289. }
  290. if (fin) {
  291. if (opcode == .text and !std.unicode.utf8ValidateSlice(payload)) {
  292. self.alloc.free(payload);
  293. return self.fail(CLOSE_INVALID_PAYLOAD);
  294. }
  295. return if (opcode == .text) .{ .text = payload } else .{ .binary = payload };
  296. }
  297. // First fragment
  298. self.msg_opcode = opcode;
  299. try self.msg.appendSlice(self.alloc, payload);
  300. self.alloc.free(payload);
  301. return self.next(); // more frames may already be buffered
  302. },
  303. .continuation => {
  304. const start_op = self.msg_opcode orelse {
  305. self.alloc.free(payload);
  306. return self.fail(CLOSE_PROTOCOL_ERROR); // continuation without a message
  307. };
  308. try self.msg.appendSlice(self.alloc, payload);
  309. self.alloc.free(payload);
  310. if (!fin) return self.next();
  311. // Message complete
  312. const full = try self.msg.toOwnedSlice(self.alloc);
  313. self.msg_opcode = null;
  314. if (start_op == .text and !std.unicode.utf8ValidateSlice(full)) {
  315. self.alloc.free(full);
  316. return self.fail(CLOSE_INVALID_PAYLOAD);
  317. }
  318. return if (start_op == .text) .{ .text = full } else .{ .binary = full };
  319. },
  320. _ => return self.fail(CLOSE_PROTOCOL_ERROR), // unreachable — filtered above
  321. }
  322. }
  323. };
  325. // ===========================================================================
  326. // Tests
  327. // ===========================================================================
  329. const t = std.testing;
  331. test "computeAcceptKey RFC 6455 sample" {
  332. var out: [28]u8 = undefined;
  333. const accept = computeAcceptKey("dGhlIHNhbXBsZSBub25jZQ==", &out);
  334. try t.expectEqualStrings("s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", accept);
  335. }
  337. fn maskedFrame(alloc: std.mem.Allocator, fin: bool, opcode: Opcode, payload: []const u8, mask: [4]u8) ![]u8 {
  338. var out = std.ArrayListUnmanaged(u8).empty;
  339. var hdr: [10]u8 = undefined;
  340. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, fin);
  341. hdr[1] |= 0x80; // set mask bit
  342. try out.appendSlice(alloc, hdr[0..hlen]);
  343. try out.appendSlice(alloc, &mask);
  344. for (payload, 0..) |b, i| try out.append(alloc, b ^ mask[i % 4]);
  345. return out.toOwnedSlice(alloc);
  346. }
  348. test "decode masked text frame" {
  349. var dec = Decoder.init(t.allocator);
  350. defer dec.deinit();
  351. const frame = try maskedFrame(t.allocator, true, .text, "Hello", .{ 0x37, 0xfa, 0x21, 0x3d });
  352. defer t.allocator.free(frame);
  353. try dec.feed(frame);
  354. var ev = (try dec.next()).?;
  355. defer ev.deinitPayload(t.allocator);
  356. try t.expectEqualStrings("Hello", ev.text);
  357. try t.expectEqual(@as(?Event, null), try dec.next());
  358. }
  360. test "decode split across feeds" {
  361. var dec = Decoder.init(t.allocator);
  362. defer dec.deinit();
  363. const frame = try maskedFrame(t.allocator, true, .text, "chunked delivery", .{ 1, 2, 3, 4 });
  364. defer t.allocator.free(frame);
  365. try dec.feed(frame[0..3]);
  366. try t.expectEqual(@as(?Event, null), try dec.next());
  367. try dec.feed(frame[3..]);
  368. var ev = (try dec.next()).?;
  369. defer ev.deinitPayload(t.allocator);
  370. try t.expectEqualStrings("chunked delivery", ev.text);
  371. }
  373. test "fragmented message assembly" {
  374. var dec = Decoder.init(t.allocator);
  375. defer dec.deinit();
  376. const f1 = try maskedFrame(t.allocator, false, .text, "Hel", .{ 9, 8, 7, 6 });
  377. defer t.allocator.free(f1);
  378. const f2 = try maskedFrame(t.allocator, false, .continuation, "lo ", .{ 5, 4, 3, 2 });
  379. defer t.allocator.free(f2);
  380. const f3 = try maskedFrame(t.allocator, true, .continuation, "WS", .{ 1, 1, 1, 1 });
  381. defer t.allocator.free(f3);
  382. try dec.feed(f1);
  383. try dec.feed(f2);
  384. try t.expectEqual(@as(?Event, null), try dec.next());
  385. try dec.feed(f3);
  386. var ev = (try dec.next()).?;
  387. defer ev.deinitPayload(t.allocator);
  388. try t.expectEqualStrings("Hello WS", ev.text);
  389. }
  391. test "control frame interleaved with fragments" {
  392. var dec = Decoder.init(t.allocator);
  393. defer dec.deinit();
  394. const f1 = try maskedFrame(t.allocator, false, .text, "par", .{ 2, 2, 2, 2 });
  395. defer t.allocator.free(f1);
  396. const ping = try maskedFrame(t.allocator, true, .ping, "hb", .{ 3, 3, 3, 3 });
  397. defer t.allocator.free(ping);
  398. const f2 = try maskedFrame(t.allocator, true, .continuation, "tial", .{ 4, 4, 4, 4 });
  399. defer t.allocator.free(f2);
  400. try dec.feed(f1);
  401. try dec.feed(ping);
  402. var ev1 = (try dec.next()).?;
  403. defer ev1.deinitPayload(t.allocator);
  404. try t.expectEqualStrings("hb", ev1.ping);
  405. try dec.feed(f2);
  406. var ev2 = (try dec.next()).?;
  407. defer ev2.deinitPayload(t.allocator);
  408. try t.expectEqualStrings("partial", ev2.text);
  409. }
  411. test "unmasked client frame is a protocol error" {
  412. var dec = Decoder.init(t.allocator);
  413. defer dec.deinit();
  414. var hdr: [10]u8 = undefined;
  415. const hlen = encodeFrameHeader(&hdr, .text, 2, true);
  416. try dec.feed(hdr[0..hlen]);
  417. try dec.feed("hi");
  418. const ev = (try dec.next()).?;
  419. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  420. try t.expectEqual(@as(?Event, null), try dec.next()); // stream dead
  421. }
  423. test "invalid UTF-8 in text is 1007" {
  424. var dec = Decoder.init(t.allocator);
  425. defer dec.deinit();
  426. const bad = [_]u8{ 0xC3, 0x28 }; // invalid 2-byte sequence
  427. const frame = try maskedFrame(t.allocator, true, .text, &bad, .{ 7, 7, 7, 7 });
  428. defer t.allocator.free(frame);
  429. try dec.feed(frame);
  430. const ev = (try dec.next()).?;
  431. try t.expectEqual(CLOSE_INVALID_PAYLOAD, ev.protocol_error);
  432. }
  434. test "close with code and reason" {
  435. var dec = Decoder.init(t.allocator);
  436. defer dec.deinit();
  437. var payload: [7]u8 = undefined;
  438. std.mem.writeInt(u16, payload[0..2], 1000, .big);
  439. @memcpy(payload[2..], "done!");
  440. const frame = try maskedFrame(t.allocator, true, .close, &payload, .{ 6, 6, 6, 6 });
  441. defer t.allocator.free(frame);
  442. try dec.feed(frame);
  443. var ev = (try dec.next()).?;
  444. defer ev.deinitPayload(t.allocator);
  445. try t.expectEqual(@as(u16, 1000), ev.close.code);
  446. try t.expectEqualStrings("done!", ev.close.reason);
  447. }
  449. test "close with invalid code is 1002" {
  450. var dec = Decoder.init(t.allocator);
  451. defer dec.deinit();
  452. var payload: [2]u8 = undefined;
  453. std.mem.writeInt(u16, payload[0..2], 1006, .big); // 1006 must never appear on the wire
  454. const frame = try maskedFrame(t.allocator, true, .close, &payload, .{ 1, 2, 3, 4 });
  455. defer t.allocator.free(frame);
  456. try dec.feed(frame);
  457. const ev = (try dec.next()).?;
  458. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  459. }
  461. test "fragmented control frame is 1002" {
  462. var dec = Decoder.init(t.allocator);
  463. defer dec.deinit();
  464. const frame = try maskedFrame(t.allocator, false, .ping, "x", .{ 1, 2, 3, 4 });
  465. defer t.allocator.free(frame);
  466. try dec.feed(frame);
  467. const ev = (try dec.next()).?;
  468. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  469. }
  471. test "continuation without message is 1002" {
  472. var dec = Decoder.init(t.allocator);
  473. defer dec.deinit();
  474. const frame = try maskedFrame(t.allocator, true, .continuation, "x", .{ 1, 2, 3, 4 });
  475. defer t.allocator.free(frame);
  476. try dec.feed(frame);
  477. const ev = (try dec.next()).?;
  478. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  479. }
  481. test "new data frame while assembling is 1002" {
  482. var dec = Decoder.init(t.allocator);
  483. defer dec.deinit();
  484. const f1 = try maskedFrame(t.allocator, false, .text, "a", .{ 1, 2, 3, 4 });
  485. defer t.allocator.free(f1);
  486. const f2 = try maskedFrame(t.allocator, true, .text, "b", .{ 1, 2, 3, 4 });
  487. defer t.allocator.free(f2);
  488. try dec.feed(f1);
  489. try dec.feed(f2);
  490. const ev = (try dec.next()).?;
  491. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  492. }
  494. test "oversize message is 1009" {
  495. var dec = Decoder.init(t.allocator);
  496. defer dec.deinit();
  497. dec.max_message_size = 8;
  498. const frame = try maskedFrame(t.allocator, true, .text, "123456789", .{ 1, 2, 3, 4 });
  499. defer t.allocator.free(frame);
  500. try dec.feed(frame);
  501. const ev = (try dec.next()).?;
  502. try t.expectEqual(CLOSE_TOO_BIG, ev.protocol_error);
  503. }
  505. test "16-bit extended length round trip" {
  506. var dec = Decoder.init(t.allocator);
  507. defer dec.deinit();
  508. const big = try t.allocator.alloc(u8, 300);
  509. defer t.allocator.free(big);
  510. @memset(big, 'A');
  511. const frame = try maskedFrame(t.allocator, true, .binary, big, .{ 9, 9, 9, 9 });
  512. defer t.allocator.free(frame);
  513. try dec.feed(frame);
  514. var ev = (try dec.next()).?;
  515. defer ev.deinitPayload(t.allocator);
  516. try t.expectEqual(@as(usize, 300), ev.binary.len);
  517. try t.expectEqual(@as(u8, 'A'), ev.binary[150]);
  518. }
  520. test "writeFrame emits parseable frame" {
  521. const Sink = struct {
  522. var buf: std.ArrayListUnmanaged(u8) = .empty;
  523. fn write(_: ?*anyopaque, data: []const u8) bool {
  524. buf.appendSlice(t.allocator, data) catch return false;
  525. return true;
  526. }
  527. };
  528. defer Sink.buf.deinit(t.allocator);
  529. try t.expect(writeFrame(&Sink.write, null, .text, "server says hi"));
  530. // Parse it back with an unmasked-tolerant decoder (client role)
  531. var dec = Decoder.init(t.allocator);
  532. dec.require_masked = false;
  533. defer dec.deinit();
  534. try dec.feed(Sink.buf.items);
  535. var ev = (try dec.next()).?;
  536. defer ev.deinitPayload(t.allocator);
  537. try t.expectEqualStrings("server says hi", ev.text);
  538. }
  540. test "writeClose encodes code and reason" {
  541. const Sink = struct {
  542. var buf: std.ArrayListUnmanaged(u8) = .empty;
  543. fn write(_: ?*anyopaque, data: []const u8) bool {
  544. buf.appendSlice(t.allocator, data) catch return false;
  545. return true;
  546. }
  547. };
  548. defer Sink.buf.deinit(t.allocator);
  549. try t.expect(writeClose(&Sink.write, null, 1000, "bye"));
  550. var dec = Decoder.init(t.allocator);
  551. dec.require_masked = false;
  552. defer dec.deinit();
  553. try dec.feed(Sink.buf.items);
  554. var ev = (try dec.next()).?;
  555. defer ev.deinitPayload(t.allocator);
  556. try t.expectEqual(@as(u16, 1000), ev.close.code);
  557. try t.expectEqualStrings("bye", ev.close.reason);
  558. }

Branches

Latest commits

  • dc40d859tracker#31 (mission 026): duplicate titles merged — the 68 type+tmdbId pairs held by 157 records were the old tracker's (all migrated); merge.hl repair job (own clock, before the TMDB jobs) keeps one keeper per title (follows/watches > old short id > oldest), moves follows, watches, seasons, cast, credits, timelines, tombstones the rest (mergedInto, never deleted), slugs + short ids 301 to the keeper; stray seasons merged into their listed twin (Reacher S3 watches) or linked when watched; search import re-checks before its put; deploy.sh waits up to 90 s for 200; real copy 68 -> 0 dup ids, az5b2 follows/watches equal; gates 342/0, 32/0, 52/0mre
  • 2667da05tracker#30 (mission 025): /my/ pages from slim cached title cards, episode rows and watch sets (after the jobs /my/series 1.8 s -> 0.06 s, /my/unwatched 4.1 -> 0.18 s); timeline page shows its name once; franchise widget under the poster/title; movies with TV leftovers (First Contact) go through the details repair; tools/count-tmdb-ids.hl; gates 327/0, 52/0, 32/0mre
  • 3909810dantcolony#40: mission references in README/STATUS/docs point to the moved missionsmre
  • e63b1d28antcolony#40: history (LOG.md), worker briefs (missions/) and reports moved here from antcolony, numbered per project; old numbers in antcolony docs/mission-map.mdmre
  • 1cda451dtracker: Hybriel master 190aa11d (#127 both shapes, GC correctness fc838894) — conductor adopts despite /my/series 2.4x after jobs (memory 8.0 → 1.7 GB boot); see reports/071mre
  • c1fa2f2etracker (mission 071): Hybriel master 190aa11d measured on the real copy vs the live binary 8590df63 — NOT adopted (after the first-start jobs /my/series 2.4x slower, /series 1.6x, RSS swings 7.4-12.2 GB; fresh it is flat at 1.7-2.2 GB and /my/unwatched faster), vendor stays 8efba065, candidate kept in .scratch/w071/vendor-190aa11d; tests/kinds.mjs: collection seed off (its TMDB request broke check 1 in 1 of 4 runs); tests/realdata-071.sh + realdata-071-bench.mjs + tools/realdata-071-table.py; README + STATUS (numbers, how to repeat); gates 325/0, 32/0, 50/0mre
  • 8081350atracker docs (mission 070): README (summary, Config HL_GC_BYTES — kept at Hybriel's default, the 256 MiB setting is taken out of docker-compose.yml again: the jobs grew to 12+ GB with it too, see STATUS), Test (three gates), Deploy (first start ~50 min: kinds then seed, restart once after collections done, memory numbers), Vendored Hybriel 8efba065 + #48 audit, Files; STATUS mission 070 entry (merges, migrated counts, lambda audit, gates, RSS old vs new, how to repeat, open points); docs/kinds.md + docs/franchises.md job order; tests/realdata-070-*.sh, tools/count-migrated.hl, tools/ref-params.py, tools/lambda-audit.pymre
  • 1ad19c8ctracker: re-vendor Hybriel master 8efba065 (#126 GC by bytes, #48 lambda parameters copy) (mission 070): bin/hybriel sha256 50361e95…, plugins core crypto data fetch fs http http1 mpackdb proc smtp time web; lambda audit: 13 lambdas change a passed record/list (11 through a local alias), no caller relies on it — unchanged; 319 read-only lambda parameters get & (no copy per call: /my/schedule 2.35 → 0.46 s, /my/unwatched 13.7 → 5.7 s on the real copy); /my/unwatched one merge sort instead of n² inserts; docker-compose HL_GC_BYTES=268435456; deploy.sh runs kinds.mjs + franchises.mjs too (default ports 8700–8710); tests/realdata-070.mjs; gates browser 325/0, kinds 32/0, franchises 50/0mre
  • 46b21389tracker (mission 070, conductor): the sync never destroys migrated data — the one-time summary step MOVES a copied summary to migratedSummary (marker summaries-moved.txt) instead of clearing it; a migrated record's first title/genres/homepage/tagline TMDB replaces → migratedTitle/migratedGenres/migratedHomepage/migratedTagline, a migrated season's/episode's title/summary → migratedTitle/migratedSummary (set once); tests/peek-shows.hl prints them; gate 325/0mre
  • 749019b0Merge t19 (tracker#19 franchises + timelines) into main (mission 070): conflicts README/STATUS/show.hl/project.hl/browser.mjs/faketmdb.mjs, both sides kept; franchise/timeline pages get #20's typed heading (Franchise | …, Timeline | …), their title links via titlePath (/movies|/series|/shows); the collection seed waits for repair, kinds and credits too; franchises.mjs URLs + 2 new checks; gates browser 323/0, kinds 32/0, franchises 50/0mre
  • daf49feaMerge t20 (tracker#20 typed headings + #21 series/shows split) into main (mission 070): conflicts README/STATUS/show.hl/project.hl/search.hl/components/search.hl/browser.mjs/faketmdb.mjs, both sides kept; clock order backfill → repair → kinds → credits; withDetailsFields stores tmdbType + kind; gates: browser.mjs URLs → /series|/movies, typed h1 selectors; kinds.mjs repair/credits off, fixture name = seed name; browser 323/0, kinds 32/0mre
  • 20e09d89Merge t18 (tracker#18 delta sync) into main (mission 070): conflicts README/STATUS/show.hl/project.hl/browser.mjs, both sides kept; pageShowOf summary = summaryOfmre
  • f83571c3tracker#18 (mission 067): daily sync by change lists — TMDB /tv|movie/changes (since the stored day, paged) + TVmaze /updates/shows → only our changed titles (followed: full step, unfollowed: light step — changed seasons, no TVmaze), full walk on first run / gap > 14 days / failed list; show record refreshed (title, tmdbSummary, tagline, status, genres …; renamed titles re-indexed); summary = the creator's own text (page: summary > tmdbSummary > tvmazeSummary), one-time clear of copied summaries (9,647 on the live copy); gate 261, tests/realdata-018*.mjs, README + STATUSmre
  • 1ed5457etracker#20 + #21 (mission 068): typed headings "<Type> | <name>" in type colours; TV titles split into Series (/series) and Shows (/shows) by TMDB type + Reality/Talk/News genres — kind stored by sync/import/adult backfill + new kind backfill (resumes), /movies/<slug>, /shows/<slug> of a series/movie → 301, /my/series + /my/shows, home 5 tiles + 3 rows, search/filmography labels; gates kinds 32 + browser 266, tests/realdata-068.mjs, tools/count-kinds.hl, docs/kinds.md, README + STATUSmre
  • f2b00674Merge t26 (tracker#26 + #28) into main (mission 062): short ids for every new person (castPersonId, guest route), guest stars stored on the title and created as people only when opened (/person/tmdb/<id>?show=<id> → 302), lean watch/follow clicks (showRow a small object, cast/crew from the slug, watches cached per user, face rows only after a season toggle); gate 311, tests/realdata-062.mjs, README + STATUSmre
  • 0553b51ftracker#19 (mission 066): franchises and timelines — tables, /franchises, /franchises/<slug>, /timelines/<slug> (Timeline | Release sort, series by last episode), the Prequel | Timeline | Sequel widget with the franchise above, the creator's editor, TMDB collection seed in the app (resumes, paced); gate tests/franchises.mjs 48/0 + browser.mjs 266/0, tests/realdata-066.mjs, docs/franchises.md, README + STATUSmre
  • fa1f9dfatracker#29 (mission 063): unwatched check muted grey outline + check (accent only on hover), watched stays solid — no code regression, the accent outline read as ticked; gate checks real checks visibly (computed style + screenshot pixel) on /my/unwatched, show, movie, /my/movies; gate 266, tests/realdata-063.mjs, README + STATUSmre
  • 10bb3f93tracker#28 (mission 061): full cast (all seasons, main cast by episodes, guest stars) + crew (created by, directed by, written by, screenplay, story, music) — stored by the details completion, the daily sync, the search import (one details request) and a background credits job (resumes, RSS limit); show page collapsed after 20 with client-side Show all; showBySlug via a slug map; gate 249, tests/realdata-028.mjs, README + STATUSmre
  • d8b12d67tracker#27 (mission 060): short ids for movies, series and persons — old 702 kept (data/old-short-ids.json), new random [a-z0-9]{5} unique across both, claimed at creation, background backfill (resumes), shown under poster/photo, /<shortId> → 301; gate 259, tests/realdata-060*, README + STATUSmre
  • 25a50bc4tracker#26 (mission 059): titles from a filmography are completed — on open (skeleton, step-wise face showComplete, no reload) and by the in-app details repair (resumes, TMDB-paced, series in parts); cast from TMDB credits; gate 231, tests/realdata-026.mjs, README + STATUSmre