Skip to content

Commit 931e915

Browse files
authored
Keep the server alive when a response write hits a dead socket (pingdotgg#4470)
1 parent 04f2309 commit 931e915

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)