TypeScript
fix(client-runtime): a thread keeps syncing after a stream defect (#31071)
Julius Marminge8ab024f31a6d
diff --git a/packages/client-runtime/src/rpc/client.test.ts b/packages/client-runtime/src/rpc/client.test.tsindex b15b20753d3..e9779c4f866 100644--- a/packages/client-runtime/src/rpc/client.test.ts+++ b/packages/client-runtime/src/rpc/client.test.ts@@ -8,12 +8,12 @@ import { describe, expect, it } from "@effect/vitest";import * as Cause from "effect/Cause";import * as Deferred from "effect/Deferred";import * as Effect from "effect/Effect";-import * as Exit from "effect/Exit";import * as Fiber from "effect/Fiber";import * as Option from "effect/Option";import * as Queue from "effect/Queue";import * as Ref from "effect/Ref";import * as Stream from "effect/Stream";+import * as TestClock from "effect/testing/TestClock";import * as SubscriptionRef from "effect/SubscriptionRef";import { RpcClientError } from "effect/rpc";@@ -347,7 +347,7 @@ describe("environment RPC", () => {);it.effect.each(["input", "stream"] as const)(- "does not classify %s subscription defects as expected failures",+ "reports %s subscription defects and resubscribes on the next session",(where) =>Effect.gen(function* () {const defect = new Error("subscription invariant failed");@@ -355,25 +355,35 @@ describe("environment RPC", () => {let inputs = 0;let streams = 0;const observedDefects: unknown[] = [];- const client = {+ const defectObserved = yield* Deferred.make<void>();+ const resubscribed = yield* Deferred.make<void>();+ const firstClient = {[WS_METHODS.subscribeTerminalMetadata]: () => {streams += 1;return where === "stream" ? Stream.die(defect) : Stream.never;},} as unknown as WsRpcProtocolClient;+ const secondClient = {+ [WS_METHODS.subscribeTerminalMetadata]: () => {+ Deferred.doneUnsafe(resubscribed, Effect.void);+ return Stream.never;+ },+ } as unknown as WsRpcProtocolClient;const { activeSession, supervisor } = yield* makeHarness();- yield* SubscriptionRef.set(activeSession, Option.some(session(client)));- const exit = yield* subscribeDynamicWithSession(+ yield* SubscriptionRef.set(activeSession, Option.some(session(firstClient)));+ const subscriptionFiber = yield* subscribeDynamicWithSession(WS_METHODS.subscribeTerminalMetadata,() =>- Effect.sync(() => {+ Effect.suspend(() => {inputs += 1;- }).pipe(Effect.andThen(where === "input" ? Effect.die(defect) : Effect.succeed({}))),+ return where === "input" && inputs === 1 ? Effect.die(defect) : Effect.succeed({});+ }),{onDefect: (cause) =>Effect.sync(() => {observedDefects.push(Cause.squash(cause));+ Deferred.doneUnsafe(defectObserved, Effect.void);}),onExpectedFailure: () =>Effect.sync(() => {@@ -384,18 +394,23 @@ describe("environment RPC", () => {).pipe(Stream.runDrain,Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),- Effect.exit,+ Effect.forkChild,);+ yield* Deferred.await(defectObserved);- expect(Exit.isFailure(exit)).toBe(true);- if (Exit.isFailure(exit)) {- expect(Cause.hasDies(exit.cause)).toBe(true);- expect(Cause.squash(exit.cause)).toBe(defect);- }expect(inputs).toBe(1);expect(streams).toBe(where === "input" ? 0 : 1);expect(expectedFailureCount).toBe(0);expect(observedDefects).toEqual([defect]);++ // Let the defect settle before the next session arrives, as it does on a real device.+ yield* TestClock.adjust("1 second");+ expect(subscriptionFiber.pollUnsafe()).toBeUndefined();+ yield* SubscriptionRef.set(activeSession, Option.some(session(secondClient)));+ yield* Deferred.await(resubscribed);+ yield* Fiber.interrupt(subscriptionFiber);++ expect(inputs).toBe(2);}),);});diff --git a/packages/client-runtime/src/rpc/client.ts b/packages/client-runtime/src/rpc/client.tsindex 2832a4e2315..e74abde6a2c 100644--- a/packages/client-runtime/src/rpc/client.ts+++ b/packages/client-runtime/src/rpc/client.ts@@ -236,6 +236,7 @@ export function runStreamGuarded<TTag extends EnvironmentStreamCommandRpcTag>(}interface SubscriptionOptions<TTag extends EnvironmentSubscriptionRpcTag> {+ /** Reports defects; the subscription then waits for the next session or resubscribe. */readonly onDefect?: (cause: Cause.Cause<EnvironmentRpcStreamFailure<TTag>>,) => Effect.Effect<void, never, never>;@@ -371,6 +372,11 @@ function subscribeDynamicMapped<TTag extends EnvironmentSubscriptionRpcTag, A>(Stream.concat(subscribeToSession()),);}+ // A reported defect parks until the next session or resubscribe. Failing would+ // end the whole subscription, so a mounted screen never syncs again.+ if (options?.onDefect !== undefined && Cause.hasDies(cause)) {+ return Stream.empty;+ }return Stream.failCause(cause);}),),