@remit/web-client 0.0.269 → 0.0.271

package/src/lib/self-update-state.ts

@@ -72,6 +72,21 @@ export interface CheckPress {
 	since: string | undefined;
 }
 
+/**
+ * When this tab first saw the run the server reported as going, by its own
+ * clock. A run's `startedAt` is written on the box, and a box whose clock is
+ * twenty minutes behind the browser's would put that start far enough in the
+ * past to spend the whole apply budget before the first failed request — the
+ * screen would open on "the server never came back". `CheckPress` keeps its wait
+ * the client's own for the same reason. The runId travels with it so a second
+ * run never inherits the first one's wait.
+ */
+export interface RunSighting {
+	runId: string;
+	/** Epoch millis, this tab's clock, of the first answer that reported it going. */
+	observedAt: number;
+}
+
 export function checkAnswered(
 	press: CheckPress,
 	data: RemitImapSystemUpdateResponse | undefined,
@@ -126,6 +141,8 @@ export interface DeriveInput {
 	checkPress: CheckPress | null;
 	/** Why the request that press fired failed, or null when it did not. */
 	checkFailure: string | null;
+	/** When this tab first saw the server's run going, for a wait it can trust. */
+	sighting: RunSighting | null;
 	now: number;
 }
 
@@ -163,6 +180,22 @@ export function isSurfaceAbsent(error: unknown): boolean {
 	return status === 404 || status === 403 || status === 401;
 }
 
+/**
+ * The run the server last reported as still going, or null when it reported
+ * none. The last answer outlives the failed requests that follow it, which is
+ * what lets any tab — not only the one that pressed install — know it is inside
+ * a restart rather than looking at an unreachable service (#468). A run the user
+ * has dismissed is not one either surface still speaks for.
+ */
+export function runInFlight(
+	data: RemitImapSystemUpdateResponse | undefined,
+	dismissedRunId: string | null,
+): RemitImapSystemUpdateRun | null {
+	const run = data?.run ?? null;
+	if (run === null || run.outcome !== null) return null;
+	return run.runId === dismissedRunId ? null : run;
+}
+
 /**
  * The available release from the check block, or undefined when the check
  * reports none. Independent of what the pane is currently showing, so a retry
@@ -343,29 +376,75 @@ function ready(
 	return { surface: { status: "ready", section, overlay }, releaseHeld };
 }
 
+/**
+ * The wait every tab is in while the server it is polling is not answering: the
+ * run is known to be in flight, and the phase is the only one the client can
+ * claim from a dead connection.
+ */
+function reconnectingSurface(
+	runId: string,
+	previousVersion: string,
+	attemptedVersion: string,
+	elapsedSeconds: number,
+): UpdateSurface {
+	return {
+		status: "ready",
+		section: applyingSection(
+			runId,
+			previousVersion,
+			attemptedVersion,
+			"reconnecting",
+			elapsedSeconds,
+		),
+		overlay: {
+			kind: "applying",
+			target: attemptedVersion,
+			phase: "reconnecting",
+			elapsedSeconds,
+		},
+	};
+}
+
+/** The client gave up waiting, and says so without claiming the rollback ran. */
+function neverCameBackSurface(
+	runId: string,
+	previousVersion: string,
+	attemptedVersion: string,
+	elapsedSeconds: number,
+	logsCommand: string,
+): UpdateSurface {
+	return {
+		status: "ready",
+		section: applyingSection(
+			runId,
+			previousVersion,
+			attemptedVersion,
+			"reconnecting",
+			elapsedSeconds,
+		),
+		overlay: {
+			kind: "neverCameBack",
+			attemptedVersion,
+			previousVersion,
+			elapsedSeconds,
+			logsCommand,
+		},
+	};
+}
+
 /**
  * The client gave up waiting. The hold stays: the screen has to sit still, and
  * its retry has to keep polling, until the server answers for itself.
  */
 function neverCameBack(held: HeldRun, elapsedSeconds: number): DeriveResult {
 	return {
-		surface: {
-			status: "ready",
-			section: applyingSection(
-				held.runId,
-				held.previousVersion,
-				held.attemptedVersion,
-				"reconnecting",
-				elapsedSeconds,
-			),
-			overlay: {
-				kind: "neverCameBack",
-				attemptedVersion: held.attemptedVersion,
-				previousVersion: held.previousVersion,
-				elapsedSeconds,
-				logsCommand: FALLBACK_LOGS_COMMAND,
-			},
-		},
+		surface: neverCameBackSurface(
+			held.runId,
+			held.previousVersion,
+			held.attemptedVersion,
+			elapsedSeconds,
+			FALLBACK_LOGS_COMMAND,
+		),
 		releaseHeld: false,
 	};
 }
@@ -408,22 +487,15 @@ function deriveHeld(
 		if (elapsedSeconds > budgetLimitSeconds()) {
 			return neverCameBack(held, elapsedSeconds);
 		}
-		return ready(
-			applyingSection(
+		return {
+			surface: reconnectingSurface(
 				held.runId,
 				held.previousVersion,
 				held.attemptedVersion,
-				"reconnecting",
 				elapsedSeconds,
 			),
-			{
-				kind: "applying",
-				target: held.attemptedVersion,
-				phase: "reconnecting",
-				elapsedSeconds,
-			},
-			false,
-		);
+			releaseHeld: false,
+		};
 	}
 
 	// Nothing has come back yet. Silence is not a phase, so the surface waits
@@ -474,10 +546,46 @@ function deriveHeld(
 }
 
 function displayFromData(input: DeriveInput): UpdateSurface {
-	const { data, isError, dismissedRunId, checkPress, checkFailure, now } =
-		input;
+	const {
+		data,
+		isError,
+		dismissedRunId,
+		checkPress,
+		checkFailure,
+		sighting,
+		now,
+	} = input;
 
 	if (isError) {
+		const stopped = runInFlight(data, dismissedRunId);
+		// A tab that never pressed install is in the same restart as the one that
+		// did: the run the server last reported is still going, and the server
+		// stopping is how it goes. The wait runs from when this tab saw the run,
+		// never from the `startedAt` the box wrote — same budget, on a clock the
+		// tab owns. A run in flight this tab has no sighting of has only just
+		// arrived, so the wait starts here.
+		if (stopped !== null) {
+			const observedAt =
+				sighting !== null && sighting.runId === stopped.runId
+					? sighting.observedAt
+					: now;
+			const elapsedSeconds = elapsedSince(observedAt, now);
+			if (elapsedSeconds > budgetLimitSeconds()) {
+				return neverCameBackSurface(
+					stopped.runId,
+					stopped.fromVersion,
+					stopped.targetVersion,
+					elapsedSeconds,
+					stopped.logCommand,
+				);
+			}
+			return reconnectingSurface(
+				stopped.runId,
+				stopped.fromVersion,
+				stopped.targetVersion,
+				elapsedSeconds,
+			);
+		}
 		return {
 			status: "ready",
 			section: {