Skip to content
TypeScript

fix(client): a big server config on a slow link no longer drops the connection in a loop (#23758)

shivamb9522c845b06
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 1b078b192c1..3eba0e1e576 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -262,6 +262,10 @@ import * as SessionStore from "./auth/SessionStore.ts";
import { failEnvironmentAuthInvalid, failEnvironmentInternal } from "./auth/http.ts";
import { isNetworkPath } from "@t3tools/shared/path";
import * as RelayClient from "@t3tools/shared/relayClient";
+import {
+ SOCKET_FRAME_PARTS_QUERY_PARAM,
+ splitLargeSocketFrames,
+} from "@t3tools/shared/socketFrameParts";
import { isTelemetryIdHash } from "@t3tools/shared/telemetryId";
import {
sameUsageLimitCommandCoverage,
@@ -3533,11 +3537,25 @@ export const layer = Layer.unwrap(
),
),
);
+ const framedRpcWebSocketHttpEffect = url.value.searchParams.has(
+ SOCKET_FRAME_PARTS_QUERY_PARAM,
+ )
+ ? rpcWebSocketHttpEffect.pipe(
+ Effect.provideService(
+ HttpServerRequest.HttpServerRequest,
+ // The RPC server upgrades the request itself, so its socket is
+ // wrapped through the request it reads.
+ Object.create(request, {
+ upgrade: { value: Effect.map(request.upgrade, splitLargeSocketFrames) },
+ }),
+ ),
+ )
+ : rpcWebSocketHttpEffect;
return yield* Effect.acquireUseRelease(
sessions.markConnected(session.sessionId),
() =>
Effect.raceFirst(
- rpcWebSocketHttpEffect,
+ framedRpcWebSocketHttpEffect,
sessions.awaitInvalidation(session.sessionId, session.proofKeyThumbprint).pipe(
Effect.as(HttpServerResponse.empty()),
Effect.catchTags({
diff --git a/packages/client-runtime/src/rpc/session.test.ts b/packages/client-runtime/src/rpc/session.test.ts
index 95702f14787..9e63f8485ad 100644
--- a/packages/client-runtime/src/rpc/session.test.ts
+++ b/packages/client-runtime/src/rpc/session.test.ts
@@ -8,6 +8,7 @@ import {
WS_METHODS,
UsageLimitSourceId,
} from "@t3tools/contracts";
+import { splitSocketFrame } from "@t3tools/shared/socketFrameParts";
import { describe, expect, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
@@ -21,6 +22,7 @@ import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import * as Socket from "effect/socket/Socket";
+import * as TestClock from "effect/testing/TestClock";
import {
AVAILABLE_CONNECTION_STATE,
@@ -275,6 +277,36 @@ const publishConfigEvents = Effect.fn("TestRpcSessionFactory.publishConfigEvents
});
describe("RpcSessionFactory", () => {
+ it.effect("connects while a large config snapshot downloads at 4000 bytes per second", () =>
+ Effect.gen(function* () {
+ const { factory, sockets } = yield* makeFactory();
+ const session = yield* factory.connect(PREPARED);
+ const readyFiber = yield* Effect.forkChild(session.ready);
+ const socket = yield* awaitSocket(sockets);
+ socket.open();
+ const request = yield* awaitRequest(socket);
+ // Multi-byte text, so parts must be sized in UTF-8 bytes and never split a surrogate pair.
+ const config = { ...SERVER_CONFIG, cwd: "/" + "é€😀x".repeat(32 * 1024) };
+ const frame = encodeJson({
+ _tag: "Chunk",
+ requestId: request.id,
+ values: [{ version: 1, type: "snapshot", config: encodeServerConfig(config) }],
+ });
+ const parts = new URL(socket.url).searchParams.has("frameParts")
+ ? splitSocketFrame(frame)
+ : [frame];
+
+ for (const part of parts) {
+ const bytes = new TextEncoder().encode(part);
+ yield* TestClock.adjust((bytes.length / 4000) * 1000);
+ socket.serverMessage(new TextDecoder().decode(bytes));
+ }
+ yield* Fiber.join(readyFiber);
+
+ expect(yield* session.initialConfig).toEqual(config);
+ }),
+ );
+
it.effect("owns one scoped websocket attempt and exposes readiness and closure", () =>
Effect.gen(function* () {
const { factory, sockets } = yield* makeFactory();
@@ -282,7 +314,7 @@ describe("RpcSessionFactory", () => {
const readyFiber = yield* Effect.forkChild(session.ready);
const socket = yield* awaitSocket(sockets);
- expect(socket.url).toBe(PREPARED.socketUrl);
+ expect(socket.url).toBe(`${PREPARED.socketUrl}&frameParts=1`);
socket.open();
yield* completeInitialConfig(socket);
yield* Fiber.join(readyFiber);
diff --git a/packages/client-runtime/src/rpc/session.ts b/packages/client-runtime/src/rpc/session.ts
index fa654561844..ddf591b1391 100644
--- a/packages/client-runtime/src/rpc/session.ts
+++ b/packages/client-runtime/src/rpc/session.ts
@@ -4,6 +4,10 @@ import {
WsSubscribeServerConfigRpc,
WS_METHODS,
} from "@t3tools/contracts";
+import {
+ joinSocketFrameParts,
+ SOCKET_FRAME_PARTS_QUERY_PARAM,
+} from "@t3tools/shared/socketFrameParts";
import * as Cause from "effect/Cause";
import * as Context from "effect/Context";
import * as Deferred from "effect/Deferred";
@@ -223,9 +227,17 @@ export const make = Effect.fn("RpcSessionFactory.make")(function* (
});
return socket;
};
- const layerSocket = Socket.layerWebSocket(connection.socketUrl, {
- openTimeout: SOCKET_OPEN_TIMEOUT,
- }).pipe(
+ const socketUrl = new URL(connection.socketUrl);
+ socketUrl.searchParams.set(SOCKET_FRAME_PARTS_QUERY_PARAM, "1");
+ const layerSocket = Layer.effect(
+ Socket.Socket,
+ Effect.map(Effect.service(Socket.Socket), joinSocketFrameParts),
+ ).pipe(
+ Layer.provide(
+ Socket.layerWebSocket(socketUrl.toString(), {
+ openTimeout: SOCKET_OPEN_TIMEOUT,
+ }),
+ ),
Layer.provide(Layer.succeed(Socket.WebSocketConstructor, countingWebSocketConstructor)),
);
const layerProtocol = Layer.effect(
diff --git a/packages/shared/package.json b/packages/shared/package.json
index b09248b2163..67426ca8d8a 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -19,6 +19,10 @@
"types": "./src/delimitedPreview.ts",
"import": "./src/delimitedPreview.ts"
},
+ "./socketFrameParts": {
+ "types": "./src/socketFrameParts.ts",
+ "import": "./src/socketFrameParts.ts"
+ },
"./composerPullRequestMatches": {
"types": "./src/composerPullRequestMatches.ts",
"import": "./src/composerPullRequestMatches.ts"
diff --git a/packages/shared/src/socketFrameParts.ts b/packages/shared/src/socketFrameParts.ts
new file mode 100644
index 00000000000..e0c82a87de3
--- /dev/null
+++ b/packages/shared/src/socketFrameParts.ts
@@ -0,0 +1,81 @@
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Socket from "effect/socket/Socket";
+
+// Old clients omit this; old servers ignore it.
+export const SOCKET_FRAME_PARTS_QUERY_PARAM = "frameParts";
+
+// WebSocket messages arrive whole. At 4,000 bytes/s each part takes about
+// 12 seconds, leaving margin before the client's 15-second liveness timeout.
+const SOCKET_FRAME_PART_BYTES = 48 * 1024;
+
+// No JSON message starts with a record separator. It marks every part but the last.
+const PART_PREFIX = "\u001e";
+
+// The RPC client only counts frames that decode to messages as liveness, and
+// ignores pongs, so each held-back part reads to it as one.
+const PART_RECEIVED_FRAME = '{"_tag":"Pong"}';
+
+/** Splits on the UTF-8 size the frame has on the wire, never inside a surrogate pair. */
+export function splitSocketFrame(
+ frame: string,
+ partBytes = SOCKET_FRAME_PART_BYTES,
+): Arr.NonEmptyReadonlyArray<string> {
+ // UTF-8 spends at most 3 bytes on a UTF-16 code unit.
+ if (frame.length * 3 <= partBytes) return [frame];
+ const parts: Array<string> = [];
+ let start = 0;
+ let bytes = PART_PREFIX.length;
+ for (let index = 0; index < frame.length;) {
+ const code = frame.charCodeAt(index);
+ const pair = code >= 0xd800 && code <= 0xdbff && index + 1 < frame.length;
+ const size = pair ? 4 : code < 0x80 ? 1 : code < 0x800 ? 2 : 3;
+ if (bytes + size > partBytes) {
+ parts.push(PART_PREFIX + frame.slice(start, index));
+ start = index;
+ bytes = PART_PREFIX.length;
+ }
+ bytes += size;
+ index += pair ? 2 : 1;
+ }
+ return Arr.append(parts, frame.slice(start));
+}
+
+/** Server side: sends string frames longer than one part as consecutive parts. */
+export function splitLargeSocketFrames(socket: Socket.Socket): Socket.Socket {
+ const split = (chunk: string | Uint8Array): Arr.NonEmptyReadonlyArray<string | Uint8Array> =>
+ typeof chunk === "string" ? splitSocketFrame(chunk) : [chunk];
+ return Socket.make({
+ reader: socket.reader,
+ writer: Effect.map(socket.writer, (writer) => ({
+ write: (chunk) =>
+ typeof chunk === "string" ? writer.writeAll(splitSocketFrame(chunk)) : writer.write(chunk),
+ writeAll: (chunks) => writer.writeAll(Arr.flatMap(chunks, split)),
+ })),
+ });
+}
+
+/** Client side: joins parts back into whole frames. */
+export function joinSocketFrameParts(socket: Socket.Socket): Socket.Socket {
+ return Socket.make({
+ reader: Effect.map(socket.reader, (reader) => {
+ let pending = "";
+ const join = (frame: string | Uint8Array) => {
+ if (typeof frame !== "string") return frame;
+ if (frame.startsWith(PART_PREFIX)) {
+ pending += frame.slice(PART_PREFIX.length);
+ return PART_RECEIVED_FRAME;
+ }
+ if (pending === "") return frame;
+ const whole = pending + frame;
+ pending = "";
+ return whole;
+ };
+ return {
+ upgrade: reader.upgrade,
+ pull: Effect.map(reader.pull, Arr.map(join)),
+ };
+ }),
+ writer: socket.writer,
+ });
+}