diff --git a/packages/client-runtime/src/connection/supervisor.test.ts b/packages/client-runtime/src/connection/supervisor.test.ts index be1ff1e47334a..f5d0a3a369910 100644 --- a/packages/client-runtime/src/connection/supervisor.test.ts +++ b/packages/client-runtime/src/connection/supervisor.test.ts @@ -361,6 +361,66 @@ describe("EnvironmentSupervisor", () => { }), ); + it.effect("explicit retry connects while the network still reports offline", () => + Effect.gen(function* () { + const harness = yield* makeHarness({ + networkStatus: "offline", + prepare: () => Effect.sleep("1 second").pipe(Effect.as(PREPARED_CONNECTION)), + }); + const supervisor = yield* EnvironmentSupervisor.make(RELAY_ENTRY, { + initiallyDesired: true, + }).pipe(Effect.provide(harness.dependencies)); + + yield* awaitState(supervisor.state, (state) => state.phase === "offline"); + // The loop wakes on the earlier signal and takes the retry's flag while + // RetryRequested is still queued, so that signal must not cancel the attempt. + yield* supervisor.connect; + yield* supervisor.retryNow; + yield* TestClock.adjust("1 second"); + const settled = yield* awaitState( + supervisor.state, + (state) => state.phase === "connected" || state.phase === "offline", + ); + + expect(settled.phase).toBe("connected"); + expect(yield* Ref.get(harness.prepareCount)).toBe(1); + expect(yield* Ref.get(harness.releaseCount)).toBe(0); + }), + ); + + it.effect.each([ + { label: "cancels connection setup", retry: false, phase: "offline", sessions: 0 }, + { label: "does not cancel an explicit retry", retry: true, phase: "connected", sessions: 1 }, + ])("an offline report during setup $label", ({ retry, phase, sessions }) => + Effect.gen(function* () { + const firstAttemptStarted = yield* Deferred.make(); + const harness = yield* makeHarness({ + prepare: () => + Deferred.succeed(firstAttemptStarted, undefined).pipe( + Effect.andThen(Effect.sleep("1 second")), + Effect.as(PREPARED_CONNECTION), + ), + }); + const supervisor = yield* EnvironmentSupervisor.make(RELAY_ENTRY, { + initiallyDesired: true, + }).pipe(Effect.provide(harness.dependencies)); + + yield* Deferred.await(firstAttemptStarted); + if (retry) { + yield* supervisor.retryNow; + } + yield* harness.setNetworkStatus("offline"); + yield* TestClock.adjust("1 second"); + const settled = yield* awaitState( + supervisor.state, + (state) => state.phase === "connected" || state.phase === "offline", + ); + + expect(settled.phase).toBe(phase); + expect(yield* Ref.get(harness.sessionCount)).toBe(sessions); + }), + ); + it.effect("connects to the primary environment while the device reports offline", () => Effect.gen(function* () { const harness = yield* makeHarness({ networkStatus: "offline" }); diff --git a/packages/client-runtime/src/connection/supervisor.ts b/packages/client-runtime/src/connection/supervisor.ts index 6ca1985d08dbe..b01f73880ab7d 100644 --- a/packages/client-runtime/src/connection/supervisor.ts +++ b/packages/client-runtime/src/connection/supervisor.ts @@ -583,7 +583,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( ); }); - const waitForEstablishmentInterrupt = Effect.fnUntraced(function* () { + const waitForEstablishmentInterrupt = Effect.fnUntraced(function* (ignoreOffline: boolean) { // A primary attempt keeps running through an offline report, so the // network returning restarts it in case it stalled meanwhile. let deviceOffline = (yield* connectivity.status) === "offline"; @@ -591,11 +591,17 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( const next = yield* Queue.take(signals); switch (next._tag) { case "DisconnectRequested": - case "RetryRequested": return false; + case "RetryRequested": + // Once the loop has taken this retry's flag, the running attempt is + // the one the retry asked for. + if (yield* Ref.get(resetRetryState)) { + return false; + } + break; case "NetworkChanged": if (target._tag !== "PrimaryConnectionTarget") { - if (next.network === "offline") { + if (next.network === "offline" && !ignoreOffline) { return false; } } else if (next.network === "offline") { @@ -920,7 +926,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( exit, })), ), - waitForEstablishmentInterrupt().pipe( + waitForEstablishmentInterrupt(ignoreOffline).pipe( Effect.map((resetRetry): EstablishmentEvent => ({ _tag: "Interrupted", resetRetry, @@ -1137,7 +1143,8 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( let replacing = false; for (;;) { - if (yield* Ref.getAndSet(resetRetryState, false)) { + const retryRequested = yield* Ref.getAndSet(resetRetryState, false); + if (retryRequested) { failureCount = 0; backoffFailures = 0; approvalWaits = 0; @@ -1153,7 +1160,10 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( yield* waitForSignal; continue; } - if (currentIntent.network === "offline" && !replacing) { + // The platform's offline report can stay wrong after the network is back, + // so an explicit retry still tries instead of waiting for it to change. + const ignoreOffline = replacing || retryRequested; + if (currentIntent.network === "offline" && !ignoreOffline) { yield* clearLease; yield* setState(offlineState(currentIntent, generation, failureCount + 1, latestFailure)); const applicationActivated = yield* waitForSignal; @@ -1166,7 +1176,7 @@ export const make = Effect.fn("EnvironmentSupervisor.make")(function* ( const attempt = failureCount + 1; const nextGeneration = generation + 1; const outcome: AttemptOutcome = yield* Effect.scoped( - runAttempt(attempt, nextGeneration, latestFailure, pendingRetry, replacing), + runAttempt(attempt, nextGeneration, latestFailure, pendingRetry, ignoreOffline), ); replacing = false; const failedProbe = yield* Ref.getAndSet(probeUnanswered, false);