Merge pull request #1293 from github/edoardo/fix-with-timeout

Fix `withTimeout` helper function

lib/trap-caching.js

@@ -100,10 +100,11 @@ async function downloadTrapCaches(codeql, languages, logger) {
         // The SHA from the base of the PR is the most similar commit we might have a cache for
         const preferredKey = await cacheKey(codeql, language, baseSha);
         logger.info(`Looking in Actions cache for TRAP cache with key ${preferredKey}`);
-        const found = await (0, util_1.withTimeout)(MAX_CACHE_OPERATION_MS, cache.restoreCache([cacheDir], preferredKey, [
-            await cachePrefix(codeql, language), // Fall back to any cache with the right key prefix
-        ]), () => {
-            logger.info(`Timed out waiting for TRAP cache download for ${language}, will continue without it`);
+        const found = await cache.restoreCache([cacheDir], preferredKey, [
+            // Fall back to any cache with the right key prefix
+            await cachePrefix(codeql, language),
+        ], {
+            segmentTimeoutInMs: MAX_CACHE_OPERATION_MS,
         });
         if (found === undefined) {
             // We didn't find a TRAP cache in the Actions cache, so the directory on disk is

lib/util.js

@@ -748,19 +748,29 @@ exports.tryGetFolderBytes = tryGetFolderBytes;
  * Run a promise for a given amount of time, and if it doesn't resolve within
  * that time, call the provided callback and then return undefined.
  *
+ * Note that this does NOT cancel the original promise, so that promise will
+ * continue in the background even after the timeout has expired.
+ *
  * @param timeoutMs The timeout in milliseconds.
  * @param promise The promise to run.
  * @param onTimeout A callback to call if the promise times out.
  * @returns The result of the promise, or undefined if the promise times out.
  */
 async function withTimeout(timeoutMs, promise, onTimeout) {
+    let finished = false;
+    const mainTask = async () => {
+        const result = await promise;
+        finished = true;
+        return result;
+    };
     const timeout = new Promise((resolve) => {
         setTimeout(() => {
-            onTimeout();
+            if (!finished)
+                onTimeout();
             resolve(undefined);
         }, timeoutMs);
     });
-    return await Promise.race([promise, timeout]);
+    return await Promise.race([mainTask(), timeout]);
 }
 exports.withTimeout = withTimeout;
 //# sourceMappingURL=util.js.map

lib/util.test.js

@@ -424,4 +424,18 @@ const shortTime = 10;
     t.deepEqual(shortTaskTimedOut, false);
     t.deepEqual(result, 99);
 });
+(0, ava_1.default)("withTimeout doesn't call callback if promise resolves", async (t) => {
+    let shortTaskTimedOut = false;
+    const shortTask = new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(99);
+        }, shortTime);
+    });
+    const result = await util.withTimeout(100, shortTask, () => {
+        shortTaskTimedOut = true;
+    });
+    await new Promise((r) => setTimeout(r, 200));
+    t.deepEqual(shortTaskTimedOut, false);
+    t.deepEqual(result, 99);
+});
 //# sourceMappingURL=util.test.js.map