feat(compile-genesis): enhance waitForGenesisConfig function for improved configMap retrieval

- Introduced a new function `waitForGenesisConfig` to handle the asynchronous retrieval of Kubernetes ConfigMaps with retry logic.
- Added configurable timeout and interval settings for waiting on ConfigMap availability.
- Improved error handling to provide clearer feedback on ConfigMap retrieval attempts.

Author: roderik

src/cli/commands/compile-genesis/compile-genesis.command.ts

@@ -10,13 +10,38 @@ import type {
 } from "../../../genesis/besu-genesis.service.ts";
 import {
   createKubernetesClient,
+  type KubernetesClient,
   readConfigMap,
   toAllocationConfigMapName,
 } from "../../integrations/kubernetes/kubernetes.client.ts";
 
 const GENESIS_DATA_KEY = "genesis.json";
 const ALLOCATION_DATA_KEY = "alloc.json";
 const DEFAULT_OUTPUT_PATH = "/data/atk-genesis.json";
+const DEFAULT_GENESIS_WAIT_TIMEOUT_MS = 120_000;
+const DEFAULT_GENESIS_WAIT_INTERVAL_MS = 2000;
+const MIN_GENESIS_WAIT_INTERVAL_MS = 200;
+const MILLISECONDS_IN_SECOND = 1000;
+
+const parseDuration = (raw: string | undefined, fallback: number): number => {
+  if (!raw) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isFinite(parsed) && parsed >= 0) {
+    return parsed;
+  }
+  return fallback;
+};
+
+const GENESIS_WAIT_TIMEOUT_MS = parseDuration(
+  Bun.env.GENESIS_WAIT_TIMEOUT_MS,
+  DEFAULT_GENESIS_WAIT_TIMEOUT_MS
+);
+const GENESIS_WAIT_INTERVAL_MS = parseDuration(
+  Bun.env.GENESIS_WAIT_INTERVAL_MS,
+  DEFAULT_GENESIS_WAIT_INTERVAL_MS
+);
 
 type CompileGenesisOptions = {
   genesisConfigMapName: string;
@@ -115,17 +140,72 @@ const parseAllocationEntry = (
   return parsed;
 };
 
+const waitForGenesisConfig = async (
+  context: KubernetesClient,
+  name: string
+) => {
+  const timeout = GENESIS_WAIT_TIMEOUT_MS;
+  const interval = Math.max(
+    GENESIS_WAIT_INTERVAL_MS,
+    MIN_GENESIS_WAIT_INTERVAL_MS
+  );
+  const start = Date.now();
+  let attempts = 0;
+
+  while (attempts === 0 || Date.now() - start < timeout) {
+    attempts += 1;
+    const config = await readConfigMap(context, name);
+    if (config) {
+      if (attempts > 1) {
+        const elapsedSeconds = (
+          (Date.now() - start) /
+          MILLISECONDS_IN_SECOND
+        ).toFixed(1);
+        process.stdout.write(
+          `ConfigMap ${name} became available after ${elapsedSeconds}s (attempt ${attempts}).\n`
+        );
+      }
+      return config;
+    }
+
+    if (timeout === 0 || Date.now() - start >= timeout) {
+      return;
+    }
+
+    if (attempts === 1) {
+      const seconds = Math.round(timeout / MILLISECONDS_IN_SECOND);
+      process.stdout.write(
+        `ConfigMap ${name} not found; waiting up to ${seconds}s for it to become available.\n`
+      );
+    } else {
+      const delaySeconds = Math.round(interval / MILLISECONDS_IN_SECOND);
+      process.stdout.write(
+        `ConfigMap ${name} still unavailable; retrying in ${delaySeconds}s (attempt ${attempts}).\n`
+      );
+    }
+
+    await Bun.sleep(interval);
+  }
+
+  return;
+};
+
 const compileGenesis = async ({
   genesisConfigMapName,
   outputPath,
 }: CompileGenesisOptions): Promise<void> => {
   const context = await createKubernetesClient();
   const { namespace } = context;
 
-  const genesisConfig = await readConfigMap(context, genesisConfigMapName);
+  const genesisConfig = await waitForGenesisConfig(
+    context,
+    genesisConfigMapName
+  );
   if (!genesisConfig) {
     throw new Error(
-      `ConfigMap ${genesisConfigMapName} not found in namespace ${namespace}.`
+      `ConfigMap ${genesisConfigMapName} not found in namespace ${namespace} after waiting up to ${Math.round(
+        GENESIS_WAIT_TIMEOUT_MS / MILLISECONDS_IN_SECOND
+      )} seconds.`
     );
   }
 

src/cli/integrations/kubernetes/kubernetes.client.ts

@@ -10,6 +10,8 @@ const NAMESPACE_PATH =
 const HEX_PREFIX = "0x";
 const HTTP_CONFLICT_STATUS = 409;
 const HTTP_NOT_FOUND_STATUS = 404;
+const STATUS_CODE_PATTERN = /\b(\d{3})\b/u;
+const HTTP_CODE_MESSAGE_PATTERN = /HTTP-Code:\s*(\d{3})/u;
 
 type KubernetesClient = {
   client: CoreV1Api;
@@ -79,6 +81,48 @@ const getStatusCode = (error: unknown): number | undefined => {
     return (fromResponse as { status?: number }).status;
   }
 
+  const body = (
+    error as {
+      body?: {
+        status?: number;
+        statusCode?: number;
+        code?: number;
+        message?: string;
+      };
+    }
+  ).body;
+  if (body) {
+    if (typeof body.status === "number") {
+      return body.status;
+    }
+    if (typeof body.statusCode === "number") {
+      return body.statusCode;
+    }
+    if (typeof body.code === "number") {
+      return body.code;
+    }
+    if (typeof body.message === "string") {
+      const match = body.message.match(STATUS_CODE_PATTERN);
+      if (match) {
+        const parsed = Number.parseInt(match[1] ?? "", 10);
+        if (!Number.isNaN(parsed)) {
+          return parsed;
+        }
+      }
+    }
+  }
+
+  const message = (error as { message?: string }).message;
+  if (typeof message === "string") {
+    const match = message.match(HTTP_CODE_MESSAGE_PATTERN);
+    if (match) {
+      const parsed = Number.parseInt(match[1] ?? "", 10);
+      if (!Number.isNaN(parsed)) {
+        return parsed;
+      }
+    }
+  }
+
   return;
 };