gitoria

3.7 KB

1. // ws-handshake-order.mjs — hl:http1 must not answer an Upgrade with its 101 before
2. // the peer is registered and its `connect` queued (039_http1_ws_client, 2026-10-02):
3. // written first, an in-process WebSocketClient could read the 101 and queue `open`
4. // ahead of the server's `connect` (2 of 80 runs under load). Deterministic form:
5. // stalled peers make a broadcast hold the plugin's peer lock for ~100 ms each; an
6. // Upgrade sent meanwhile may get its 101 only after the broadcast let go, because
7. // registering needs that lock. Drives the built libhttp1.so through the interpreter
8. // (ws_handshake_order.hl) with raw sockets.
9. import { spawn } from 'node:child_process';
10. import { connect } from 'node:net';
11. import { fileURLToPath } from 'node:url';
12. import { dirname, resolve } from 'node:path';
14. const HERE = dirname(fileURLToPath(import.meta.url));
15. const ROOT = resolve(HERE, '../../..');
16. const BIN = resolve(ROOT, 'native/zig-out/bin/hybriel');
17. const FIXTURE = resolve(HERE, 'ws_handshake_order.hl');
18. const PORT = Number(process.env.HL_TEST_PORT || 14981);
19. const STALLED = 5;
20. const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
22. const server = spawn(BIN, [FIXTURE], {
23. env: { ...process.env, HL_TEST_PORT: String(PORT) },
24. stdio: ['ignore', 'pipe', 'pipe'],
25. });
26. let log = '';
27. server.stdout.on('data', (d) => { log += d; });
28. server.stderr.on('data', (d) => { log += d; });
29. const finish = (code, msg) => { console.log(msg); server.kill('SIGKILL'); process.exit(code); };
31. let up = false;
32. for (let i = 0; i < 80 && !up; i++) {
33. try { up = (await fetch(`http://127.0.0.1:${PORT}/`)).status === 200; } catch {}
34. if (!up) await sleep(250);
35. }
36. if (!up) finish(1, 'FAIL server did not come up\n' + log.slice(0, 4000));
38. // One raw Upgrade; resolves with the time its 101 arrived. `stall` stops reading after it.
39. const upgrade = (stall) => new Promise((res, rej) => {
40. const sock = connect(PORT, '127.0.0.1');
41. let head = '';
42. sock.on('connect', () => sock.write(
43. `GET / HTTP/1.1\r\nHost: 127.0.0.1:${PORT}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n` +
44. 'Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nSec-WebSocket-Version: 13\r\n\r\n'));
45. sock.on('data', (d) => {
46. if (head === null) return;
47. head += d.toString('latin1');
48. if (!head.includes('\r\n\r\n')) return;
49. if (!head.startsWith('HTTP/1.1 101')) return rej(new Error('no 101: ' + head.slice(0, 200)));
50. head = null;
51. if (stall) sock.pause();
52. res({ at: performance.now(), sock });
53. });
54. sock.on('error', () => {});
55. });
57. const stalled = [];
58. for (let i = 0; i < STALLED; i++) stalled.push(await upgrade(true));
59. await sleep(100); // every stalled peer's `connect` is through
61. let holdDone = 0;
62. const hold = fetch(`http://127.0.0.1:${PORT}/hold`).then(async (r) => { await r.text(); holdDone = performance.now(); });
63. await sleep(150); // the broadcast is inside its first stalled peer
64. const lateSent = performance.now();
65. const late = await upgrade(false);
66. await hold;
67. for (const s of stalled) s.sock.destroy();
68. late.sock.destroy();
70. // The /hold answer leaves only after the handler returns, a few ms after the lock went:
71. // a 101 that waited for the lock lands within those ms, one that did not lands at once.
72. const waited = late.at - lateSent, remaining = holdDone - lateSent;
73. if (remaining < 250) finish(1, `FAIL precondition: the Upgrade was sent only ${remaining.toFixed(0)} ms before the broadcast ended, so nothing was measured`);
74. if (waited < remaining / 2) finish(1, `FAIL the 101 arrived ${waited.toFixed(0)} ms after the Upgrade, ${(remaining - waited).toFixed(0)} ms before the broadcast let the peer lock go — sent before the peer was registered`);
75. finish(0, 'ok ws-handshake-order: an Upgrade during a held broadcast gets its 101 only after the peer is registered');