Skip to content

Commit 1f10a9e

Browse files
yashranawayjuliusmarminge
authored andcommitted
Keep the server alive when a response write hits a dead socket
A client that disconnects while an error response is being written crashes the whole Node server with an unhandled EPIPE, disconnecting every other client and abandoning in-flight provider work. Upgrade sockets are the worst case: once a connection upgrades for websocket RPC, Node's http server detaches its own socket error handling, so an auth rejection written to a vanished client emits an error event with no listener at all. Arm every response and upgrade socket with an error listener when the Node server is created. The failed request is already interrupted through its close event, so the write failure only needs to be observed instead of taking down the process. Fixes #4410
1 parent db02c6b commit 1f10a9e

3 files changed

Lines changed: 145 additions & 1 deletion

File tree

Lines changed: 104 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,104 @@
1+
// @effect-diagnostics nodeBuiltinImport:off
2+
import * as NodeHttp from "node:http";
3+
import * as NodeNet from "node:net";
4+
import { afterEach, describe, expect, it } from "vite-plus/test";
5+
6+
import { guardHttpResponseWriteErrors } from "./httpResponseErrorGuard.ts";
7+
8+
const servers: NodeHttp.Server[] = [];
9+
10+
function listen(server: NodeHttp.Server): Promise<number> {
11+
servers.push(server);
12+
return new Promise((resolve) => {
13+
server.listen(0, "127.0.0.1", () => {
14+
resolve((server.address() as NodeNet.AddressInfo).port);
15+
});
16+
});
17+
}
18+
19+
function fetchStatus(port: number, path: string): Promise<number> {
20+
return new Promise((resolve, reject) => {
21+
const request = NodeHttp.get({ host: "127.0.0.1", port, path }, (response) => {
22+
response.resume();
23+
resolve(response.statusCode ?? 0);
24+
});
25+
request.on("error", reject);
26+
request.setTimeout(5_000, () => reject(new Error("request timed out")));
27+
});
28+
}
29+
30+
afterEach(() => {
31+
for (const server of servers.splice(0)) {
32+
server.close();
33+
}
34+
});
35+
36+
describe("guardHttpResponseWriteErrors", () => {
37+
it("contains an upgrade socket write failure instead of crashing the process", async () => {
38+
const writeErrors: unknown[] = [];
39+
const failureObserved = Promise.withResolvers<void>();
40+
const server = guardHttpResponseWriteErrors(NodeHttp.createServer(), (error) => {
41+
writeErrors.push(error);
42+
failureObserved.resolve();
43+
});
44+
45+
server.on("upgrade", (_request, socket) => {
46+
// Simulate the client vanishing while the auth rejection response is
47+
// written to the upgrade socket: the write failure surfaces as an
48+
// "error" event on a socket Node's http server no longer listens to.
49+
socket.destroy(Object.assign(new Error("write EPIPE"), { code: "EPIPE" }));
50+
});
51+
52+
const port = await listen(server);
53+
54+
const client = NodeNet.connect(port, "127.0.0.1", () => {
55+
client.write(
56+
[
57+
"GET /rpc HTTP/1.1",
58+
"Host: 127.0.0.1",
59+
"Connection: Upgrade",
60+
"Upgrade: websocket",
61+
"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==",
62+
"Sec-WebSocket-Version: 13",
63+
"",
64+
"",
65+
].join("\r\n"),
66+
);
67+
});
68+
client.on("error", () => {});
69+
70+
await failureObserved.promise;
71+
client.destroy();
72+
73+
expect(writeErrors).toHaveLength(1);
74+
expect(writeErrors[0]).toBeInstanceOf(Error);
75+
expect((writeErrors[0] as NodeJS.ErrnoException).code).toBe("EPIPE");
76+
77+
// The process survived the failed write and the server keeps serving.
78+
server.on("request", (_request, response) => {
79+
response.writeHead(200, { "content-type": "text/plain" });
80+
response.end("ok");
81+
});
82+
await expect(fetchStatus(port, "/")).resolves.toBe(200);
83+
});
84+
85+
it("arms every response with an error listener without disturbing normal traffic", async () => {
86+
const writeErrors: unknown[] = [];
87+
let responseErrorListeners = -1;
88+
const server = guardHttpResponseWriteErrors(NodeHttp.createServer(), (error) => {
89+
writeErrors.push(error);
90+
});
91+
92+
server.on("request", (_request, response) => {
93+
responseErrorListeners = response.listenerCount("error");
94+
response.writeHead(200, { "content-type": "text/plain" });
95+
response.end("ok");
96+
});
97+
98+
const port = await listen(server);
99+
100+
await expect(fetchStatus(port, "/")).resolves.toBe(200);
101+
expect(responseErrorListeners).toBeGreaterThan(0);
102+
expect(writeErrors).toEqual([]);
103+
});
104+
});
Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
// @effect-diagnostics nodeBuiltinImport:off
2+
import type * as NodeHttp from "node:http";
3+
4+
/**
5+
* Node surfaces late socket write failures (EPIPE, ECONNRESET,
6+
* ERR_STREAM_DESTROYED) as "error" events. An "error" event without a
7+
* listener escalates into an uncaught exception and terminates the whole
8+
* server process, taking every other client and all in-flight provider
9+
* work with it.
10+
*
11+
* Two emitters need coverage:
12+
*
13+
* - Upgrade sockets. Once a connection upgrades (the websocket RPC path,
14+
* including its auth rejection responses), Node's http server detaches
15+
* its own socket error handling, so the raw socket has no listener at
16+
* all until the websocket server adopts it.
17+
* - Server responses. Response streams have no default error listener
18+
* either.
19+
*
20+
* A disconnected client only affects its own request: the request fiber is
21+
* already interrupted through the response "close" event, so the write
22+
* failure needs no handling beyond being observed.
23+
*/
24+
export function guardHttpResponseWriteErrors<T extends NodeHttp.Server>(
25+
server: T,
26+
onError?: (error: unknown) => void,
27+
): T {
28+
server.on("request", (_request, response) => {
29+
response.on("error", (error) => {
30+
onError?.(error);
31+
});
32+
});
33+
server.on("upgrade", (_request, socket) => {
34+
socket.on("error", (error) => {
35+
onError?.(error);
36+
});
37+
});
38+
return server;
39+
}

‎apps/server/src/server.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ import {
1818
browserApiCorsLayer,
1919
httpCompressionLayer,
2020
} from "./http.ts";
21+
import { guardHttpResponseWriteErrors } from "./httpResponseErrorGuard.ts";
2122
import { fixPath } from "./os-jank.ts";
2223
import { websocketRpcRouteLayer } from "./ws.ts";
2324
import * as ExternalLauncher from "./process/externalLauncher.ts";
@@ -209,7 +210,7 @@ const HttpServerLive = Layer.unwrap(
209210
Effect.promise(() => import("@effect/platform-node/NodeHttpServer")),
210211
Effect.promise(() => import("node:http")),
211212
]);
212-
return NodeHttpServer.layer(NodeHttp.createServer, {
213+
return NodeHttpServer.layer(() => guardHttpResponseWriteErrors(NodeHttp.createServer()), {
213214
host: config.host ?? "127.0.0.1",
214215
port: config.port,
215216
gracefulShutdownTimeout: HTTP_PREEMPTIVE_SHUTDOWN_GRACE_MS,

0 commit comments

Comments
 (0)