AtlatestRepositorysigil-http3

sigil-http3 / tree / testtest-echo-lifecycle.mjs

1// Linux lifecycle checks. The executable fixture opens no sockets and
2// its synthetic acceptance receipt is never evidence of real WebTransport.
3import assert from 'node:assert/strict';
4import { spawn } from 'node:child_process';
5import { createHash } from 'node:crypto';
6import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync,
7 readFileSync, writeFileSync } from 'node:fs';
8import { hostname } from 'node:os';
9import { join, resolve } from 'node:path';
10import { test } from 'node:test';
11import { identity, inspectPlan, runTest, sameIdentity, stopRun } from '../scripts/echo-lifecycle.mjs';
13const root = resolve('build/lifecycle');
14const runner = resolve('scripts/echo-lifecycle.mjs');
15const certificateDirectory = join(root, 'certificate');
16const certificate = JSON.parse(readFileSync(join(certificateDirectory, 'certificate.json')));
17const digest = path => createHash('sha256').update(readFileSync(path)).digest('hex');
18const pause = ms => new Promise(done => setTimeout(done, ms));
19const synthetic = {
20 mode: 'webtransport-echo', ready: true, bidirectionalEcho: true, unidirectionalEcho: true,
21 datagramEcho: true, chromeReaped: true, serverReaped: true,
22 sourceRevision: '0'.repeat(40), quicRevision: '0'.repeat(40),
23 browser: 'SOCKET-FREE FIXTURE', profile: 'synthetic unit test; not interop',
24 server: Object.fromEntries(['configurableBind', 'retry', 'antiAmplification', 'peerAddressLogging',
25 'pathChangeLogging', 'cidChangeLogging', 'boundedAdmission', 'echoOnly'].map(key => [key, true])),
26};
27const fixtureSource = `#!${process.execPath}
28import { readFileSync, writeFileSync, renameSync } from 'node:fs';
29import { createHash } from 'node:crypto';
30const env = process.env;
31const certificateSha256 = createHash('sha256')
32 .update(readFileSync(env.HTTP3_CERTIFICATE_DIR + '/cert.der')).digest('hex');
33const ready = { testId: env.HTTP3_TEST_ID, bindAddress: env.HTTP3_BIND_ADDRESS,
34 port: Number(env.HTTP3_PORT), certificateSha256, retry: true, antiAmplification: true };
35if (env.HTTP3_TEST_ID === 'wrong-ready') ready.port++;
36writeFileSync(env.HTTP3_READY_FILE + '.next', JSON.stringify(ready), { mode: 0o600 });
37renameSync(env.HTTP3_READY_FILE + '.next', env.HTTP3_READY_FILE);
38if (env.HTTP3_TEST_ID === 'log-budget') process.stdout.write(Buffer.alloc(9 * 1024 * 1024, 120));
39process.on('SIGTERM', () => process.exit(0));
40setInterval(() => {}, 1000);
41`;
42function fixture(name = 'fixture', seconds = 2) {
43 const directory = mkdtempSync(join(root, 'case-'));
44 const binary = join(directory, 'server.mjs');
45 writeFileSync(binary, fixtureSource, { mode: 0o700 });
46 const receiptPath = join(directory, 'receipt.json');
47 const receipt = { ...synthetic, binarySha256: digest(binary), certificateSha256: certificate.sha256,
48 server: { ...synthetic.server } };
49 const config = { schema: 1, testId: name, expectedHost: hostname(), binary,
50 binarySha256: receipt.binarySha256, certificateDirectory, runDirectory: join(directory, 'run'),
51 interopReceipt: receiptPath, bindAddress: '127.0.0.1', port: 54433, lifetimeSeconds: seconds,
52 authority: '127.0.0.1:54433', origins: ['http://127.0.0.1:54434'] };
53 const path = join(directory, 'config.json');
54 const save = () => {
55 writeFileSync(path, JSON.stringify(config));
56 writeFileSync(receiptPath, JSON.stringify(receipt));
57 };
58 save();
59 return { config, receipt, path, save };
61function launch(t, configPath) {
62 const child = spawn(process.execPath, [runner, 'run', configPath], { stdio: ['ignore', 'pipe', 'pipe'] });
63 const admitted = identity(child.pid);
64 assert.ok(admitted);
65 let output = '';
66 let closed = false;
67 for (const stream of [child.stdout, child.stderr]) stream.on('data', bytes => { output += bytes; });
68 const done = new Promise((resolveDone, reject) => {
69 child.once('error', reject);
70 child.once('close', code => { closed = true; resolveDone({ code, output }); });
71 });
72 const deadline = setTimeout(() => {
73 if (!closed && sameIdentity(admitted, identity(child.pid))) child.kill('SIGTERM');
74 }, 12000);
75 t.after(async () => {
76 clearTimeout(deadline);
77 if (!closed && sameIdentity(admitted, identity(child.pid))) child.kill('SIGTERM');
78 await done;
79 });
80 return { done };
82function state(config) { return JSON.parse(readFileSync(join(config.runDirectory, 'state.json'))); }
83function reaped(config) {
84 const result = state(config);
85 assert.equal(result.phase, 'finished');
86 assert.equal(result.childReaped, true);
87 assert.equal(identity(result.child.pid), null, 'Owned fixture must have been reaped');
88 return result;
91test('parent cancellation reaps its admitted child without signalling the parent', async t => {
92 const f = fixture('parent-cancel', 5);
93 const cancellation = new AbortController();
94 const running = runTest(f.path, { signal: cancellation.signal });
95 t.after(async () => { cancellation.abort(); await running.catch(() => {}); });
96 const deadline = Date.now() + 5000;
97 while (!existsSync(join(f.config.runDirectory, 'state.json')) || state(f.config).phase !== 'ready') {
98 assert.ok(Date.now() < deadline, 'Owned fixture readiness deadline');
99 await pause(25);
100 }
101 cancellation.abort();
102 await running;
103 assert.equal(reaped(f.config).reason, 'parent-stop');
104});
106test('plan is read-only and rejects capability-only or unproved admission', () => {
107 const f = fixture();
108 assert.equal(inspectPlan(f.path).ready, true);
109 assert.equal(existsSync(f.config.runDirectory), false);
110 f.config.lifetimeSeconds = 7200; f.save();
111 assert.equal(inspectPlan(f.path).ready, true, 'A two-hour plan remains read-only');
112 f.config.lifetimeSeconds = 7201; f.save();
113 assert.throws(() => inspectPlan(f.path), /7200/);
114 f.config.lifetimeSeconds = 2;
115 f.config.bindAddress = '0.0.0.0'; f.save();
116 assert.throws(() => inspectPlan(f.path), /configured run scope/);
117 f.config.bindAddress = '::1'; f.config.authority = '[::1]:54433'; f.save();
118 assert.equal(inspectPlan(f.path).ready, true);
119 f.config.authority = '[::1]:54435'; f.save();
120 assert.throws(() => inspectPlan(f.path), /admitted bind and port/);
121 f.config.bindAddress = '127.0.0.1'; f.config.authority = '127.0.0.1:54433'; f.save();
122 f.receipt.mode = 'capability-preflight'; f.save();
123 assert.equal(inspectPlan(f.path).ready, false);
124 f.receipt.mode = 'webtransport-echo'; f.receipt.server.retry = false; f.save();
125 assert.match(inspectPlan(f.path).blockers.join(' '), /retry/);
126 f.receipt.server.retry = true; f.receipt.datagramEcho = false; f.save();
127 assert.equal(inspectPlan(f.path).ready, false);
128});
130test('plan binds host, exact binary/certificate, key permissions and fresh run directory', () => {
131 const f = fixture();
132 f.config.expectedHost = hostname() + '-wrong'; f.save();
133 assert.throws(() => inspectPlan(f.path), /host/);
134 f.config.expectedHost = hostname(); f.config.binarySha256 = '0'.repeat(64); f.save();
135 assert.throws(() => inspectPlan(f.path), /binary SHA/);
136 f.config.binarySha256 = f.receipt.binarySha256;
137 f.receipt.certificateSha256 = '0'.repeat(64); f.save();
138 assert.match(inspectPlan(f.path).blockers.join(' '), /exact binary and certificate/);
139 f.receipt.certificateSha256 = certificate.sha256;
140 const badCertificate = join(f.config.binary, '..', 'certificate');
141 mkdirSync(badCertificate);
142 copyFileSync(join(certificateDirectory, 'cert.der'), join(badCertificate, 'cert.der'));
143 copyFileSync(join(certificateDirectory, 'private.raw'), join(badCertificate, 'private.raw'));
144 chmodSync(join(badCertificate, 'private.raw'), 0o644);
145 f.config.certificateDirectory = badCertificate; f.save();
146 assert.throws(() => inspectPlan(f.path), /signing key/);
147 f.config.certificateDirectory = certificateDirectory; f.save();
148 mkdirSync(f.config.runDirectory, { mode: 0o700 });
149 assert.match(inspectPlan(f.path).blockers.join(' '), /already exists/);
150});
152test('lifetime shutdown reaps only the admitted socket-free child', async t => {
153 const f = fixture();
154 const result = await launch(t, f.path).done;
155 assert.equal(result.code, 0, result.output);
156 assert.equal(reaped(f.config).reason, 'lifetime');
157});
159test('manual teardown reaches supervisor, reaps child and is idempotent', async t => {
160 const f = fixture('manual-stop', 8);
161 const running = launch(t, f.path);
162 const deadline = Date.now() + 5000;
163 while ((!existsSync(join(f.config.runDirectory, 'state.json')) || state(f.config).phase !== 'ready') &&
164 Date.now() < deadline) await pause(25);
165 assert.equal(state(f.config).phase, 'ready');
166 assert.equal(stopRun(f.config.runDirectory).stopRequested, true);
167 const result = await running.done;
168 assert.equal(result.code, 0, result.output);
169 assert.equal(reaped(f.config).reason, 'SIGTERM');
170 assert.equal(stopRun(f.config.runDirectory).alreadyFinished, true);
171});
173test('teardown refuses a reused PID identity before sending a signal', () => {
174 const f = fixture();
175 mkdirSync(f.config.runDirectory, { mode: 0o700 });
176 const supervisor = { ...identity(process.pid), start: 'wrong-start' };
177 writeFileSync(join(f.config.runDirectory, 'state.json'), JSON.stringify({ schema: 1,
178 phase: 'ready', supervisor }), { mode: 0o600 });
179 assert.throws(() => stopRun(f.config.runDirectory), /Refusing reused PID/);
180});
182test('readiness mismatch fails and reaps its owned child', async t => {
183 const f = fixture('wrong-ready');
184 const result = await launch(t, f.path).done;
185 assert.equal(result.code, 1, result.output);
186 assert.match(reaped(f.config).error, /readiness contract/);
187});
189test('log budget bounds retained bytes and reaps its owned child', async t => {
190 const f = fixture('log-budget');
191 const result = await launch(t, f.path).done;
192 assert.equal(result.code, 1, result.output);
193 assert.match(reaped(f.config).error, /log budget/);
194 assert.equal(readFileSync(join(f.config.runDirectory, 'stdout.log')).length, 8388608);
195});