Switch cache action to use the cache node package

src/utils/actionUtils.ts

@@ -1,86 +1,35 @@
 import * as core from "@actions/core";
-import * as exec from "@actions/exec";
-import * as glob from "@actions/glob";
-import * as io from "@actions/io";
-import * as fs from "fs";
-import * as path from "path";
-import * as util from "util";
-import * as uuidV4 from "uuid/v4";
 
-import {
-    CacheFilename,
-    CompressionMethod,
-    Outputs,
-    RefKey,
-    State
-} from "../constants";
-import { ArtifactCacheEntry } from "../contracts";
+import { Outputs, RefKey, State } from "../constants";
 
-// From https://github.com/actions/toolkit/blob/master/packages/tool-cache/src/tool-cache.ts#L23
-export async function createTempDirectory(): Promise<string> {
-    const IS_WINDOWS = process.platform === "win32";
-
-    let tempDirectory: string = process.env["RUNNER_TEMP"] || "";
-
-    if (!tempDirectory) {
-        let baseLocation: string;
-        if (IS_WINDOWS) {
-            // On Windows use the USERPROFILE env variable
-            baseLocation = process.env["USERPROFILE"] || "C:\\";
-        } else {
-            if (process.platform === "darwin") {
-                baseLocation = "/Users";
-            } else {
-                baseLocation = "/home";
-            }
-        }
-        tempDirectory = path.join(baseLocation, "actions", "temp");
-    }
-
-    const dest = path.join(tempDirectory, uuidV4.default());
-    await io.mkdirP(dest);
-    return dest;
-}
-
-export function getArchiveFileSize(path: string): number {
-    return fs.statSync(path).size;
-}
-
-export function isExactKeyMatch(
-    key: string,
-    cacheResult?: ArtifactCacheEntry
-): boolean {
+export function isExactKeyMatch(key: string, cacheKey?: string): boolean {
     return !!(
-        cacheResult &&
-        cacheResult.cacheKey &&
-        cacheResult.cacheKey.localeCompare(key, undefined, {
+        cacheKey &&
+        cacheKey.localeCompare(key, undefined, {
             sensitivity: "accent"
         }) === 0
     );
 }
 
-export function setCacheState(state: ArtifactCacheEntry): void {
-    core.saveState(State.CacheResult, JSON.stringify(state));
+export function setCacheState(state: string): void {
+    core.saveState(State.CacheResult, state);
 }
 
 export function setCacheHitOutput(isCacheHit: boolean): void {
     core.setOutput(Outputs.CacheHit, isCacheHit.toString());
 }
 
-export function setOutputAndState(
-    key: string,
-    cacheResult?: ArtifactCacheEntry
-): void {
-    setCacheHitOutput(isExactKeyMatch(key, cacheResult));
+export function setOutputAndState(key: string, cacheKey?: string): void {
+    setCacheHitOutput(isExactKeyMatch(key, cacheKey));
     // Store the cache result if it exists
-    cacheResult && setCacheState(cacheResult);
+    cacheKey && setCacheState(cacheKey);
 }
 
-export function getCacheState(): ArtifactCacheEntry | undefined {
-    const stateData = core.getState(State.CacheResult);
-    core.debug(`State: ${stateData}`);
-    if (stateData) {
-        return JSON.parse(stateData) as ArtifactCacheEntry;
+export function getCacheState(): string | undefined {
+    const cacheKey = core.getState(State.CacheResult);
+    if (cacheKey) {
+        core.debug(`Cache state/key: ${cacheKey}`);
+        return cacheKey;
     }
 
     return undefined;
@@ -91,70 +40,8 @@ export function logWarning(message: string): void {
     core.info(`${warningPrefix}${message}`);
 }
 
-export async function resolvePaths(patterns: string[]): Promise<string[]> {
-    const paths: string[] = [];
-    const workspace = process.env["GITHUB_WORKSPACE"] ?? process.cwd();
-    const globber = await glob.create(patterns.join("\n"), {
-        implicitDescendants: false
-    });
-
-    for await (const file of globber.globGenerator()) {
-        const relativeFile = path.relative(workspace, file);
-        core.debug(`Matched: ${relativeFile}`);
-        // Paths are made relative so the tar entries are all relative to the root of the workspace.
-        paths.push(`${relativeFile}`);
-    }
-
-    return paths;
-}
-
 // Cache token authorized for all events that are tied to a ref
 // See GitHub Context https://help.github.com/actions/automating-your-workflow-with-github-actions/contexts-and-expression-syntax-for-github-actions#github-context
 export function isValidEvent(): boolean {
     return RefKey in process.env && Boolean(process.env[RefKey]);
 }
-
-export function unlinkFile(path: fs.PathLike): Promise<void> {
-    return util.promisify(fs.unlink)(path);
-}
-
-async function getVersion(app: string): Promise<string> {
-    core.debug(`Checking ${app} --version`);
-    let versionOutput = "";
-    try {
-        await exec.exec(`${app} --version`, [], {
-            ignoreReturnCode: true,
-            silent: true,
-            listeners: {
-                stdout: (data: Buffer): string =>
-                    (versionOutput += data.toString()),
-                stderr: (data: Buffer): string =>
-                    (versionOutput += data.toString())
-            }
-        });
-    } catch (err) {
-        core.debug(err.message);
-    }
-
-    versionOutput = versionOutput.trim();
-    core.debug(versionOutput);
-    return versionOutput;
-}
-
-export async function getCompressionMethod(): Promise<CompressionMethod> {
-    const versionOutput = await getVersion("zstd");
-    return versionOutput.toLowerCase().includes("zstd command line interface")
-        ? CompressionMethod.Zstd
-        : CompressionMethod.Gzip;
-}
-
-export function getCacheFileName(compressionMethod: CompressionMethod): string {
-    return compressionMethod == CompressionMethod.Zstd
-        ? CacheFilename.Zstd
-        : CacheFilename.Gzip;
-}
-
-export async function useGnuTar(): Promise<boolean> {
-    const versionOutput = await getVersion("tar");
-    return versionOutput.toLowerCase().includes("gnu tar");
-}