Skip to content
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.ts
index 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.ts
index 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);
}),
),