Skip to content

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

7.7 KB
Raw Blame
/**
 * 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();
  });
});