v0.5.0

dist/save/index.js

@@ -43294,12 +43294,43 @@ class CacheService {
     }
     restoreCache(paths, primaryKey, restoreKeys) {
         return __awaiter(this, void 0, void 0, function* () {
-            return "";
+            restoreKeys = restoreKeys || [];
+            const keys = [primaryKey, ...restoreKeys];
+            core.debug("Resolved Keys:");
+            core.debug(JSON.stringify(keys));
+            const compressionMethod = yield utils.getCompressionMethod();
+            // path are needed to compute version
+            const cacheEntry = yield this.getS3CacheKey(keys);
+            if (!cacheEntry) {
+                // Cache not found
+                return undefined;
+            }
+            const archivePath = path.join(yield utils.createTempDirectory(), cacheEntry);
+            core.debug(`Archive Path: ${archivePath}`);
+            try {
+                // Download the cache from the cache entry
+                yield this.downloadFromS3(cacheEntry, archivePath);
+                if (core.isDebug()) {
+                    yield tar_1.listTar(archivePath, compressionMethod);
+                }
+                core.info(`Cache Size: ~${filesize_1.default(fs_1.default.statSync(archivePath).size)}`);
+                yield tar_1.extractTar(archivePath, compressionMethod);
+                core.info("Cache restored successfully");
+            }
+            finally {
+                // Try to delete the archive to save space
+                try {
+                    yield utils.unlinkFile(archivePath);
+                }
+                catch (error) {
+                    core.debug(`Failed to delete archive: ${error}`);
+                }
+            }
+            return cacheEntry;
         });
     }
     saveCache(paths, key) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cacheId = this.getCacheId(key);
             const compressionMethod = yield utils.getCompressionMethod();
             const cachePaths = yield utils.resolvePaths(paths);
             core.debug("Cache Paths:");
@@ -43313,8 +43344,8 @@ class CacheService {
                     yield tar_1.listTar(archivePath, compressionMethod);
                 }
                 core.info(`Archive Size: ${filesize_1.default(fs_1.default.statSync(archivePath).size)}`);
-                core.debug(`Saving Cache (ID: ${cacheId})`);
-                yield this.uploadToS3(cacheId, archivePath);
+                core.debug(`Saving Cache (ID: ${key})`);
+                yield this.uploadToS3(key, archivePath);
             }
             finally {
                 // Try to delete the archive to save space
@@ -43330,20 +43361,73 @@ class CacheService {
     }
     uploadToS3(key, archivePath) {
         return __awaiter(this, void 0, void 0, function* () {
-            const client = new aws_sdk_1.S3();
             const data = fs_1.default.readFileSync(archivePath).toString("base64");
-            return client
+            return this._client
                 .putObject({
                 Bucket: this._bucket,
-                Key: key,
+                Key: path.join(this.getCacheFolder(), key),
                 Body: data
             })
                 .promise();
         });
     }
-    getCacheId(primaryKey) {
-        var _a;
-        return `${(_a = process.env["GITHUB_REPOSITORY"]) === null || _a === void 0 ? void 0 : _a.replace("/", "-").toLowerCase()}-${primaryKey}`;
+    downloadFromS3(key, savePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this._client
+                    .getObject({
+                    Bucket: this._bucket,
+                    Key: path.join(this.getCacheFolder(), key)
+                })
+                    .promise();
+                fs_1.default.writeFileSync(savePath, response.Body);
+            }
+            catch (err) {
+                core.warning("Could not download cache from S3");
+                core.warning(err.message);
+            }
+        });
+    }
+    getS3CacheKey(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // return first matching key
+            for (let i = 0; i < keys.length; i++) {
+                if (i === 0) {
+                    // look for exact match
+                    try {
+                        yield this._client
+                            .headObject({
+                            Bucket: this._bucket,
+                            Key: path.join(this.getCacheFolder(), keys[i])
+                        })
+                            .promise();
+                        return keys[i];
+                        // eslint-disable-next-line no-empty
+                    }
+                    catch (_a) { }
+                }
+                else {
+                    // look for match with newest added date that matches a prefix
+                    try {
+                        const response = yield this._client
+                            .listObjectsV2({
+                            Bucket: this._bucket,
+                            Prefix: path.join(this.getCacheFolder(), keys[i])
+                        })
+                            .promise();
+                        core.debug(JSON.stringify(response));
+                        // eslint-disable-next-line no-empty
+                    }
+                    catch (_b) { }
+                }
+            }
+            return undefined;
+        });
+    }
+    getCacheFolder() {
+        return process.env["GITHUB_REPOSITORY"]
+            .replace("/", "-")
+            .toLowerCase();
     }
 }
 exports.CacheService = CacheService;