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

fix: destroy upgraded WebSocket sockets at shutdown so HTTP close no longer times out (#11849)

Adam Eivy65a89cb670fa
diff --git a/server/lib/httpDrain.js b/server/lib/httpDrain.js
index 1f7a99e4ee..73a8c8fb76 100644
--- a/server/lib/httpDrain.js
+++ b/server/lib/httpDrain.js
@@ -13,7 +13,8 @@
// the same way, so a WebSocket `Upgrade:` request on a still-open
// keep-alive socket gets a raw 503 instead of reaching those handlers.
// Sockets already upgraded before the drain began never emit 'upgrade'
-// again — their owners close them;
+// again — their owners close them, and `destroyUpgraded()` force-drops
+// whatever is left (closeAllConnections() cannot see them);
// - in-flight responses are told not to keep their socket alive, and an open
// SSE stream (which never ends on its own) is dropped outright.
//
@@ -72,6 +73,22 @@ export const createHttpDrain = (servers) => {
};
for (const server of listeners) server.prependListener('request', track);
+ // A socket handed to an 'upgrade' listener is detached from the HTTP server's
+ // connection tracking, so closeAllConnections() never destroys it, yet
+ // server.close() waits for it. Track them here (#11849; #6994 only raised the grace).
+ const upgraded = new Set();
+ const trackUpgrade = (req, socket) => {
+ upgraded.add(socket);
+ socket.once('close', () => upgraded.delete(socket));
+ };
+ for (const server of listeners) server.prependListener('upgrade', trackUpgrade);
+
+ // Call after the sockets' owners (Socket.IO) have sent their close frames.
+ const destroyUpgraded = () => {
+ for (const socket of upgraded) socket.destroy();
+ upgraded.clear();
+ };
+
const begin = (windowMs) => {
if (draining) return draining;
draining = new Promise((resolve) => {
@@ -102,5 +119,5 @@ export const createHttpDrain = (servers) => {
return draining;
};
- return { begin };
+ return { begin, destroyUpgraded };
};
diff --git a/server/lib/httpDrain.test.js b/server/lib/httpDrain.test.js
index c6e9bf3583..32433264ff 100644
--- a/server/lib/httpDrain.test.js
+++ b/server/lib/httpDrain.test.js
@@ -159,4 +159,29 @@ describe('createHttpDrain', () => {
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();
+ });
});
diff --git a/server/services/bootstrap.js b/server/services/bootstrap.js
index e19fc83b8c..6fddc1ebe7 100644
--- a/server/services/bootstrap.js
+++ b/server/services/bootstrap.js
@@ -1222,6 +1222,9 @@ export const registerShutdownHandlers = ({ io, httpServer, localHttpServer }) =>
// (ERR_SERVER_NOT_RUNNING → treated as success by closeServer), and
// the bounded backstop in closeServer guarantees neither can hang shutdown even
// if a future socket.io version changes which server it owns.
+ // Upgraded (WebSocket) sockets are invisible to closeAllConnections() but
+ // keep server.close() pending; Socket.IO has already sent its close frames.
+ httpDrain.destroyUpgraded();
await Promise.all([
closeServer(httpServer, 'HTTP server'),
closeServer(localHttpServer, 'Local HTTP mirror')