Skip to content

Commit 9114a74

Browse files
committed
fix(client): recover config state after session failure
1 parent a68af45 commit 9114a74

2 files changed

Lines changed: 180 additions & 2 deletions

File tree

‎packages/client-runtime/src/rpc/session.test.ts‎

Lines changed: 163 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,15 +20,21 @@ import * as Option from "effect/Option";
2020
import * as Queue from "effect/Queue";
2121
import * as Schema from "effect/Schema";
2222
import * as Stream from "effect/Stream";
23+
import * as SubscriptionRef from "effect/SubscriptionRef";
2324
import * as TestClock from "effect/testing/TestClock";
2425
import * as Socket from "effect/unstable/socket/Socket";
2526

2627
import {
28+
AVAILABLE_CONNECTION_STATE,
29+
ConnectionBlockedError,
2730
ConnectionTransientError,
2831
PrimaryConnectionTarget,
2932
type PreparedConnection,
3033
} from "../connection/model.ts";
34+
import * as EnvironmentSupervisor from "../connection/supervisor.ts";
35+
import * as Persistence from "../platform/persistence.ts";
3136
import * as RpcSession from "./session.ts";
37+
import { makeEnvironmentServerConfigState } from "../state/server.ts";
3238
import { applyServerConfigProjection } from "../state/serverConfigProjection.ts";
3339

