WIP Assignments

Author: skyrpex

src/utils/localstack-status.ts

@@ -7,6 +7,94 @@ import type {
 import { createEmitter } from "./emitter.ts";
 import type { TimeTracker } from "./time-tracker.ts";
 
+type HealthStatus = "healthy" | "not_healthy";
+
+const FAST_HEALTH_CHECK_INTERVAL = 1_000;
+const SLOW_HEALTH_CHECK_INTERVAL = 3_000;
+
+interface HealthTracker extends Disposable {
+	status(): HealthStatus | undefined;
+	start(interval: "fast" | "slow"): Promise<void>;
+	stop(): void;
+	onChange(callback: (status: HealthStatus) => void): void;
+}
+
+const createHealthTracker = (
+	outputChannel: LogOutputChannel,
+): HealthTracker => {
+	const emitter = createEmitter<HealthStatus>(outputChannel);
+
+	let interval: "fast" | "slow" = "fast";
+	let status: HealthStatus | undefined;
+	let timeout: NodeJS.Timeout | undefined;
+
+	const startHealthCheck = async () => {
+		if (timeout) {
+			return;
+		}
+
+		outputChannel.debug(`[health]: Checking health...`);
+		const newStatus = await fetchHealth();
+		outputChannel.debug(`[health]: Health = ${status}`);
+		if (status !== newStatus) {
+			status = newStatus;
+			outputChannel.debug(`[health]: EMITTING Health = ${status}`);
+			void emitter.emit(status);
+		}
+
+		outputChannel.debug(
+			`[health]: Next check in ${
+				interval === "fast"
+					? FAST_HEALTH_CHECK_INTERVAL
+					: SLOW_HEALTH_CHECK_INTERVAL
+			} interval.`,
+		);
+
+		timeout = setTimeout(
+			() => {
+				timeout = undefined;
+				void startHealthCheck();
+			},
+			interval === "fast"
+				? FAST_HEALTH_CHECK_INTERVAL
+				: SLOW_HEALTH_CHECK_INTERVAL,
+		);
+	};
+
+	const stop = () => {
+		if (timeout === undefined) {
+			return;
+		}
+
+		outputChannel.debug(`[health]: Stopping health checks.`);
+		clearTimeout(timeout);
+		timeout = undefined;
+	};
+
+	return {
+		status() {
+			return status;
+		},
+		async start(newInterval: "fast" | "slow") {
+			outputChannel.debug(
+				`[health]: Starting health checks at interval "${newInterval}"... `,
+			);
+			interval = newInterval;
+			await startHealthCheck();
+		},
+		stop,
+		onChange(callback) {
+			emitter.on(callback);
+			if (status !== undefined) {
+				callback(status);
+			}
+		},
+		dispose() {
+			clearTimeout(timeout);
+		},
+	};
+};
+
 export type LocalStackStatus = "starting" | "running" | "stopping" | "stopped";
 
 export interface LocalStackStatusTracker extends Disposable {
@@ -27,7 +115,7 @@ export async function createLocalStackStatusTracker(
 	let status: LocalStackStatus | undefined;
 	const emitter = createEmitter<LocalStackStatus>(outputChannel);
 
-	let healthCheck: boolean | undefined;
+	const healthTracker = createHealthTracker(outputChannel);
 
 	const setStatus = (newStatus: LocalStackStatus) => {
 		if (status !== newStatus) {
@@ -37,7 +125,13 @@ export async function createLocalStackStatusTracker(
 	};
 
 	const deriveStatus = () => {
-		const newStatus = getLocalStackStatus(containerStatus, healthCheck);
+		outputChannel.debug(
+			`Container Status = ${containerStatus}, Health Status = ${healthTracker.status()}`,
+		);
+		const newStatus = getLocalStackStatus(
+			containerStatus,
+			healthTracker.status(),
+		);
 		setStatus(newStatus);
 	};
 
@@ -48,17 +142,32 @@ export async function createLocalStackStatusTracker(
 		}
 	});
 
-	let healthCheckTimeout: NodeJS.Timeout | undefined;
-	const startHealthCheck = async () => {
-		healthCheck = await fetchHealth();
+	healthTracker.onChange(() => {
 		deriveStatus();
-		healthCheckTimeout = setTimeout(() => void startHealthCheck(), 1_000);
-	};
+	});
 
-	await timeTracker.run("localstack-status.healthCheck", async () => {
-		await startHealthCheck();
+	containerStatusTracker.onChange((newContainerStatus) => {
+		switch (newContainerStatus) {
+			case "running":
+				void healthTracker.start("fast");
+				break;
+			case "stopping":
+			case "stopped":
+				healthTracker.stop();
+				break;
+		}
 	});
 
+	emitter.on((localStackStatus) => {
+		if (localStackStatus === "running") {
+			void healthTracker.start("slow");
+		}
+	});
+
+	// await timeTracker.run("localstack-status.healthCheck", async () => {
+	// 	await healthTracker.start("slow");
+	// });
+
 	return {
 		status() {
 			// biome-ignore lint/style/noNonNullAssertion: false positive
@@ -77,17 +186,17 @@ export async function createLocalStackStatusTracker(
 			}
 		},
 		dispose() {
-			clearTimeout(healthCheckTimeout);
+			healthTracker.dispose();
 		},
 	};
 }
 
 function getLocalStackStatus(
 	containerStatus: ContainerStatus | undefined,
-	healthCheck: boolean | undefined,
+	healthStatus: HealthStatus | undefined,
 ): LocalStackStatus {
 	if (containerStatus === "running") {
-		if (healthCheck === true) {
+		if (healthStatus === "healthy") {
 			return "running";
 		} else {
 			return "starting";
@@ -99,7 +208,7 @@ function getLocalStackStatus(
 	}
 }
 
-async function fetchHealth(): Promise<boolean> {
+async function fetchHealth(): Promise<"healthy" | "not_healthy"> {
 	// Abort the fetch if it takes more than 500ms.
 	const controller = new AbortController();
 	setTimeout(() => controller.abort(), 500);
@@ -111,8 +220,8 @@ async function fetchHealth(): Promise<boolean> {
 		const response = await fetch("http://localhost:4566/_localstack/health", {
 			signal: controller.signal,
 		});
-		return response.ok;
-	} catch (err) {
-		return false;
+		return response.ok ? "healthy" : "not_healthy";
+	} catch {
+		return "not_healthy";
 	}
 }