PR feedback

__tests__/save.test.ts

@@ -208,7 +208,7 @@ test("save with large cache outputs warning", async () => {
 
     expect(logWarningMock).toHaveBeenCalledTimes(1);
     expect(logWarningMock).toHaveBeenCalledWith(
-        "Cache size of ~4 GB (4294967296 B) is over the 2GB limit, not saving cache."
+        "Cache size of ~4096 MB (4294967296 B) is over the 2GB limit, not saving cache."
     );
 
     expect(failedMock).toHaveBeenCalledTimes(0);

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "cache",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

src/cacheHttpClient.ts

@@ -177,6 +177,7 @@ async function uploadChunk(
     }
 
     if (isRetryableStatusCode(response.statusCode)) {
+        core.debug(`Received ${response.statusCode}, retrying chunk at offset ${start}.`);
         const retryResponse = await uploadChunkRequest();
         if (isSuccessStatusCode(retryResponse.statusCode)) {
             return retryResponse;
@@ -199,20 +200,19 @@ async function uploadFile(
     const responses: IRestResponse<void>[] = [];
     const fd = fs.openSync(archivePath, "r");
 
-    const concurrency = 4; // # of HTTP requests in parallel
+    const concurrency = Number(process.env["CACHE_UPLOAD_CONCURRENCY"]) ?? 4; // # of HTTP requests in parallel
-    const MAX_CHUNK_SIZE = 32000000; // 32 MB Chunks
+    const MAX_CHUNK_SIZE = Number(process.env["CACHE_UPLOAD_CHUNK_SIZE"]) ?? 32000000; // 32 MB Chunks
     core.debug(`Concurrency: ${concurrency} and Chunk Size: ${MAX_CHUNK_SIZE}`);
 
     const parallelUploads = [...new Array(concurrency).keys()];
     core.debug("Awaiting all uploads");
     let offset = 0;
+
+    try {
         await Promise.all(
             parallelUploads.map(async () => {
                 while (offset < fileSize) {
-                const chunkSize =
+                    const chunkSize = Math.min(fileSize - offset, MAX_CHUNK_SIZE)
-                    offset + MAX_CHUNK_SIZE > fileSize
-                        ? fileSize - offset
-                        : MAX_CHUNK_SIZE;
                     const start = offset;
                     const end = offset + chunkSize - 1;
                     offset += MAX_CHUNK_SIZE;
@@ -234,18 +234,9 @@ async function uploadFile(
                 }
             })
         );
-
+    } finally {
         fs.closeSync(fd);
-
-    const failedResponse = responses.find(
-        x => !isSuccessStatusCode(x.statusCode)
-    );
-    if (failedResponse) {
-        throw new Error(
-            `Cache service responded with ${failedResponse.statusCode} during chunk upload.`
-        );
     }
-
     return;
 }
 

src/restore.ts

@@ -60,7 +60,7 @@ async function run(): Promise<void> {
 
         try {
             const cacheEntry = await cacheHttpClient.getCacheEntry(keys);
-            if (!cacheEntry || !cacheEntry?.archiveLocation) {
+            if (!cacheEntry?.archiveLocation) {
                 core.info(
                     `Cache not found for input keys: ${keys.join(", ")}.`
                 );
@@ -78,7 +78,7 @@ async function run(): Promise<void> {
 
             // Download the cache from the cache entry
             await cacheHttpClient.downloadCache(
-                cacheEntry?.archiveLocation,
+                cacheEntry.archiveLocation,
                 archivePath
             );
 

src/save.ts

@@ -36,7 +36,7 @@ async function run(): Promise<void> {
 
         core.debug("Reserving Cache");
         const cacheId = await cacheHttpClient.reserveCache(primaryKey);
-        if (cacheId < 0) {
+        if (cacheId == -1) {
             core.info(
                 `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
             );
@@ -62,13 +62,13 @@ async function run(): Promise<void> {
         if (archiveFileSize > fileSizeLimit) {
             utils.logWarning(
                 `Cache size of ~${Math.round(
-                    archiveFileSize / (1024 * 1024 * 1024)
+                    archiveFileSize / (1024 * 1024)
-                )} GB (${archiveFileSize} B) is over the 2GB limit, not saving cache.`
+                )} MB (${archiveFileSize} B) is over the 2GB limit, not saving cache.`
             );
             return;
         }
 
-        core.debug("Saving Cache");
+        core.debug(`Saving Cache (ID: ${cacheId})`);
         await cacheHttpClient.saveCache(cacheId, archivePath);
     } catch (error) {
         utils.logWarning(error.message);