3440
type SocketEventType = "open" | "message" | "close" | "error";
@@ -194,9 +200,10 @@ const makeFactory = Effect.fn("TestRpcSessionFactory.make")(function* (
194200

195201
const awaitSocket = Effect.fn("TestRpcSessionFactory.awaitSocket")(function* (
196202
sockets: ReadonlyArray<TestWebSocket>,
203+
index = 0,
197204
) {
198205
for (let attempt = 0; attempt < 100; attempt += 1) {
199-
const socket = sockets[0];
206+
const socket = sockets[index];
200207
if (socket) {
201208
return socket;
202209
}
@@ -671,6 +678,161 @@ describe("RpcSessionFactory", () => {
671678
),
672679
);
673680

681+
it.effect.each([{ failure: "defect" as const }, { failure: "typed" as const }])(
682+
"keeps durable config state alive after an owned $failure failure",
683+
({ failure }) =>
684+
Effect.scoped(
685+
Effect.gen(function* () {
686+
const { factory, sockets } = yield* makeFactory({ environmentThemes: true });
687+
const firstSession = yield* factory.connect(PREPARED);
688+
const firstReady = yield* Effect.forkChild(firstSession.ready);
689+
const firstSocket = yield* awaitSocket(sockets);
690+
firstSocket.open();
691+
yield* completeInitialConfig(firstSocket, ENCODED_THEME_SERVER_CONFIG, {
692+
environmentThemes: true,
693+
});
694+
yield* Fiber.join(firstReady);
695+
696+
const activeSession = yield* SubscriptionRef.make(Option.some(firstSession));
697+
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
698+
target: TARGET,
699+
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
700+
session: activeSession,
701+
prepared: yield* SubscriptionRef.make(Option.some(PREPARED)),
702+
connect: Effect.void,
703+
disconnect: Effect.void,
704+
retryNow: Effect.void,
705+
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
706+
const cache = Persistence.EnvironmentCacheStore.of({
707+
loadShell: () => Effect.succeed(Option.none()),
708+
saveShell: () => Effect.void,
709+
loadThread: () => Effect.succeed(Option.none()),
710+
saveThread: () => Effect.void,
711+
removeThread: () => Effect.void,
712+
loadServerConfig: () => Effect.succeed(Option.none()),
713+
saveServerConfig: () => Effect.void,
714+
loadVcsRefs: () => Effect.succeed(Option.none()),
715+
saveVcsRefs: () => Effect.void,
716+
removeVcsRefs: () => Effect.void,
717+
clearVcsRefs: () => Effect.void,
718+
clear: () => Effect.void,
719+
});
720+
const configState = yield* makeEnvironmentServerConfigState(true).pipe(
721+
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
722+
Effect.provideService(Persistence.EnvironmentCacheStore, cache),
723+
);
724+
const awaitConfig = (predicate: (config: ServerConfigType) => boolean) =>
725+
SubscriptionRef.changes(configState).pipe(
726+
Stream.filter(Option.isSome),
727+
Stream.map((projection) => projection.value.config),
728+
Stream.filter(predicate),
729+
Stream.runHead,
730+
Effect.map(Option.getOrThrow),
731+
);
732+
733+
const firstThemes = [
734+
{
735+
id: "first-theme",
736+
name: "First theme",
737+
appearance: "dark" as const,
738+
canvas: "#111111",
739+
accent: "#ffffff",
740+
},
741+
];
742+
const firstThemeState = yield* awaitConfig(
743+
(config) => config.environmentThemes?.[0]?.id === "first-theme",
744+
).pipe(Effect.forkChild);
745+
yield* publishConfigEvents(firstSocket, [
746+
{
747+
version: 1,
748+
type: "environmentThemesUpdated",
749+
payload: { themes: firstThemes },
750+
},
751+
]);
752+
expect((yield* Fiber.join(firstThemeState)).environmentThemes).toEqual(firstThemes);
753+
754+
const firstClosed = yield* firstSession.closed.pipe(Effect.exit, Effect.forkChild);
755+
const firstRequest = yield* awaitRequest(firstSocket);
756+
firstSocket.serverMessage(
757+
failure === "defect"
758+
? encodeJson({
759+
_tag: "Defect",
760+
defect: encodeDefect(new Error("config stream died")),
761+
})
762+
: encodeJson({
763+
_tag: "Exit",
764+
requestId: firstRequest.id,
765+
exit: {
766+
_tag: "Failure",
767+
cause: [
768+
{
769+
_tag: "Fail",
770+
error: {
771+
_tag: "EnvironmentAuthorizationError",
772+
message: "config subscription rejected",
773+
requiredScope: "orchestration:read",
774+
},
775+
},
776+
],
777+
},
778+
}),
779+
);
780+
const firstClosedExit = yield* Fiber.join(firstClosed);
781+
expect(Exit.isFailure(firstClosedExit)).toBe(true);
782+
if (failure === "typed" && Exit.isFailure(firstClosedExit)) {
783+
expect(Cause.squash(firstClosedExit.cause)).toBeInstanceOf(ConnectionBlockedError);
784+
expect(Cause.squash(firstClosedExit.cause)).toMatchObject({ reason: "permission" });
785+
}
786+
yield* SubscriptionRef.set(activeSession, Option.none());
787+
788+
const recoveredConfig = {
789+
...THEME_SERVER_CONFIG,
790+
environment: {
791+
...THEME_SERVER_CONFIG.environment,
792+
label: "Recovered environment",
793+
},
794+
} satisfies ServerConfigType;
795+
const secondSession = yield* factory.connect(PREPARED);
796+
const secondReady = yield* Effect.forkChild(secondSession.ready);
797+
const secondSocket = yield* awaitSocket(sockets, 1);
798+
secondSocket.open();
799+
yield* completeInitialConfig(secondSocket, encodeServerConfig(recoveredConfig), {
800+
environmentThemes: true,
801+
});
802+
yield* Fiber.join(secondReady);
803+
804+
const recoveredState = yield* awaitConfig(
805+
(config) => config.environment.label === "Recovered environment",
806+
).pipe(Effect.forkChild);
807+
yield* SubscriptionRef.set(activeSession, Option.some(secondSession));
808+
expect((yield* Fiber.join(recoveredState)).environmentThemes).toEqual(firstThemes);
809+
810+
const recoveredThemes = [
811+
{
812+
id: "recovered-theme",
813+
name: "Recovered theme",
814+
appearance: "dark" as const,
815+
canvas: "#000000",
816+
accent: "#eeeeee",
817+
},
818+
];
819+
const liveRecoveredState = yield* awaitConfig(
820+
(config) => config.environmentThemes?.[0]?.id === "recovered-theme",
821+
).pipe(Effect.forkChild);
822+
yield* publishConfigEvents(secondSocket, [
823+
{
824+
version: 1,
825+
type: "environmentThemesUpdated",
826+
payload: { themes: recoveredThemes },
827+
},
828+
]);
829+
expect((yield* Fiber.join(liveRecoveredState)).environmentThemes).toEqual(
830+
recoveredThemes,
831+
);
832+
}),
833+
),
834+
);
835+
674836
it.effect.each<{
675837
readonly event: ServerConfigStreamEventType;
676838
readonly expectedConfig: Partial<ServerConfigType>;

‎packages/client-runtime/src/rpc/session.ts‎

Lines changed: 17 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ import type * as Scope from "effect/Scope";
1919
import * as Stream from "effect/Stream";
2020
import type * as Rpc from "effect/unstable/rpc/Rpc";
2121
import * as RpcClient from "effect/unstable/rpc/RpcClient";
22-
import type * as RpcClientError from "effect/unstable/rpc/RpcClientError";
22+
import * as RpcClientError from "effect/unstable/rpc/RpcClientError";
2323
import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
2424
import * as Socket from "effect/unstable/socket/Socket";
2525

@@ -285,6 +285,22 @@ export const make = Effect.fn("RpcSessionFactory.make")(function* (
285285
Stream.merge(updates, terminal, { haltStrategy: "either" }),
286286
);
287287
}),
288+
).pipe(
289+
Stream.catchCause((cause) => {
290+
if (Cause.hasInterruptsOnly(cause)) {
291+
return Stream.failCause(cause);
292+
}
293+
// The supervisor keeps the original cause. Shared durable consumers
294+
// need a transport-shaped failure so they wait for its replacement.
295+
return Stream.fail(
296+
new RpcClientError.RpcClientError({
297+
reason: new RpcClientError.RpcClientDefect({
298+
message: `${connection.label} config subscription failed.`,
299+
cause,
300+
}),
301+
}),
302+
);
303+
}),
288304
);
289305
const subscribeServerConfig = (input: ServerConfigSubscriptionInput) =>
290306
Equal.equals(input, serverConfigInput)

0 commit comments

Comments
 (0)