Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
/**
* Shutdown drain contract (#8323), exercised against real listeners because the
* behaviour under test is Node's own connection handling: `server.close()` alone
* keeps serving requests on already-open keep-alive sockets, and the drain has to
* both let accepted work finish and keep new work out.
*/
import { describe, it, expect, afterEach } from 'vitest';
import http from 'node:http';
import net from 'node:net';
import { createHttpDrain } from './httpDrain.js';
const opened = [];
afterEach(() => {
for (const server of opened.splice(0)) server.closeAllConnections();
});
const listen = async (handler) => {
const server = http.createServer(handler);
opened.push(server);
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
return { server, port: server.address().port };
};
const request = (port, path, agent = false) => new Promise((resolve) => {
http.get({ host: '127.0.0.1', port, path, agent }, (res) => {
let body = '';
res.on('data', (chunk) => { body += chunk; });
res.on('end', () => resolve({ status: res.statusCode, connection: res.headers.connection, body }));
res.on('error', (err) => resolve({ error: err.code }));
}).on('error', (err) => resolve({ error: err.code }));
});
// A raw connection whose request is only partly written — the server has
// accepted the socket, but the request is not complete until `finish()`.
const openPartialRequest = async (port, path) => {
const socket = net.connect(port, '127.0.0.1');
await new Promise((resolve) => socket.once('connect', resolve));
socket.write(`GET ${path} HTTP/1.1\r\nHost: localhost\r\n`);
let raw = '';
socket.on('data', (chunk) => { raw += chunk; });
const closed = new Promise((resolve) => socket.once('close', () => resolve(raw)));
return { finish: () => { socket.write('\r\n'); return closed; } };
};
const deferred = () => {
let resolve;
const promise = new Promise((r) => { resolve = r; });
return { promise, resolve };
};
// A raw connection accepted before the drain begins with an incomplete upgrade
// request. The partial header keeps it active: Node's server.close() drops idle
// sockets, so a merely connected but idle socket would close before the upgrade
// handler could refuse its completed request.
const openUpgradeRequest = async (port, path) => {
const socket = net.connect(port, '127.0.0.1');
await new Promise((resolve) => socket.once('connect', resolve));
socket.write(
`GET ${path} HTTP/1.1\r\nHost: localhost\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n`,
);
let raw = '';
socket.on('data', (chunk) => { raw += chunk; });
const closed = new Promise((resolve) => socket.once('close', () => resolve(raw)));
return {
finish: () => {
socket.write('\r\n');
return closed;
},
};
};
describe('createHttpDrain', () => {
it('lets an accepted request finish while both listeners refuse new requests', async () => {
const handled = [];
const release = deferred();
const handler = async (req, res) => {
handled.push(req.url);
if (req.url === '/slow') await release.promise;
res.end(`done ${req.url}`);
};
const primary = await listen(handler);
const mirror = await listen(handler);
const drain = createHttpDrain([primary.server, mirror.server, null]);
// A keep-alive client, so the response must actively opt out of reuse.
const keepAlive = new http.Agent({ keepAlive: true });
const slow = request(primary.port, '/slow', keepAlive);
const pending = await openPartialRequest(mirror.port, '/late');
while (!handled.includes('/slow')) await new Promise((r) => setImmediate(r));
let drained = null;
drain.begin(5000).then((result) => { drained = result; });
// New connections are refused on both listeners, and a request completed on
// a socket accepted before the drain never reaches the handler.
expect(await request(primary.port, '/new')).toEqual({ error: 'ECONNREFUSED' });
expect(await request(mirror.port, '/new')).toEqual({ error: 'ECONNREFUSED' });
const refused = await pending.finish();
expect(refused).toMatch(/^HTTP\/1\.1 503 /);
expect(refused).toMatch(/connection: close/i);
expect(drained).toBeNull();
release.resolve();
expect(await slow).toEqual({ status: 200, connection: 'close', body: 'done /slow' });
await new Promise((r) => setImmediate(r));
expect(drained).toEqual({ remaining: 0 });
expect(handled).toEqual(['/slow']);
keepAlive.destroy();
});
it('drops event streams at once and stops waiting on stuck requests at the deadline', async () => {
const stuckArrived = deferred();
const { server, port } = await listen((req, res) => {
if (req.url === '/events') {
res.writeHead(200, { 'Content-Type': 'text/event-stream' });
res.write('data: hello\n\n');
}
// '/stuck' never answers — but the drain may only begin once the server
// has actually received it, or a slow runner (Windows CI) drains an idle
// server and reports nothing remaining.
if (req.url === '/stuck') stuckArrived.resolve();
});
const drain = createHttpDrain([server]);
const events = new Promise((resolve) => {
http.get({ host: '127.0.0.1', port, path: '/events', agent: false }, (res) => {
res.once('data', () => resolve({ closed: new Promise((done) => res.once('close', done)) }));
});
});
const { closed: streamClosed } = await events;
const stuck = request(port, '/stuck');
await stuckArrived.promise;
const drained = drain.begin(100);
await streamClosed;
expect(await drained).toEqual({ remaining: 1 });
server.closeAllConnections();
expect(await stuck).toEqual({ error: 'ECONNRESET' });
});
it('refuses a WebSocket upgrade on a still-open socket once the drain begins', async () => {
const upgradeCalls = [];
const requestStarted = deferred();
const { server, port } = await listen((req, res) => res.end('ok'));
server.once('connection', (socket) => socket.once('data', requestStarted.resolve));
server.on('upgrade', (req, socket) => {
upgradeCalls.push(req.url);
socket.write('HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n');
});
const drain = createHttpDrain([server]);
const pending = await openUpgradeRequest(port, '/socket.io/');
await requestStarted.promise;
drain.begin(5000);
const refused = await pending.finish();
expect(refused).toMatch(/^HTTP\/1\.1 503 /);
expect(refused).toMatch(/connection: close/i);
expect(upgradeCalls).toEqual([]);
});
it('destroyUpgraded lets server.close() finish despite an upgraded socket whose peer never closes (#11849)', async () => {
const { server, port } = await listen((req, res) => res.end('ok'));
server.on('upgrade', (req, socket) => {
socket.write('HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n');
});
const drain = createHttpDrain([server]);
const client = net.connect(port, '127.0.0.1');
const handshake = deferred();
client.once('data', handshake.resolve);
client.on('error', () => {});
client.write('GET /ws HTTP/1.1\r\nHost: localhost\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n');
await handshake.promise;
drain.begin(5000);
server.closeAllConnections();
const closed = new Promise((resolve) => server.close(resolve));
const outcome = await Promise.race([closed.then(() => 'closed'), new Promise((r) => setTimeout(() => r('stuck'), 200))]);
expect(outcome).toBe('stuck');
drain.destroyUpgraded();
expect(await Promise.race([closed.then(() => 'closed'), new Promise((r) => setTimeout(() => r('stuck'), 1000))])).toBe('closed');
client.destroy();
});
});