Skip to content

Commit 77f057c

Browse files
shivamhwpclaude
andcommitted
fix(connection): re-arm the post-wake retry when a fallback route has not opened
The 3 second post-wake retry stopped for good once any route opened. If that route then failed its snapshot and the fallback route stalled before opening, the attempt waited out the full setup and snapshot budgets. The attempt now tracks whether a route is open in one SubscriptionRef. An open socket pauses the 3 second clock, and a route that fails after opening gives the next route a fresh 3 seconds. It still retries at most once per wake. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent 0b89cb1 commit 77f057c

2 files changed

Lines changed: 91 additions & 31 deletions

File tree

‎packages/client-runtime/src/connection/supervisor.test.ts‎

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1867,6 +1867,72 @@ describe("EnvironmentSupervisor routes", () => {
18671867
}).pipe(Effect.provide(TestClock.layer())),
18681868
);
18691869

1870+
// After a wake, the LAN route opens and fails its snapshot 2 seconds later.
1871+
it.effect.each(["reachability check", "preparation", "opening"] as const)(
1872+
"retries once, 3 seconds on, a post-wake fallback route that stalls in %s",
1873+
(stall) =>
1874+
Effect.gen(function* () {
1875+
const woke = yield* Ref.make(false);
1876+
const stallCancelled = yield* Deferred.make<void>();
1877+
const stallHere = Effect.never.pipe(
1878+
Effect.onInterrupt(() => Deferred.succeed(stallCancelled, undefined)),
1879+
);
1880+
const harness = yield* makeHarness({
1881+
checkRoute: (route) =>
1882+
Effect.gen(function* () {
1883+
if (
1884+
stall === "reachability check" &&
1885+
route.target._tag === "RelayConnectionTarget" &&
1886+
(yield* Ref.get(woke))
1887+
) {
1888+
return yield* stallHere;
1889+
}
1890+
return "answered" as const;
1891+
}),
1892+
prepare: (_attempt, target) =>
1893+
Effect.gen(function* () {
1894+
if (
1895+
stall === "preparation" &&
1896+
target._tag === "RelayConnectionTarget" &&
1897+
(yield* Ref.get(woke))
1898+
) {
1899+
return yield* stallHere;
1900+
}
1901+
return preparedFor(target);
1902+
}),
1903+
opened: (attempt) => (stall === "opening" && attempt === 3 ? stallHere : Effect.void),
1904+
ready: (attempt) =>
1905+
attempt === 2
1906+
? Effect.sleep("2 seconds").pipe(Effect.andThen(Effect.fail(transient())))
1907+
: Effect.void,
1908+
probe: (attempt) => (attempt === 1 ? Effect.never : Effect.void),
1909+
});
1910+
const supervisor = yield* EnvironmentSupervisor.make(LAN_THEN_RELAY_ENTRY, {
1911+
initiallyDesired: true,
1912+
}).pipe(Effect.provide(harness.dependencies));
1913+
yield* awaitState(supervisor.state, (state) => state.phase === "connected");
1914+
1915+
yield* Ref.set(woke, true);
1916+
yield* harness.wake("application-active-long");
1917+
yield* TestClock.adjust("3 seconds");
1918+
expect(yield* Ref.get(harness.sessionCount)).toBe(2);
1919+
yield* TestClock.adjust("2 seconds");
1920+
const stalledAt = yield* Ref.get(harness.prepareCount);
1921+
yield* TestClock.adjust("2999 millis");
1922+
expect(yield* Deferred.isDone(stallCancelled)).toBe(false);
1923+
expect(yield* Ref.get(harness.prepareCount)).toBe(stalledAt);
1924+
1925+
yield* TestClock.adjust("1 millis");
1926+
expect(yield* Deferred.isDone(stallCancelled)).toBe(true);
1927+
expect(yield* Ref.get(harness.prepareCount)).toBe(stalledAt + 1);
1928+
const connected = yield* awaitState(
1929+
supervisor.state,
1930+
(state) => state.phase === "connected",
1931+
);
1932+
expect(connected.lastFailure).toBeNull();
1933+
}).pipe(Effect.provide(TestClock.layer())),
1934+
);
1935+
18701936
it.effect("tries every route when none answers the reachability check", () =>
18711937
Effect.gen(function* () {
18721938
const harness = yield* makeHarness({

‎packages/client-runtime/src/connection/supervisor.ts‎

Lines changed: 25 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@ import { withRelayClientTracing } from "@t3tools/shared/relayTracing";
22
import * as Cause from "effect/Cause";
33
import * as Clock from "effect/Clock";
44
import * as Context from "effect/Context";
5-
import * as Deferred from "effect/Deferred";
65
import * as Duration from "effect/Duration";
76
import * as Effect from "effect/Effect";
87
import * as Exit from "effect/Exit";
@@ -466,17 +465,13 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
466465
generation: number,
467466
lastFailure: ConnectionAttemptError | null,
468467
synchronizedRoutes: Ref.Ref<number>,
469-
transportOpened: Deferred.Deferred<void>,
470-
routeOpen: Ref.Ref<boolean>,
468+
routeOpen: SubscriptionRef.SubscriptionRef<boolean>,
471469
) {
472470
return yield* driver.connect(yield* attemptEntry, (progress) => {
473471
if ("transportOpened" in progress) {
474-
return Ref.set(routeOpen, true).pipe(
475-
Effect.andThen(Deferred.succeed(transportOpened, undefined)),
476-
Effect.asVoid,
477-
);
472+
return SubscriptionRef.set(routeOpen, true);
478473
}
479-
return Ref.set(routeOpen, false).pipe(
474+
return SubscriptionRef.set(routeOpen, false).pipe(
480475
Effect.andThen(
481476
progress.stage === "synchronizing"
482477
? Ref.update(synchronizedRoutes, (count) => count + 1)
@@ -565,19 +560,11 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
565560
lastFailure: ConnectionAttemptError | null,
566561
pendingRetry: Option.Option<PendingRetryTrace>,
567562
synchronizedRoutes: Ref.Ref<number>,
568-
transportOpened: Deferred.Deferred<void>,
569-
routeOpen: Ref.Ref<boolean>,
563+
routeOpen: SubscriptionRef.SubscriptionRef<boolean>,
570564
) {
571565
if (usesRelay) {
572566
return yield* traceRelayEstablishment(
573-
establishConnection(
574-
attempt,
575-
generation,
576-
lastFailure,
577-
synchronizedRoutes,
578-
transportOpened,
579-
routeOpen,
580-
),
567+
establishConnection(attempt, generation, lastFailure, synchronizedRoutes, routeOpen),
581568
attempt,
582569
generation,
583570
pendingRetry,
@@ -588,7 +575,6 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
588575
generation,
589576
lastFailure,
590577
synchronizedRoutes,
591-
transportOpened,
592578
routeOpen,
593579
).pipe(
594580
Effect.map((lease) => ({
@@ -602,7 +588,9 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
602588
);
603589
});
604590

605-
const waitForEstablishmentInterrupt = Effect.fnUntraced(function* (routeOpen: Ref.Ref<boolean>) {
591+
const waitForEstablishmentInterrupt = Effect.fnUntraced(function* (
592+
routeOpen: SubscriptionRef.SubscriptionRef<boolean>,
593+
) {
606594
for (;;) {
607595
const next = yield* Queue.take(signals);
608596
switch (next._tag) {
@@ -615,7 +603,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
615603
}
616604
// An attempt started before the network came back can hang until
617605
// its setup timeout, so a recovery restarts it unless its socket is open.
618-
if (next.network === "online" && !(yield* Ref.get(routeOpen))) {
606+
if (next.network === "online" && !(yield* SubscriptionRef.get(routeOpen))) {
619607
return true;
620608
}
621609
break;
@@ -885,14 +873,22 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
885873
}
886874
});
887875

876+
// An open socket pauses the clock; a route that fails after opening gives
877+
// the next route its own time to open.
888878
const awaitWakeRecoveryStall = Effect.fnUntraced(function* (
889-
transportOpened: Deferred.Deferred<void>,
879+
routeOpen: SubscriptionRef.SubscriptionRef<boolean>,
890880
) {
891-
const opened = yield* Deferred.await(transportOpened).pipe(
892-
Effect.timeoutOption(WAKE_RECOVERY_OPEN_TIMEOUT),
893-
);
894-
if (Option.isSome(opened)) {
895-
return yield* Effect.never;
881+
const awaitRouteOpen = (open: boolean) =>
882+
SubscriptionRef.changes(routeOpen).pipe(
883+
Stream.filter((value) => value === open),
884+
Stream.runHead,
885+
);
886+
while (
887+
Option.isSome(
888+
yield* awaitRouteOpen(true).pipe(Effect.timeoutOption(WAKE_RECOVERY_OPEN_TIMEOUT)),
889+
)
890+
) {
891+
yield* awaitRouteOpen(false);
896892
}
897893
yield* Effect.logInfo("Connection after a wake did not open; retrying it once.").pipe(
898894
Effect.annotateLogs({
@@ -913,8 +909,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
913909
const switchingTo = yield* Ref.get(preferredRouteId);
914910
yield* SubscriptionRef.set(prepared, Option.none());
915911
const synchronizedRoutes = yield* Ref.make(0);
916-
const transportOpened = yield* Deferred.make<void>();
917-
const routeOpen = yield* Ref.make(false);
912+
const routeOpen = yield* SubscriptionRef.make(false);
918913
const wakeRecovery = yield* Ref.getAndSet(wakeRecoveryPending, false);
919914
const establishment = yield* Effect.raceAllFirst([
920915
exitUnlessInterrupted(
@@ -924,7 +919,6 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
924919
lastFailure,
925920
pendingRetry,
926921
synchronizedRoutes,
927-
transportOpened,
928922
routeOpen,
929923
),
930924
).pipe(
@@ -957,7 +951,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* (
957951
yield* Effect.sleep(Duration.nanos(remaining));
958952
}
959953
}),
960-
...(wakeRecovery ? [awaitWakeRecoveryStall(transportOpened)] : []),
954+
...(wakeRecovery ? [awaitWakeRecoveryStall(routeOpen)] : []),
961955
]);
962956

963957
if (establishment._tag === "Interrupted") {

0 commit comments

Comments
 (0)