fix: retry requests on error until timeout reached

src/api.spec.ts

@@ -1,13 +1,22 @@
 import * as core from "@actions/core";
 import * as github from "@actions/github";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  type MockInstance,
+} from "vitest";
 
 import {
   getWorkflowRunActiveJobUrl,
   getWorkflowRunActiveJobUrlRetry,
   getWorkflowRunFailedJobs,
   getWorkflowRunState,
   init,
+  retryOnError,
 } from "./api.ts";
 
 vi.mock("@actions/core");
@@ -361,4 +370,73 @@ describe("API", () => {
       });
     });
   });
+
+  describe("retryOnError", () => {
+    let warningLogSpy: MockInstance<
+      [
+        message: string | Error,
+        properties?: core.AnnotationProperties | undefined,
+      ],
+      void
+    >;
+
+    beforeEach(() => {
+      vi.useFakeTimers();
+      warningLogSpy = vi.spyOn(core, "warning");
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+      warningLogSpy.mockRestore();
+    });
+
+    it("should retry a function if it throws an error", async () => {
+      const funcName = "testFunc";
+      const errorMsg = "some error";
+      const testFunc = vi
+        .fn()
+        .mockImplementation(async () => "completed")
+        .mockImplementationOnce(async () => {
+          throw new Error(errorMsg);
+        });
+
+      const retryPromise = retryOnError(() => testFunc(), funcName);
+
+      // Progress timers to first failure
+      vi.advanceTimersByTime(500);
+      await vi.advanceTimersByTimeAsync(500);
+
+      expect(warningLogSpy).toHaveBeenCalledOnce();
+      expect(warningLogSpy).toHaveBeenCalledWith(
+        "retryOnError: An unexpected error has occurred:\n" +
+          `  name: ${funcName}\n` +
+          `  error: ${errorMsg}`,
+      );
+
+      // Progress timers to second success
+      vi.advanceTimersByTime(500);
+      await vi.advanceTimersByTimeAsync(500);
+      const result = await retryPromise;
+
+      expect(warningLogSpy).toHaveBeenCalledOnce();
+      expect(result).toStrictEqual("completed");
+    });
+
+    it("should throw the original error if timed out while calling the function", async () => {
+      const funcName = "testFunc";
+      const errorMsg = "some error";
+      const testFunc = vi.fn().mockImplementation(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        throw new Error(errorMsg);
+      });
+
+      const retryPromise = retryOnError(() => testFunc(), funcName, 500);
+
+      vi.advanceTimersByTime(500);
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      vi.advanceTimersByTimeAsync(500);
+
+      await expect(retryPromise).rejects.toThrowError("some error");
+    });
+  });
 });

src/api.ts

@@ -239,3 +239,35 @@ export async function getWorkflowRunActiveJobUrlRetry(
 
   return "Unable to fetch URL";
 }
+
+export async function retryOnError<T>(
+  func: () => Promise<T>,
+  name: string,
+  timeout: number = 5000,
+): Promise<T> {
+  const startTime = Date.now();
+  let elapsedTime = Date.now() - startTime;
+
+  while (elapsedTime < timeout) {
+    elapsedTime = Date.now() - startTime;
+    try {
+      return await func();
+    } catch (error) {
+      if (error instanceof Error) {
+        // We now exceed the time, so throw the error up
+        if (Date.now() - startTime >= timeout) {
+          throw error;
+        }
+
+        core.warning(
+          "retryOnError: An unexpected error has occurred:\n" +
+            `  name: ${name}\n` +
+            `  error: ${error.message}`,
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  }
+
+  throw new Error(`Timeout exceeded while attempting to retry ${name}`);
+}

src/main.ts

@@ -5,6 +5,7 @@ import {
   getWorkflowRunFailedJobs,
   getWorkflowRunState,
   init,
+  retryOnError,
   WorkflowRunConclusion,
   WorkflowRunStatus,
 } from "./api.ts";
@@ -54,7 +55,11 @@ async function run(): Promise<void> {
       attemptNo++;
       elapsedTime = Date.now() - startTime;
 
-      const { status, conclusion } = await getWorkflowRunState(config.runId);
+      const { status, conclusion } = await retryOnError(
+        async () => getWorkflowRunState(config.runId),
+        "getWorkflowRunState",
+        400,
+      );
 
       if (status === WorkflowRunStatus.Completed) {
         switch (conclusion) {