retries (#355)

.github/workflows/build-sign-notarize.yml

@@ -41,7 +41,7 @@ jobs:
     steps:
       - uses: teaxyz/setup@v0
         with:
-          version: 0.25.0
+          version: 0.26.2
       - uses: actions/checkout@v3
 
       - name: get gui version

.github/workflows/ci.yml

@@ -36,7 +36,7 @@ jobs:
     steps:
       - uses: teaxyz/setup@v0
         with:
-          version: 0.25.0
+          version: 0.26.2
       - uses: actions/checkout@v3
       - name: install app dependencies
         run: tea -E xc setup
@@ -51,7 +51,7 @@ jobs:
     steps:
       - uses: teaxyz/setup@v0
         with:
-          version: 0.25.0
+          version: 0.26.2
       - uses: actions/checkout@v3
       - name: cache node_modules build
         # TODO: cache issue in our self-hosted macos runner ESPIPE: invalid seek, read

modules/desktop/src/libs/native-electron.ts

@@ -11,7 +11,6 @@
  *  - connect to a local platform api and returns a data
  */
 
-import semverCompare from "semver/functions/compare";
 import type { Package, Review, AirtablePost, Bottle } from "@tea/ui/types";
 import { type GUIPackage, type DeviceAuth, type Session, AuthStatus } from "./types";
 
@@ -21,26 +20,24 @@ import { installPackageCommand } from "./native/cli";
 
 import { get as apiGet } from "$libs/v1-client";
 import axios from "axios";
+import withRetry from "./utils/retry";
 
 const log = window.require("electron-log");
 const { ipcRenderer, shell } = window.require("electron");
 
-let retryLimit = 0;
 export async function getDistPackages(): Promise<Package[]> {
-	let packages: Package[] = [];
 	try {
+		return withRetry(async () => {
 			const req = await axios.get<Package[]>(
 				"https://s3.amazonaws.com/preview.gui.tea.xyz/packages.json"
 			);
 			log.info("packages received:", req.data.length);
-		packages = req.data;
+			return req.data;
+		});
 	} catch (error) {
-		retryLimit++;
 		log.error("getDistPackagesList:", error);
-		if (retryLimit < 3) packages = await getDistPackages();
+		return [];
 	}
-	retryLimit = 0;
-	return packages;
 }
 
 export async function getInstalledPackages(): Promise<InstalledPackage[]> {
@@ -135,38 +132,33 @@ export async function getDeviceAuth(deviceId: string): Promise<DeviceAuth> {
 
 export async function getPackageBottles(packageName: string): Promise<Bottle[]> {
 	try {
+		return withRetry(async () => {
 			const pkg = await apiGet<Package>(`packages/${packageName.replaceAll("/", ":")}`);
 			log.info(`got ${pkg?.bottles?.length || 0} bottles for ${packageName}`);
 			return (pkg && pkg.bottles) || [];
+		});
 	} catch (error) {
-		log.error(error);
+		log.error("getPackageBottles:", error);
 		return [];
 	}
 }
 
-const retryGetPackage: { [key: string]: number } = {};
 export async function getPackage(packageName: string): Promise<Partial<Package>> {
-	let pkg: Partial<Package> = {};
 	try {
+		return await withRetry(async () => {
 			const data = await apiGet<Partial<Package>>(`packages/${packageName.replaceAll("/", ":")}`);
 			if (data) {
-			pkg = data;
+				return data;
 			} else {
 				throw new Error(`package:${packageName} not found`);
 			}
+		});
 	} catch (error) {
-		log.error(error);
-		retryGetPackage[packageName] = (retryGetPackage[packageName] || 0) + 1;
-		if (retryGetPackage[packageName] < 3) {
-			pkg = await getPackage(packageName);
-		} else {
-			log.info(`failed to get package:${packageName} after 3 tries`);
+		log.error("getPackage:", error);
+		return {};
 	}
 }
 
-	return pkg;
-}
-
 export const getSession = async (): Promise<Session | null> => {
 	try {
 		log.info("getting local session data");

modules/desktop/src/libs/utils/retry.ts

@@ -0,0 +1,34 @@
+const log = window.require("electron-log");
+
+export type RetryOptions = {
+	// Number of times to retry. default 10
+	maxRetries?: number;
+	// Initial delay in ms. default 100
+	initialDelayMs?: number;
+	// Maximum delay in ms. default 5000
+	maxDelayMs?: number;
+};
+
+// Retry a function up to maxRetries times, with exponential backoff
+// With defaults retry cadence will look like this:
+// 100ms, 200ms, 400ms, 800ms, 1600ms, 3200ms, 5000ms, 5000ms, 5000ms, 5000ms
+export default async function withRetry<T>(
+	fn: () => Promise<T>,
+	{ maxRetries = 10, initialDelayMs = 100, maxDelayMs = 5000 }: RetryOptions = {}
+) {
+	let retries = 0;
+	let currentDelay = initialDelayMs;
+	while (retries <= maxRetries) {
+		try {
+			return await fn();
+		} catch (err) {
+			log.error(err);
+			retries++;
+			await wait(currentDelay);
+			currentDelay = Math.min(currentDelay * 2, maxDelayMs);
+		}
+	}
+	throw new Error(`Failed after ${maxRetries} retries`);
+}
+
+const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

modules/desktop/src/libs/v1-client.ts

@@ -9,7 +9,6 @@ export async function get<T>(
 	urlPath: string,
 	params?: { [key: string]: string }
 ): Promise<T | null> {
-	try {
 	console.log(`GET /v1/${urlPath}`);
 
 	const [session] = await Promise.all([getSession()]);
@@ -24,18 +23,11 @@ export async function get<T>(
 		baseURL: "https://api.tea.xyz",
 		url: ["v1", ...urlPath.split("/")].filter((p) => p).join("/"),
 		headers,
-			params
+		params,
+		validateStatus: (status) => status >= 200 && status < 300
 	});
 
-		if (req.status == 200) {
 	return req.data as T;
-		} else {
-			return await get<T>(urlPath, params || {});
-		}
-	} catch (error) {
-		console.error("ERROR", error);
-		return null;
-	}
 }
 
 async function getHeaders(path: string, session: Session) {