Release v1.1.2

.eslintrc.json

@@ -12,12 +12,5 @@
     "plugin:prettier/recommended",
     "prettier/@typescript-eslint"
   ],
-  "plugins": ["@typescript-eslint", "simple-import-sort", "jest"],
-  "rules": {
-    "import/first": "error",
-    "import/newline-after-import": "error",
-    "import/no-duplicates": "error",
-    "simple-import-sort/sort": "error",
-    "sort-imports": "off"
-  }
+  "plugins": ["@typescript-eslint", "jest"]
 }

.github/workflows/codeql.yml

@@ -1,35 +0,0 @@
-name: "Code Scanning - Action"
-
-on:
-  push:
-  schedule:
-    - cron: '0 0 * * 0'
-
-jobs:
-  CodeQL-Build:
-
-    strategy:
-      fail-fast: false
-
-
-    # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      # Override language selection by uncommenting this and choosing your languages
-      # with:
-      #   languages: go, javascript, csharp, python, cpp, java
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below).
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.github/workflows/workflow.yml

@@ -13,129 +13,42 @@ on:
       - '**.md'
 
 jobs:
-  # Build and unit test
-  build:
+  test:
+    name: Test on ${{ matrix.os }}
+
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
       fail-fast: false
+
     runs-on: ${{ matrix.os }}
+
     steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup Node.js
-      uses: actions/setup-node@v1
+    - uses: actions/checkout@v1
+
+    - uses: actions/setup-node@v1
       with:
         node-version: '12.x'
-    - name: Determine npm cache directory
+
+    - name: Get npm cache directory
       id: npm-cache
       run: |
         echo "::set-output name=dir::$(npm config get cache)"
-    - name: Restore npm cache
-      uses: actions/cache@v1
+
+    - uses: actions/cache@v1
       with:
         path: ${{ steps.npm-cache.outputs.dir }}
         key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
         restore-keys: |
           ${{ runner.os }}-node-
+
     - run: npm ci
+
     - name: Prettier Format Check
       run: npm run format-check
+
     - name: ESLint Check
       run: npm run lint
+
     - name: Build & Test
       run: npm run test
-
-  # End to end save and restore
-  test-save:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Generate files in working directory
-      shell: bash
-      run: __tests__/create-cache-files.sh ${{ runner.os }} test-cache
-    - name: Generate files outside working directory
-      shell: bash
-      run: __tests__/create-cache-files.sh ${{ runner.os }} ~/test-cache
-    - name: Save cache
-      uses: ./
-      with:
-        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: |
-          test-cache
-          ~/test-cache
-  test-restore:
-    needs: test-save
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Restore cache
-      uses: ./
-      with:
-        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: |
-          test-cache
-          ~/test-cache
-    - name: Verify cache files in working directory
-      shell: bash
-      run: __tests__/verify-cache-files.sh ${{ runner.os }} test-cache
-    - name: Verify cache files outside working directory
-      shell: bash
-      run: __tests__/verify-cache-files.sh ${{ runner.os }} ~/test-cache
-
-  # End to end with proxy
-  test-proxy-save:
-    runs-on: ubuntu-latest
-    container:
-      image: ubuntu:latest
-      options: --dns 127.0.0.1
-    services:
-      squid-proxy:
-        image: datadog/squid:latest
-        ports:
-          - 3128:3128
-    env:
-      https_proxy: http://squid-proxy:3128
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Generate files
-      run: __tests__/create-cache-files.sh proxy test-cache
-    - name: Save cache
-      uses: ./
-      with:
-        key: test-proxy-${{ github.run_id }}
-        path: test-cache
-  test-proxy-restore:
-    needs: test-proxy-save
-    runs-on: ubuntu-latest
-    container:
-      image: ubuntu:latest
-      options: --dns 127.0.0.1
-    services:
-      squid-proxy:
-        image: datadog/squid:latest
-        ports:
-          - 3128:3128
-    env:
-      https_proxy: http://squid-proxy:3128
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Restore cache
-      uses: ./
-      with:
-        key: test-proxy-${{ github.run_id }}
-        path: test-cache
-    - name: Verify cache
-      run: __tests__/verify-cache-files.sh proxy test-cache

.gitignore

@@ -1,5 +1,8 @@
 __tests__/runner/*
 
+# comment out in distribution branches
+dist/
+
 node_modules/
 lib/
 

README.md

@@ -37,7 +37,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v1
 
     - name: Cache Primes
       id: cache-primes
@@ -67,9 +67,7 @@ See [Examples](examples.md) for a list of `actions/cache` implementations for us
 - [Java - Gradle](./examples.md#java---gradle)
 - [Java - Maven](./examples.md#java---maven)
 - [Node - npm](./examples.md#node---npm)
-- [Node - Lerna](./examples.md#node---lerna)
 - [Node - Yarn](./examples.md#node---yarn)
-- [OCaml/Reason - esy](./examples.md##ocamlreason---esy)
 - [PHP - Composer](./examples.md#php---composer)
 - [Python - pip](./examples.md#python---pip)
 - [R - renv](./examples.md#r---renv)
@@ -91,7 +89,7 @@ Using the `cache-hit` output, subsequent steps (such as install or build) can be
 Example:
 ```yaml
 steps:
-  - uses: actions/checkout@v2
+  - uses: actions/checkout@v1
 
   - uses: actions/cache@v1
     id: cache

__tests__/actionUtils.test.ts

@@ -1,6 +1,4 @@
 import * as core from "@actions/core";
-import * as io from "@actions/io";
-import { promises as fs } from "fs";
 import * as os from "os";
 import * as path from "path";
 
@@ -8,24 +6,13 @@ import { Events, Outputs, State } from "../src/constants";
 import { ArtifactCacheEntry } from "../src/contracts";
 import * as actionUtils from "../src/utils/actionUtils";
 
-import uuid = require("uuid");
-
 jest.mock("@actions/core");
 jest.mock("os");
 
-function getTempDir(): string {
-    return path.join(__dirname, "_temp", "actionUtils");
-}
-
 afterEach(() => {
     delete process.env[Events.Key];
 });
 
-afterAll(async () => {
-    delete process.env["GITHUB_WORKSPACE"];
-    await io.rmRF(getTempDir());
-});
-
 test("getArchiveFileSize returns file size", () => {
     const filePath = path.join(__dirname, "__fixtures__", "helloWorld.txt");
 
@@ -194,43 +181,17 @@ test("isValidEvent returns false for unknown event", () => {
     expect(isValidEvent).toBe(false);
 });
 
-test("resolvePaths with no ~ in path", async () => {
-    const filePath = ".cache";
+test("resolvePath with no ~ in path", () => {
+    const filePath = ".cache/yarn";
 
-    // Create the following layout:
-    //   cwd
-    //   cwd/.cache
-    //   cwd/.cache/file.txt
+    const resolvedPath = actionUtils.resolvePath(filePath);
 
-    const root = path.join(getTempDir(), "no-tilde");
-    // tarball entries will be relative to workspace
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    await fs.mkdir(root, { recursive: true });
-    const cache = path.join(root, ".cache");
-    await fs.mkdir(cache, { recursive: true });
-    await fs.writeFile(path.join(cache, "file.txt"), "cached");
-
-    const originalCwd = process.cwd();
-
-    try {
-        process.chdir(root);
-
-        const resolvedPath = await actionUtils.resolvePaths([filePath]);
-
-        const expectedPath = [filePath];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        process.chdir(originalCwd);
-    }
+    const expectedPath = path.resolve(filePath);
+    expect(resolvedPath).toBe(expectedPath);
 });
 
-test("resolvePaths with ~ in path", async () => {
-    const cacheDir = uuid();
-    const filePath = `~/${cacheDir}`;
-    // Create the following layout:
-    //   ~/uuid
-    //   ~/uuid/file.txt
+test("resolvePath with ~ in path", () => {
+    const filePath = "~/.cache/yarn";
 
     const homedir = jest.requireActual("os").homedir();
     const homedirMock = jest.spyOn(os, "homedir");
@@ -238,93 +199,24 @@ test("resolvePaths with ~ in path", async () => {
         return homedir;
     });
 
-    const target = path.join(homedir, cacheDir);
-    await fs.mkdir(target, { recursive: true });
-    await fs.writeFile(path.join(target, "file.txt"), "cached");
+    const resolvedPath = actionUtils.resolvePath(filePath);
 
-    const root = getTempDir();
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    try {
-        const resolvedPath = await actionUtils.resolvePaths([filePath]);
-
-        const expectedPath = [path.relative(root, target)];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        await io.rmRF(target);
-    }
+    const expectedPath = path.join(homedir, ".cache/yarn");
+    expect(resolvedPath).toBe(expectedPath);
 });
 
-test("resolvePaths with home not found", async () => {
+test("resolvePath with home not found", () => {
     const filePath = "~/.cache/yarn";
     const homedirMock = jest.spyOn(os, "homedir");
     homedirMock.mockImplementation(() => {
         return "";
     });
 
-    await expect(actionUtils.resolvePaths([filePath])).rejects.toThrow(
-        "Unable to determine HOME directory"
+    expect(() => actionUtils.resolvePath(filePath)).toThrow(
+        "Unable to resolve `~` to HOME"
     );
 });
 
-test("resolvePaths inclusion pattern returns found", async () => {
-    const pattern = "*.ts";
-    // Create the following layout:
-    //   inclusion-patterns
-    //   inclusion-patterns/miss.txt
-    //   inclusion-patterns/test.ts
-
-    const root = path.join(getTempDir(), "inclusion-patterns");
-    // tarball entries will be relative to workspace
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    await fs.mkdir(root, { recursive: true });
-    await fs.writeFile(path.join(root, "miss.txt"), "no match");
-    await fs.writeFile(path.join(root, "test.ts"), "match");
-
-    const originalCwd = process.cwd();
-
-    try {
-        process.chdir(root);
-
-        const resolvedPath = await actionUtils.resolvePaths([pattern]);
-
-        const expectedPath = ["test.ts"];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        process.chdir(originalCwd);
-    }
-});
-
-test("resolvePaths exclusion pattern returns not found", async () => {
-    const patterns = ["*.ts", "!test.ts"];
-    // Create the following layout:
-    //   exclusion-patterns
-    //   exclusion-patterns/miss.txt
-    //   exclusion-patterns/test.ts
-
-    const root = path.join(getTempDir(), "exclusion-patterns");
-    // tarball entries will be relative to workspace
-    process.env["GITHUB_WORKSPACE"] = root;
-
-    await fs.mkdir(root, { recursive: true });
-    await fs.writeFile(path.join(root, "miss.txt"), "no match");
-    await fs.writeFile(path.join(root, "test.ts"), "no match");
-
-    const originalCwd = process.cwd();
-
-    try {
-        process.chdir(root);
-
-        const resolvedPath = await actionUtils.resolvePaths(patterns);
-
-        const expectedPath = [];
-        expect(resolvedPath).toStrictEqual(expectedPath);
-    } finally {
-        process.chdir(originalCwd);
-    }
-});
-
 test("isValidEvent returns true for push event", () => {
     const event = Events.Push;
     process.env[Events.Key] = event;
@@ -342,16 +234,3 @@ test("isValidEvent returns true for pull request event", () => {
 
     expect(isValidEvent).toBe(true);
 });
-
-test("unlinkFile unlinks file", async () => {
-    const testDirectory = await fs.mkdtemp("unlinkFileTest");
-    const testFile = path.join(testDirectory, "test.txt");
-    await fs.writeFile(testFile, "hello world");
-
-    await actionUtils.unlinkFile(testFile);
-
-    // This should throw as testFile should not exist
-    await expect(fs.stat(testFile)).rejects.toThrow();
-
-    await fs.rmdir(testDirectory);
-});

__tests__/cacheHttpsClient.test.ts

@@ -1,177 +0,0 @@
-import { getCacheVersion, retry } from "../src/cacheHttpClient";
-import { CompressionMethod, Inputs } from "../src/constants";
-import * as testUtils from "../src/utils/testUtils";
-
-afterEach(() => {
-    testUtils.clearInputs();
-});
-
-test("getCacheVersion with path input and compression method undefined returns version", async () => {
-    testUtils.setInput(Inputs.Path, "node_modules");
-
-    const result = getCacheVersion();
-
-    expect(result).toEqual(
-        "b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985"
-    );
-});
-
-test("getCacheVersion with zstd compression returns version", async () => {
-    testUtils.setInput(Inputs.Path, "node_modules");
-    const result = getCacheVersion(CompressionMethod.Zstd);
-
-    expect(result).toEqual(
-        "273877e14fd65d270b87a198edbfa2db5a43de567c9a548d2a2505b408befe24"
-    );
-});
-
-test("getCacheVersion with gzip compression does not change vesion", async () => {
-    testUtils.setInput(Inputs.Path, "node_modules");
-    const result = getCacheVersion(CompressionMethod.Gzip);
-
-    expect(result).toEqual(
-        "b3e0c6cb5ecf32614eeb2997d905b9c297046d7cbf69062698f25b14b4cb0985"
-    );
-});
-
-test("getCacheVersion with no input throws", async () => {
-    expect(() => getCacheVersion()).toThrow();
-});
-
-interface TestResponse {
-    statusCode: number;
-    result: string | null;
-}
-
-function handleResponse(
-    response: TestResponse | undefined
-): Promise<TestResponse> {
-    if (!response) {
-        fail("Retry method called too many times");
-    }
-
-    if (response.statusCode === 999) {
-        throw Error("Test Error");
-    } else {
-        return Promise.resolve(response);
-    }
-}
-
-async function testRetryExpectingResult(
-    responses: Array<TestResponse>,
-    expectedResult: string | null
-): Promise<void> {
-    responses = responses.reverse(); // Reverse responses since we pop from end
-
-    const actualResult = await retry(
-        "test",
-        () => handleResponse(responses.pop()),
-        (response: TestResponse) => response.statusCode
-    );
-
-    expect(actualResult.result).toEqual(expectedResult);
-}
-
-async function testRetryExpectingError(
-    responses: Array<TestResponse>
-): Promise<void> {
-    responses = responses.reverse(); // Reverse responses since we pop from end
-
-    expect(
-        retry(
-            "test",
-            () => handleResponse(responses.pop()),
-            (response: TestResponse) => response.statusCode
-        )
-    ).rejects.toBeInstanceOf(Error);
-}
-
-test("retry works on successful response", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry works after retryable status code", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 503,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry fails after exhausting retries", async () => {
-    await testRetryExpectingError([
-        {
-            statusCode: 503,
-            result: null
-        },
-        {
-            statusCode: 503,
-            result: null
-        },
-        {
-            statusCode: 200,
-            result: "Ok"
-        }
-    ]);
-});
-
-test("retry fails after non-retryable status code", async () => {
-    await testRetryExpectingError([
-        {
-            statusCode: 500,
-            result: null
-        },
-        {
-            statusCode: 200,
-            result: "Ok"
-        }
-    ]);
-});
-
-test("retry works after error", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 999,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry returns after client error", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 400,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        null
-    );
-});

__tests__/create-cache-files.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-# Validate args
-prefix="$1"
-if [ -z "$prefix" ]; then
-  echo "Must supply prefix argument"
-  exit 1
-fi
-
-path="$2"
-if [ -z "$path" ]; then
-  echo "Must supply path argument"
-  exit 1
-fi
-
-mkdir -p $path
-echo "$prefix $GITHUB_RUN_ID" > $path/test-file.txt

__tests__/restore.test.ts

@@ -1,13 +1,7 @@
 import * as core from "@actions/core";
 import * as path from "path";
-
 import * as cacheHttpClient from "../src/cacheHttpClient";
-import {
-    CacheFilename,
-    CompressionMethod,
-    Events,
-    Inputs
-} from "../src/constants";
+import { Events, Inputs } from "../src/constants";
 import { ArtifactCacheEntry } from "../src/contracts";
 import run from "../src/restore";
 import * as tar from "../src/tar";
@@ -19,6 +13,10 @@ jest.mock("../src/tar");
 jest.mock("../src/utils/actionUtils");
 
 beforeAll(() => {
+    jest.spyOn(actionUtils, "resolvePath").mockImplementation(filePath => {
+        return path.resolve(filePath);
+    });
+
     jest.spyOn(actionUtils, "isExactKeyMatch").mockImplementation(
         (key, cacheResult) => {
             const actualUtils = jest.requireActual("../src/utils/actionUtils");
@@ -35,11 +33,6 @@ beforeAll(() => {
         const actualUtils = jest.requireActual("../src/utils/actionUtils");
         return actualUtils.getSupportedEvents();
     });
-
-    jest.spyOn(actionUtils, "getCacheFileName").mockImplementation(cm => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.getCacheFileName(cm);
-    });
 });
 
 beforeEach(() => {
@@ -66,8 +59,7 @@ test("restore with invalid event outputs warning", async () => {
 test("restore with no path should fail", async () => {
     const failedMock = jest.spyOn(core, "setFailed");
     await run();
-    // this input isn't necessary for restore b/c tarball contains entries relative to workspace
-    expect(failedMock).not.toHaveBeenCalledWith(
+    expect(failedMock).toHaveBeenCalledWith(
         "Input required and not supplied: path"
     );
 });
@@ -144,7 +136,7 @@ test("restore with no cache found", async () => {
     expect(failedMock).toHaveBeenCalledTimes(0);
 
     expect(infoMock).toHaveBeenCalledWith(
-        `Cache not found for input keys: ${key}`
+        `Cache not found for input keys: ${key}.`
     );
 });
 
@@ -203,12 +195,13 @@ test("restore with restore keys and no cache found", async () => {
     expect(failedMock).toHaveBeenCalledTimes(0);
 
     expect(infoMock).toHaveBeenCalledWith(
-        `Cache not found for input keys: ${key}, ${restoreKey}`
+        `Cache not found for input keys: ${key}, ${restoreKey}.`
     );
 });
 
-test("restore with gzip compressed cache found", async () => {
+test("restore with cache found", async () => {
     const key = "node-test";
+    const cachePath = path.resolve("node_modules");
     testUtils.setInputs({
         path: "node_modules",
         key
@@ -237,7 +230,7 @@ test("restore with gzip compressed cache found", async () => {
         return Promise.resolve(tempPath);
     });
 
-    const archivePath = path.join(tempPath, CacheFilename.Gzip);
+    const archivePath = path.join(tempPath, "cache.tgz");
     const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
     const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
 
@@ -247,20 +240,12 @@ test("restore with gzip compressed cache found", async () => {
         .mockReturnValue(fileSize);
 
     const extractTarMock = jest.spyOn(tar, "extractTar");
-    const unlinkFileMock = jest.spyOn(actionUtils, "unlinkFile");
     const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
 
-    const compression = CompressionMethod.Gzip;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
-
     await run();
 
     expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(getCacheMock).toHaveBeenCalledWith([key], {
-        compressionMethod: compression
-    });
+    expect(getCacheMock).toHaveBeenCalledWith([key]);
     expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
     expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
     expect(downloadCacheMock).toHaveBeenCalledWith(
@@ -270,21 +255,18 @@ test("restore with gzip compressed cache found", async () => {
     expect(getArchiveFileSizeMock).toHaveBeenCalledWith(archivePath);
 
     expect(extractTarMock).toHaveBeenCalledTimes(1);
-    expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression);
-
-    expect(unlinkFileMock).toHaveBeenCalledTimes(1);
-    expect(unlinkFileMock).toHaveBeenCalledWith(archivePath);
+    expect(extractTarMock).toHaveBeenCalledWith(archivePath, cachePath);
 
     expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
     expect(setCacheHitOutputMock).toHaveBeenCalledWith(true);
 
     expect(infoMock).toHaveBeenCalledWith(`Cache restored from key: ${key}`);
     expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
 });
 
-test("restore with a pull request event and zstd compressed cache found", async () => {
+test("restore with a pull request event and cache found", async () => {
     const key = "node-test";
+    const cachePath = path.resolve("node_modules");
     testUtils.setInputs({
         path: "node_modules",
         key
@@ -315,7 +297,7 @@ test("restore with a pull request event and zstd compressed cache found", async
         return Promise.resolve(tempPath);
     });
 
-    const archivePath = path.join(tempPath, CacheFilename.Zstd);
+    const archivePath = path.join(tempPath, "cache.tgz");
     const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
     const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
 
@@ -326,17 +308,11 @@ test("restore with a pull request event and zstd compressed cache found", async
 
     const extractTarMock = jest.spyOn(tar, "extractTar");
     const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
 
     await run();
 
     expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(getCacheMock).toHaveBeenCalledWith([key], {
-        compressionMethod: compression
-    });
+    expect(getCacheMock).toHaveBeenCalledWith([key]);
     expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
     expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
     expect(downloadCacheMock).toHaveBeenCalledWith(
@@ -347,19 +323,19 @@ test("restore with a pull request event and zstd compressed cache found", async
     expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~60 MB (62915000 B)`);
 
     expect(extractTarMock).toHaveBeenCalledTimes(1);
-    expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression);
+    expect(extractTarMock).toHaveBeenCalledWith(archivePath, cachePath);
 
     expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
     expect(setCacheHitOutputMock).toHaveBeenCalledWith(true);
 
     expect(infoMock).toHaveBeenCalledWith(`Cache restored from key: ${key}`);
     expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
 });
 
 test("restore with cache found for restore key", async () => {
     const key = "node-test";
     const restoreKey = "node-";
+    const cachePath = path.resolve("node_modules");
     testUtils.setInputs({
         path: "node_modules",
         key,
@@ -389,7 +365,7 @@ test("restore with cache found for restore key", async () => {
         return Promise.resolve(tempPath);
     });
 
-    const archivePath = path.join(tempPath, CacheFilename.Zstd);
+    const archivePath = path.join(tempPath, "cache.tgz");
     const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
     const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
 
@@ -400,17 +376,11 @@ test("restore with cache found for restore key", async () => {
 
     const extractTarMock = jest.spyOn(tar, "extractTar");
     const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
 
     await run();
 
     expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
-    expect(getCacheMock).toHaveBeenCalledWith([key, restoreKey], {
-        compressionMethod: compression
-    });
+    expect(getCacheMock).toHaveBeenCalledWith([key, restoreKey]);
     expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
     expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
     expect(downloadCacheMock).toHaveBeenCalledWith(
@@ -421,7 +391,7 @@ test("restore with cache found for restore key", async () => {
     expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~0 MB (142 B)`);
 
     expect(extractTarMock).toHaveBeenCalledTimes(1);
-    expect(extractTarMock).toHaveBeenCalledWith(archivePath, compression);
+    expect(extractTarMock).toHaveBeenCalledWith(archivePath, cachePath);
 
     expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
     expect(setCacheHitOutputMock).toHaveBeenCalledWith(false);
@@ -430,5 +400,4 @@ test("restore with cache found for restore key", async () => {
         `Cache restored from key: ${restoreKey}`
     );
     expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
 });

__tests__/save.test.ts

@@ -1,13 +1,7 @@
 import * as core from "@actions/core";
 import * as path from "path";
-
 import * as cacheHttpClient from "../src/cacheHttpClient";
-import {
-    CacheFilename,
-    CompressionMethod,
-    Events,
-    Inputs
-} from "../src/constants";
+import { Events, Inputs } from "../src/constants";
 import { ArtifactCacheEntry } from "../src/contracts";
 import run from "../src/save";
 import * as tar from "../src/tar";
@@ -46,20 +40,13 @@ beforeAll(() => {
         return actualUtils.getSupportedEvents();
     });
 
-    jest.spyOn(actionUtils, "resolvePaths").mockImplementation(
-        async filePaths => {
-            return filePaths.map(x => path.resolve(x));
-        }
-    );
+    jest.spyOn(actionUtils, "resolvePath").mockImplementation(filePath => {
+        return path.resolve(filePath);
+    });
 
     jest.spyOn(actionUtils, "createTempDirectory").mockImplementation(() => {
         return Promise.resolve("/foo/bar");
     });
-
-    jest.spyOn(actionUtils, "getCacheFileName").mockImplementation(cm => {
-        const actualUtils = jest.requireActual("../src/utils/actionUtils");
-        return actualUtils.getCacheFileName(cm);
-    });
 });
 
 beforeEach(() => {
@@ -202,7 +189,7 @@ test("save with large cache outputs warning", async () => {
         });
 
     const inputPath = "node_modules";
-    const cachePaths = [path.resolve(inputPath)];
+    const cachePath = path.resolve(inputPath);
     testUtils.setInput(Inputs.Path, inputPath);
 
     const createTarMock = jest.spyOn(tar, "createTar");
@@ -211,27 +198,20 @@ test("save with large cache outputs warning", async () => {
     jest.spyOn(actionUtils, "getArchiveFileSize").mockImplementationOnce(() => {
         return cacheSize;
     });
-    const compression = CompressionMethod.Gzip;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
 
     await run();
 
-    const archiveFolder = "/foo/bar";
+    const archivePath = path.join("/foo/bar", "cache.tgz");
 
     expect(createTarMock).toHaveBeenCalledTimes(1);
-    expect(createTarMock).toHaveBeenCalledWith(
-        archiveFolder,
-        cachePaths,
-        compression
-    );
+    expect(createTarMock).toHaveBeenCalledWith(archivePath, cachePath);
+
     expect(logWarningMock).toHaveBeenCalledTimes(1);
     expect(logWarningMock).toHaveBeenCalledWith(
         "Cache size of ~6144 MB (6442450944 B) is over the 5GB limit, not saving cache."
     );
+
     expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
 });
 
 test("save with reserve cache failure outputs warning", async () => {
@@ -267,18 +247,13 @@ test("save with reserve cache failure outputs warning", async () => {
         });
 
     const createTarMock = jest.spyOn(tar, "createTar");
+
     const saveCacheMock = jest.spyOn(cacheHttpClient, "saveCache");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
 
     await run();
 
     expect(reserveCacheMock).toHaveBeenCalledTimes(1);
-    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, {
-        compressionMethod: compression
-    });
+    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey);
 
     expect(infoMock).toHaveBeenCalledWith(
         `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
@@ -288,7 +263,6 @@ test("save with reserve cache failure outputs warning", async () => {
     expect(saveCacheMock).toHaveBeenCalledTimes(0);
     expect(logWarningMock).toHaveBeenCalledTimes(0);
     expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
 });
 
 test("save with server error outputs warning", async () => {
@@ -314,7 +288,7 @@ test("save with server error outputs warning", async () => {
         });
 
     const inputPath = "node_modules";
-    const cachePaths = [path.resolve(inputPath)];
+    const cachePath = path.resolve(inputPath);
     testUtils.setInput(Inputs.Path, inputPath);
 
     const cacheId = 4;
@@ -331,36 +305,24 @@ test("save with server error outputs warning", async () => {
         .mockImplementationOnce(() => {
             throw new Error("HTTP Error Occurred");
         });
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
 
     await run();
 
     expect(reserveCacheMock).toHaveBeenCalledTimes(1);
-    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, {
-        compressionMethod: compression
-    });
+    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey);
 
-    const archiveFolder = "/foo/bar";
-    const archiveFile = path.join(archiveFolder, CacheFilename.Zstd);
+    const archivePath = path.join("/foo/bar", "cache.tgz");
 
     expect(createTarMock).toHaveBeenCalledTimes(1);
-    expect(createTarMock).toHaveBeenCalledWith(
-        archiveFolder,
-        cachePaths,
-        compression
-    );
+    expect(createTarMock).toHaveBeenCalledWith(archivePath, cachePath);
 
     expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archiveFile);
+    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archivePath);
 
     expect(logWarningMock).toHaveBeenCalledTimes(1);
     expect(logWarningMock).toHaveBeenCalledWith("HTTP Error Occurred");
 
     expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
 });
 
 test("save with valid inputs uploads a cache", async () => {
@@ -385,7 +347,7 @@ test("save with valid inputs uploads a cache", async () => {
         });
 
     const inputPath = "node_modules";
-    const cachePaths = [path.resolve(inputPath)];
+    const cachePath = path.resolve(inputPath);
     testUtils.setInput(Inputs.Path, inputPath);
 
     const cacheId = 4;
@@ -398,31 +360,19 @@ test("save with valid inputs uploads a cache", async () => {
     const createTarMock = jest.spyOn(tar, "createTar");
 
     const saveCacheMock = jest.spyOn(cacheHttpClient, "saveCache");
-    const compression = CompressionMethod.Zstd;
-    const getCompressionMock = jest
-        .spyOn(actionUtils, "getCompressionMethod")
-        .mockReturnValue(Promise.resolve(compression));
 
     await run();
 
     expect(reserveCacheMock).toHaveBeenCalledTimes(1);
-    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, {
-        compressionMethod: compression
-    });
+    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey);
 
-    const archiveFolder = "/foo/bar";
-    const archiveFile = path.join(archiveFolder, CacheFilename.Zstd);
+    const archivePath = path.join("/foo/bar", "cache.tgz");
 
     expect(createTarMock).toHaveBeenCalledTimes(1);
-    expect(createTarMock).toHaveBeenCalledWith(
-        archiveFolder,
-        cachePaths,
-        compression
-    );
+    expect(createTarMock).toHaveBeenCalledWith(archivePath, cachePath);
 
     expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archiveFile);
+    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archivePath);
 
     expect(failedMock).toHaveBeenCalledTimes(0);
-    expect(getCompressionMock).toHaveBeenCalledTimes(1);
 });

__tests__/tar.test.ts

@@ -1,204 +1,58 @@
 import * as exec from "@actions/exec";
 import * as io from "@actions/io";
-import * as path from "path";
-
-import { CacheFilename, CompressionMethod } from "../src/constants";
 import * as tar from "../src/tar";
-import * as utils from "../src/utils/actionUtils";
-
-import fs = require("fs");
 
 jest.mock("@actions/exec");
 jest.mock("@actions/io");
 
-const IS_WINDOWS = process.platform === "win32";
-
-function getTempDir(): string {
-    return path.join(__dirname, "_temp", "tar");
-}
-
-beforeAll(async () => {
+beforeAll(() => {
     jest.spyOn(io, "which").mockImplementation(tool => {
         return Promise.resolve(tool);
     });
-
-    process.env["GITHUB_WORKSPACE"] = process.cwd();
-    await jest.requireActual("@actions/io").rmRF(getTempDir());
 });
 
-afterAll(async () => {
-    delete process.env["GITHUB_WORKSPACE"];
-    await jest.requireActual("@actions/io").rmRF(getTempDir());
-});
-
-test("zstd extract tar", async () => {
+test("extract tar", async () => {
     const mkdirMock = jest.spyOn(io, "mkdirP");
     const execMock = jest.spyOn(exec, "exec");
 
-    const archivePath = IS_WINDOWS
-        ? `${process.env["windir"]}\\fakepath\\cache.tar`
-        : "cache.tar";
-    const workspace = process.env["GITHUB_WORKSPACE"];
+    const archivePath = "cache.tar";
+    const targetDirectory = "~/.npm/cache";
+    await tar.extractTar(archivePath, targetDirectory);
 
-    await tar.extractTar(archivePath, CompressionMethod.Zstd);
+    expect(mkdirMock).toHaveBeenCalledWith(targetDirectory);
 
-    expect(mkdirMock).toHaveBeenCalledWith(workspace);
+    const IS_WINDOWS = process.platform === "win32";
     const tarPath = IS_WINDOWS
         ? `${process.env["windir"]}\\System32\\tar.exe`
         : "tar";
     expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "--use-compress-program",
-            "zstd -d --long=30",
-            "-xf",
-            IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace
-        ],
-        { cwd: undefined }
-    );
+    expect(execMock).toHaveBeenCalledWith(`"${tarPath}"`, [
+        "-xz",
+        "-f",
+        archivePath,
+        "-C",
+        targetDirectory
+    ]);
 });
 
-test("gzip extract tar", async () => {
-    const mkdirMock = jest.spyOn(io, "mkdirP");
-    const execMock = jest.spyOn(exec, "exec");
-    const archivePath = IS_WINDOWS
-        ? `${process.env["windir"]}\\fakepath\\cache.tar`
-        : "cache.tar";
-    const workspace = process.env["GITHUB_WORKSPACE"];
-
-    await tar.extractTar(archivePath, CompressionMethod.Gzip);
-
-    expect(mkdirMock).toHaveBeenCalledWith(workspace);
-    const tarPath = IS_WINDOWS
-        ? `${process.env["windir"]}\\System32\\tar.exe`
-        : "tar";
-    expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "-z",
-            "-xf",
-            IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace
-        ],
-        { cwd: undefined }
-    );
-});
-
-test("gzip extract GNU tar on windows", async () => {
-    if (IS_WINDOWS) {
-        jest.spyOn(fs, "existsSync").mockReturnValueOnce(false);
-
-        const isGnuMock = jest
-            .spyOn(utils, "useGnuTar")
-            .mockReturnValue(Promise.resolve(true));
-        const execMock = jest.spyOn(exec, "exec");
-        const archivePath = `${process.env["windir"]}\\fakepath\\cache.tar`;
-        const workspace = process.env["GITHUB_WORKSPACE"];
-
-        await tar.extractTar(archivePath, CompressionMethod.Gzip);
-
-        expect(isGnuMock).toHaveBeenCalledTimes(1);
-        expect(execMock).toHaveBeenCalledTimes(1);
-        expect(execMock).toHaveBeenCalledWith(
-            `"tar"`,
-            [
-                "-z",
-                "-xf",
-                archivePath.replace(/\\/g, "/"),
-                "-P",
-                "-C",
-                workspace?.replace(/\\/g, "/"),
-                "--force-local"
-            ],
-            { cwd: undefined }
-        );
-    }
-});
-
-test("zstd create tar", async () => {
+test("create tar", async () => {
     const execMock = jest.spyOn(exec, "exec");
 
-    const archiveFolder = getTempDir();
-    const workspace = process.env["GITHUB_WORKSPACE"];
-    const sourceDirectories = ["~/.npm/cache", `${workspace}/dist`];
-
-    await fs.promises.mkdir(archiveFolder, { recursive: true });
-
-    await tar.createTar(
-        archiveFolder,
-        sourceDirectories,
-        CompressionMethod.Zstd
-    );
+    const archivePath = "cache.tar";
+    const sourceDirectory = "~/.npm/cache";
+    await tar.createTar(archivePath, sourceDirectory);
 
+    const IS_WINDOWS = process.platform === "win32";
     const tarPath = IS_WINDOWS
         ? `${process.env["windir"]}\\System32\\tar.exe`
         : "tar";
-
     expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "--use-compress-program",
-            "zstd -T0 --long=30",
-            "-cf",
-            IS_WINDOWS
-                ? CacheFilename.Zstd.replace(/\\/g, "/")
-                : CacheFilename.Zstd,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace,
-            "--files-from",
-            "manifest.txt"
-        ],
-        {
-            cwd: archiveFolder
-        }
-    );
-});
-
-test("gzip create tar", async () => {
-    const execMock = jest.spyOn(exec, "exec");
-
-    const archiveFolder = getTempDir();
-    const workspace = process.env["GITHUB_WORKSPACE"];
-    const sourceDirectories = ["~/.npm/cache", `${workspace}/dist`];
-
-    await fs.promises.mkdir(archiveFolder, { recursive: true });
-
-    await tar.createTar(
-        archiveFolder,
-        sourceDirectories,
-        CompressionMethod.Gzip
-    );
-
-    const tarPath = IS_WINDOWS
-        ? `${process.env["windir"]}\\System32\\tar.exe`
-        : "tar";
-
-    expect(execMock).toHaveBeenCalledTimes(1);
-    expect(execMock).toHaveBeenCalledWith(
-        `"${tarPath}"`,
-        [
-            "-z",
-            "-cf",
-            IS_WINDOWS
-                ? CacheFilename.Gzip.replace(/\\/g, "/")
-                : CacheFilename.Gzip,
-            "-P",
-            "-C",
-            IS_WINDOWS ? workspace?.replace(/\\/g, "/") : workspace,
-            "--files-from",
-            "manifest.txt"
-        ],
-        {
-            cwd: archiveFolder
-        }
-    );
+    expect(execMock).toHaveBeenCalledWith(`"${tarPath}"`, [
+        "-cz",
+        "-f",
+        archivePath,
+        "-C",
+        sourceDirectory,
+        "."
+    ]);
 });

__tests__/verify-cache-files.sh

@@ -1,36 +0,0 @@
-#!/bin/sh
-
-# Validate args
-prefix="$1"
-if [ -z "$prefix" ]; then
-  echo "Must supply prefix argument"
-  exit 1
-fi
-
-path="$2"
-if [ -z "$path" ]; then
-  echo "Must specify path argument"
-  exit 1
-fi
-
-# Sanity check GITHUB_RUN_ID defined
-if [ -z "$GITHUB_RUN_ID" ]; then
-  echo "GITHUB_RUN_ID not defined"
-  exit 1
-fi
-
-# Verify file exists
-file="$path/test-file.txt"
-echo "Checking for $file"
-if [ ! -e $file ]; then
-  echo "File does not exist"
-  exit 1
-fi
-
-# Verify file content
-content="$(cat $file)"
-echo "File content:\n$content"
-if [ -z "$(echo $content | grep --fixed-strings "$prefix $GITHUB_RUN_ID")" ]; then
-  echo "Unexpected file content"
-  exit 1
-fi

examples.md

@@ -1,34 +1,22 @@
 # Examples
 
-- [Examples](#examples)
-  - [C# - NuGet](#c---nuget)
-  - [Elixir - Mix](#elixir---mix)
-  - [Go - Modules](#go---modules)
-  - [Haskell - Cabal](#haskell---cabal)
-  - [Java - Gradle](#java---gradle)
-  - [Java - Maven](#java---maven)
-  - [Node - npm](#node---npm)
-    - [macOS and Ubuntu](#macos-and-ubuntu)
-    - [Windows](#windows)
-    - [Using multiple systems and `npm config`](#using-multiple-systems-and-npm-config)
-  - [Node - Lerna](#node---lerna)
-  - [Node - Yarn](#node---yarn)
-  - [OCaml/Reason - esy](#ocamlreason---esy)
-  - [PHP - Composer](#php---composer)
-  - [Python - pip](#python---pip)
-    - [Simple example](#simple-example)
-    - [Multiple OS's in a workflow](#multiple-oss-in-a-workflow)
-    - [Using pip to get cache location](#using-pip-to-get-cache-location)
-    - [Using a script to get cache location](#using-a-script-to-get-cache-location)
-  - [R - renv](#r---renv)
-    - [Simple example](#simple-example-1)
-    - [Multiple OS's in a workflow](#multiple-oss-in-a-workflow-1)
-  - [Ruby - Bundler](#ruby---bundler)
-  - [Rust - Cargo](#rust---cargo)
-  - [Scala - SBT](#scala---sbt)
-  - [Swift, Objective-C - Carthage](#swift-objective-c---carthage)
-  - [Swift, Objective-C - CocoaPods](#swift-objective-c---cocoapods)
-  - [Swift - Swift Package Manager](#swift---swift-package-manager)
+- [C# - NuGet](#c---nuget)
+- [Elixir - Mix](#elixir---mix)
+- [Go - Modules](#go---modules)
+- [Haskell - Cabal](#haskell---cabal)
+- [Java - Gradle](#java---gradle)
+- [Java - Maven](#java---maven)
+- [Node - npm](#node---npm)
+- [Node - Yarn](#node---yarn)
+- [PHP - Composer](#php---composer)
+- [Python - pip](#python---pip)
+- [R - renv](#r---renv)
+- [Ruby - Bundler](#ruby---bundler)
+- [Rust - Cargo](#rust---cargo)
+- [Scala - SBT](#scala---sbt)
+- [Swift, Objective-C - Carthage](#swift-objective-c---carthage)
+- [Swift, Objective-C - CocoaPods](#swift-objective-c---cocoapods)
+- [Swift - Swift Package Manager](#swift---swift-package-manager)
 
 ## C# - NuGet
 Using [NuGet lock files](https://docs.microsoft.com/nuget/consume-packages/package-references-in-project-files#locking-dependencies):
@@ -106,7 +94,7 @@ We cache the elements of the Cabal store separately, as the entirety of `~/.caba
 - uses: actions/cache@v1
   with:
     path: ~/.gradle/caches
-    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
+    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
     restore-keys: |
       ${{ runner.os }}-gradle-
 ```
@@ -142,21 +130,17 @@ For npm, cache files are stored in `~/.npm` on Posix, or `%AppData%/npm-cache` o
 ### Windows
 
 ```yaml
-- name: Get npm cache directory
-  id: npm-cache
-  run: |
-    echo "::set-output name=dir::$(npm config get cache)"
 - uses: actions/cache@v1
   with:
-    path: ${{ steps.npm-cache.outputs.dir }}
-    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+    path: ~\AppData\Roaming\npm-cache
+    key: ${{ runner.os }}-node-${{ hashFiles('**\package-lock.json') }}
     restore-keys: |
       ${{ runner.os }}-node-
 ```
 
 ### Using multiple systems and `npm config`
 
-```yaml
+```yaml  
 - name: Get npm cache directory
   id: npm-cache
   run: |
@@ -169,67 +153,25 @@ For npm, cache files are stored in `~/.npm` on Posix, or `%AppData%/npm-cache` o
       ${{ runner.os }}-node-
 ```
 
-## Node - Lerna
-
->Note this example uses the new multi-paths feature and is only available at `master`
-```yaml
-- name: restore lerna
-  uses: actions/cache@master
-  with:
-    path: |
-      node_modules
-      */*/node_modules
-    key: ${{ runner.os }}-${{ hashFiles('**/yarn.lock') }}
-```
-
 ## Node - Yarn
 The yarn cache directory will depend on your operating system and version of `yarn`. See https://yarnpkg.com/lang/en/docs/cli/cache/ for more info.
 
 ```yaml
-- name: Get yarn cache directory path
-  id: yarn-cache-dir-path
+- name: Get yarn cache
+  id: yarn-cache
   run: echo "::set-output name=dir::$(yarn cache dir)"
 
 - uses: actions/cache@v1
-  id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
   with:
-    path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+    path: ${{ steps.yarn-cache.outputs.dir }}
     key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
     restore-keys: |
       ${{ runner.os }}-yarn-
 ```
 
-## OCaml/Reason - esy
-Esy allows you to export built dependencies and import pre-built dependencies.
-```yaml
-    - name: Restore Cache
-      id: restore-cache
-      uses: actions/cache@v1
-      with:
-        path: _export
-        key:  ${{ runner.os }}-esy-${{ hashFiles('esy.lock/index.json') }}
-        restore-keys: |
-          ${{ runner.os }}-esy-
-    - name: Esy install
-      run: 'esy install'
-    - name: Import Cache
-      run: |
-        esy import-dependencies _export
-        rm -rf _export
-
-    ...(Build job)...
-
-    # Re-export dependencies if anything has changed or if it is the first time
-    - name: Setting dependency cache 
-      run: |
-        esy export-dependencies
-      if: steps.restore-cache.outputs.cache-hit != 'true'
-```
-
-
 ## PHP - Composer
 
-```yaml
+```yaml  
 - name: Get Composer Cache Directory
   id: composer-cache
   run: |
@@ -291,32 +233,14 @@ Replace `~/.cache/pip` with the correct `path` if not using Ubuntu.
       ${{ runner.os }}-pip-
 ```
 
-### Using pip to get cache location
-
-> Note: This requires pip 20.1+
-```yaml
-- name: Get pip cache dir
-  id: pip-cache
-  run: |
-    echo "::set-output name=dir::$(pip cache dir)"
-
-- name: pip cache
-  uses: actions/cache@v1
-  with:
-    path: ${{ steps.pip-cache.outputs.dir }}
-    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-    restore-keys: |
-      ${{ runner.os }}-pip-
-```
-
 ### Using a script to get cache location
 
 > Note: This uses an internal pip API and may not always work
 ```yaml
-- name: Get pip cache dir
- id: pip-cache
- run: |
-   python -c "from pip._internal.locations import USER_CACHE_DIR; print('::set-output name=dir::' + USER_CACHE_DIR)"
+- name: Get pip cache
+   id: pip-cache
+   run: |
+     python -c "from pip._internal.locations import USER_CACHE_DIR; print('::set-output name=dir::' + USER_CACHE_DIR)"
 
 - uses: actions/cache@v1
   with:

package.json

@@ -5,11 +5,12 @@
   "description": "Cache dependencies and build outputs",
   "main": "dist/restore/index.js",
   "scripts": {
-    "build": "tsc && ncc build -o dist/restore src/restore.ts && ncc build -o dist/save src/save.ts",
+    "build": "tsc",
     "test": "tsc --noEmit && jest --coverage",
     "lint": "eslint **/*.ts --cache",
     "format": "prettier --write **/*.ts",
-    "format-check": "prettier --check **/*.ts"
+    "format-check": "prettier --check **/*.ts",
+    "release": "ncc build -o dist/restore src/restore.ts && ncc build -o dist/save src/save.ts && git add -f dist/"
   },
   "repository": {
     "type": "git",
@@ -25,8 +26,7 @@
   "dependencies": {
     "@actions/core": "^1.2.0",
     "@actions/exec": "^1.0.1",
-    "@actions/glob": "^0.1.0",
-    "@actions/http-client": "^1.0.8",
+    "@actions/http-client": "^1.0.6",
     "@actions/io": "^1.0.1",
     "uuid": "^3.3.3"
   },
@@ -43,7 +43,6 @@
     "eslint-plugin-import": "^2.18.2",
     "eslint-plugin-jest": "^23.0.3",
     "eslint-plugin-prettier": "^3.1.1",
-    "eslint-plugin-simple-import-sort": "^5.0.2",
     "jest": "^24.8.0",
     "jest-circus": "^24.7.1",
     "nock": "^11.7.0",

src/cacheHttpClient.ts

@@ -1,28 +1,20 @@
 import * as core from "@actions/core";
-import { HttpClient, HttpCodes } from "@actions/http-client";
+import * as fs from "fs";
 import { BearerCredentialHandler } from "@actions/http-client/auth";
+import { HttpClient, HttpCodes } from "@actions/http-client";
 import {
     IHttpClientResponse,
     IRequestOptions,
     ITypedResponse
 } from "@actions/http-client/interfaces";
-import * as crypto from "crypto";
-import * as fs from "fs";
-import * as stream from "stream";
-import * as util from "util";
-
-import { CompressionMethod, Inputs, SocketTimeout } from "./constants";
 import {
     ArtifactCacheEntry,
-    CacheOptions,
     CommitCacheRequest,
     ReserveCacheRequest,
     ReserveCacheResponse
 } from "./contracts";
 import * as utils from "./utils/actionUtils";
 
-const versionSalt = "1.0";
-
 function isSuccessStatusCode(statusCode?: number): boolean {
     if (!statusCode) {
         return false;
@@ -30,13 +22,6 @@ function isSuccessStatusCode(statusCode?: number): boolean {
     return statusCode >= 200 && statusCode < 300;
 }
 
-function isServerErrorStatusCode(statusCode?: number): boolean {
-    if (!statusCode) {
-        return true;
-    }
-    return statusCode >= 500;
-}
-
 function isRetryableStatusCode(statusCode?: number): boolean {
     if (!statusCode) {
         return false;
@@ -92,106 +77,21 @@ function createHttpClient(): HttpClient {
     );
 }
 
-export function getCacheVersion(compressionMethod?: CompressionMethod): string {
-    const components = [core.getInput(Inputs.Path, { required: true })].concat(
-        compressionMethod == CompressionMethod.Zstd ? [compressionMethod] : []
-    );
-
-    // Add salt to cache version to support breaking changes in cache entry
-    components.push(versionSalt);
-
-    return crypto
-        .createHash("sha256")
-        .update(components.join("|"))
-        .digest("hex");
-}
-
-export async function retry<T>(
-    name: string,
-    method: () => Promise<T>,
-    getStatusCode: (T) => number | undefined,
-    maxAttempts = 2
-): Promise<T> {
-    let response: T | undefined = undefined;
-    let statusCode: number | undefined = undefined;
-    let isRetryable = false;
-    let errorMessage = "";
-    let attempt = 1;
-
-    while (attempt <= maxAttempts) {
-        try {
-            response = await method();
-            statusCode = getStatusCode(response);
-
-            if (!isServerErrorStatusCode(statusCode)) {
-                return response;
-            }
-
-            isRetryable = isRetryableStatusCode(statusCode);
-            errorMessage = `Cache service responded with ${statusCode}`;
-        } catch (error) {
-            isRetryable = true;
-            errorMessage = error.message;
-        }
-
-        core.debug(
-            `${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`
-        );
-
-        if (!isRetryable) {
-            core.debug(`${name} - Error is not retryable`);
-            break;
-        }
-
-        attempt++;
-    }
-
-    throw Error(`${name} failed: ${errorMessage}`);
-}
-
-export async function retryTypedResponse<T>(
-    name: string,
-    method: () => Promise<ITypedResponse<T>>,
-    maxAttempts = 2
-): Promise<ITypedResponse<T>> {
-    return await retry(
-        name,
-        method,
-        (response: ITypedResponse<T>) => response.statusCode,
-        maxAttempts
-    );
-}
-
-export async function retryHttpClientResponse<T>(
-    name: string,
-    method: () => Promise<IHttpClientResponse>,
-    maxAttempts = 2
-): Promise<IHttpClientResponse> {
-    return await retry(
-        name,
-        method,
-        (response: IHttpClientResponse) => response.message.statusCode,
-        maxAttempts
-    );
-}
-
 export async function getCacheEntry(
-    keys: string[],
-    options?: CacheOptions
+    keys: string[]
 ): Promise<ArtifactCacheEntry | null> {
     const httpClient = createHttpClient();
-    const version = getCacheVersion(options?.compressionMethod);
-    const resource = `cache?keys=${encodeURIComponent(
-        keys.join(",")
-    )}&version=${version}`;
+    const resource = `cache?keys=${encodeURIComponent(keys.join(","))}`;
 
-    const response = await retryTypedResponse("getCacheEntry", () =>
-        httpClient.getJson<ArtifactCacheEntry>(getCacheApiUrl(resource))
+    const response = await httpClient.getJson<ArtifactCacheEntry>(
+        getCacheApiUrl(resource)
     );
-
     if (response.statusCode === 204) {
         return null;
     }
+    if (!isSuccessStatusCode(response.statusCode)) {
+        throw new Error(`Cache service responded with ${response.statusCode}`);
+    }
 
     const cacheResult = response.result;
     const cacheDownloadUrl = cacheResult?.archiveLocation;
@@ -207,10 +107,13 @@ export async function getCacheEntry(
 
 async function pipeResponseToStream(
     response: IHttpClientResponse,
-    output: NodeJS.WritableStream
+    stream: NodeJS.WritableStream
 ): Promise<void> {
-    const pipeline = util.promisify(stream.pipeline);
-    await pipeline(response.message, output);
+    return new Promise(resolve => {
+        response.message.pipe(stream).on("close", () => {
+            resolve();
+        });
+    });
 }
 
 export async function downloadCache(
@@ -219,58 +122,21 @@ export async function downloadCache(
 ): Promise<void> {
     const stream = fs.createWriteStream(archivePath);
     const httpClient = new HttpClient("actions/cache");
-    const downloadResponse = await retryHttpClientResponse(
-        "downloadCache",
-        () => httpClient.get(archiveLocation)
-    );
-
-    // Abort download if no traffic received over the socket.
-    downloadResponse.message.socket.setTimeout(SocketTimeout, () => {
-        downloadResponse.message.destroy();
-        core.debug(
-            `Aborting download, socket timed out after ${SocketTimeout} ms`
-        );
-    });
-
+    const downloadResponse = await httpClient.get(archiveLocation);
     await pipeResponseToStream(downloadResponse, stream);
-
-    // Validate download size.
-    const contentLengthHeader =
-        downloadResponse.message.headers["content-length"];
-
-    if (contentLengthHeader) {
-        const expectedLength = parseInt(contentLengthHeader);
-        const actualLength = utils.getArchiveFileSize(archivePath);
-
-        if (actualLength != expectedLength) {
-            throw new Error(
-                `Incomplete download. Expected file size: ${expectedLength}, actual file size: ${actualLength}`
-            );
-        }
-    } else {
-        core.debug("Unable to validate download, no Content-Length header");
-    }
 }
 
 // Reserve Cache
-export async function reserveCache(
-    key: string,
-    options?: CacheOptions
-): Promise<number> {
+export async function reserveCache(key: string): Promise<number> {
     const httpClient = createHttpClient();
-    const version = getCacheVersion(options?.compressionMethod);
 
     const reserveCacheRequest: ReserveCacheRequest = {
-        key,
-        version
+        key
     };
-    const response = await retryTypedResponse("reserveCache", () =>
-        httpClient.postJson<ReserveCacheResponse>(
-            getCacheApiUrl("caches"),
-            reserveCacheRequest
-        )
+    const response = await httpClient.postJson<ReserveCacheResponse>(
+        getCacheApiUrl("caches"),
+        reserveCacheRequest
     );
-
     return response?.result?.cacheId ?? -1;
 }
 
@@ -286,7 +152,7 @@ function getContentRange(start: number, end: number): string {
 async function uploadChunk(
     httpClient: HttpClient,
     resourceUrl: string,
-    openStream: () => NodeJS.ReadableStream,
+    data: NodeJS.ReadableStream,
     start: number,
     end: number
 ): Promise<void> {
@@ -307,14 +173,28 @@ async function uploadChunk(
         return await httpClient.sendStream(
             "PATCH",
             resourceUrl,
-            openStream(),
+            data,
             additionalHeaders
         );
     };
 
-    await retryHttpClientResponse(
-        `uploadChunk (start: ${start}, end: ${end})`,
-        uploadChunkRequest
+    const response = await uploadChunkRequest();
+    if (isSuccessStatusCode(response.message.statusCode)) {
+        return;
+    }
+
+    if (isRetryableStatusCode(response.message.statusCode)) {
+        core.debug(
+            `Received ${response.message.statusCode}, retrying chunk at offset ${start}.`
+        );
+        const retryResponse = await uploadChunkRequest();
+        if (isSuccessStatusCode(retryResponse.message.statusCode)) {
+            return;
+        }
+    }
+
+    throw new Error(
+        `Cache service responded with ${response.message.statusCode} during chunk upload.`
     );
 }
 
@@ -356,17 +236,17 @@ async function uploadFile(
                     const start = offset;
                     const end = offset + chunkSize - 1;
                     offset += MAX_CHUNK_SIZE;
+                    const chunk = fs.createReadStream(archivePath, {
+                        fd,
+                        start,
+                        end,
+                        autoClose: false
+                    });
 
                     await uploadChunk(
                         httpClient,
                         resourceUrl,
-                        () =>
-                            fs.createReadStream(archivePath, {
-                                fd,
-                                start,
-                                end,
-                                autoClose: false
-                            }),
+                        chunk,
                         start,
                         end
                     );
@@ -385,11 +265,9 @@ async function commitCache(
     filesize: number
 ): Promise<ITypedResponse<null>> {
     const commitCacheRequest: CommitCacheRequest = { size: filesize };
-    return await retryTypedResponse("commitCache", () =>
-        httpClient.postJson<null>(
-            getCacheApiUrl(`caches/${cacheId.toString()}`),
-            commitCacheRequest
-        )
+    return await httpClient.postJson<null>(
+        getCacheApiUrl(`caches/${cacheId.toString()}`),
+        commitCacheRequest
     );
 }
 

src/constants.ts

@@ -18,18 +18,3 @@ export enum Events {
     Push = "push",
     PullRequest = "pull_request"
 }
-
-export enum CacheFilename {
-    Gzip = "cache.tgz",
-    Zstd = "cache.tzst"
-}
-
-export enum CompressionMethod {
-    Gzip = "gzip",
-    Zstd = "zstd"
-}
-
-// Socket timeout in milliseconds during download.  If no traffic is received
-// over the socket during this period, the socket is destroyed and the download
-// is aborted.
-export const SocketTimeout = 5000;

src/contracts.d.ts

@@ -1,5 +1,3 @@
-import { CompressionMethod } from "./constants";
-
 export interface ArtifactCacheEntry {
     cacheKey?: string;
     scope?: string;
@@ -19,7 +17,3 @@ export interface ReserveCacheRequest {
 export interface ReserveCacheResponse {
     cacheId: number;
 }
-
-export interface CacheOptions {
-    compressionMethod?: CompressionMethod;
-}

src/restore.ts

@@ -1,6 +1,5 @@
 import * as core from "@actions/core";
 import * as path from "path";
-
 import * as cacheHttpClient from "./cacheHttpClient";
 import { Events, Inputs, State } from "./constants";
 import { extractTar } from "./tar";
@@ -20,6 +19,11 @@ async function run(): Promise<void> {
             return;
         }
 
+        const cachePath = utils.resolvePath(
+            core.getInput(Inputs.Path, { required: true })
+        );
+        core.debug(`Cache Path: ${cachePath}`);
+
         const primaryKey = core.getInput(Inputs.Key, { required: true });
         core.saveState(State.CacheKey, primaryKey);
 
@@ -54,49 +58,38 @@ async function run(): Promise<void> {
             }
         }
 
-        const compressionMethod = await utils.getCompressionMethod();
-
         try {
-            const cacheEntry = await cacheHttpClient.getCacheEntry(keys, {
-                compressionMethod: compressionMethod
-            });
+            const cacheEntry = await cacheHttpClient.getCacheEntry(keys);
             if (!cacheEntry?.archiveLocation) {
-                core.info(`Cache not found for input keys: ${keys.join(", ")}`);
+                core.info(
+                    `Cache not found for input keys: ${keys.join(", ")}.`
+                );
                 return;
             }
 
             const archivePath = path.join(
                 await utils.createTempDirectory(),
-                utils.getCacheFileName(compressionMethod)
+                "cache.tgz"
             );
             core.debug(`Archive Path: ${archivePath}`);
 
             // Store the cache result
             utils.setCacheState(cacheEntry);
 
-            try {
-                // Download the cache from the cache entry
-                await cacheHttpClient.downloadCache(
-                    cacheEntry.archiveLocation,
-                    archivePath
-                );
+            // Download the cache from the cache entry
+            await cacheHttpClient.downloadCache(
+                cacheEntry.archiveLocation,
+                archivePath
+            );
 
-                const archiveFileSize = utils.getArchiveFileSize(archivePath);
-                core.info(
-                    `Cache Size: ~${Math.round(
-                        archiveFileSize / (1024 * 1024)
-                    )} MB (${archiveFileSize} B)`
-                );
+            const archiveFileSize = utils.getArchiveFileSize(archivePath);
+            core.info(
+                `Cache Size: ~${Math.round(
+                    archiveFileSize / (1024 * 1024)
+                )} MB (${archiveFileSize} B)`
+            );
 
-                await extractTar(archivePath, compressionMethod);
-            } finally {
-                // Try to delete the archive to save space
-                try {
-                    await utils.unlinkFile(archivePath);
-                } catch (error) {
-                    core.debug(`Failed to delete archive: ${error}`);
-                }
-            }
+            await extractTar(archivePath, cachePath);
 
             const isExactKeyMatch = utils.isExactKeyMatch(
                 primaryKey,

src/save.ts

@@ -1,6 +1,5 @@
 import * as core from "@actions/core";
 import * as path from "path";
-
 import * as cacheHttpClient from "./cacheHttpClient";
 import { Events, Inputs, State } from "./constants";
 import { createTar } from "./tar";
@@ -35,12 +34,8 @@ async function run(): Promise<void> {
             return;
         }
 
-        const compressionMethod = await utils.getCompressionMethod();
-
         core.debug("Reserving Cache");
-        const cacheId = await cacheHttpClient.reserveCache(primaryKey, {
-            compressionMethod: compressionMethod
-        });
+        const cacheId = await cacheHttpClient.reserveCache(primaryKey);
         if (cacheId == -1) {
             core.info(
                 `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
@@ -48,25 +43,18 @@ async function run(): Promise<void> {
             return;
         }
         core.debug(`Cache ID: ${cacheId}`);
-        const cachePaths = await utils.resolvePaths(
-            core
-                .getInput(Inputs.Path, { required: true })
-                .split("\n")
-                .filter(x => x !== "")
+        const cachePath = utils.resolvePath(
+            core.getInput(Inputs.Path, { required: true })
         );
+        core.debug(`Cache Path: ${cachePath}`);
 
-        core.debug("Cache Paths:");
-        core.debug(`${JSON.stringify(cachePaths)}`);
-
-        const archiveFolder = await utils.createTempDirectory();
         const archivePath = path.join(
-            archiveFolder,
-            utils.getCacheFileName(compressionMethod)
+            await utils.createTempDirectory(),
+            "cache.tgz"
         );
-
         core.debug(`Archive Path: ${archivePath}`);
 
-        await createTar(archiveFolder, cachePaths, compressionMethod);
+        await createTar(archivePath, cachePath);
 
         const fileSizeLimit = 5 * 1024 * 1024 * 1024; // 5GB per repo limit
         const archiveFileSize = utils.getArchiveFileSize(archivePath);

src/tar.ts

@@ -1,87 +1,47 @@
 import { exec } from "@actions/exec";
 import * as io from "@actions/io";
-import { existsSync, writeFileSync } from "fs";
-import * as path from "path";
+import { existsSync } from "fs";
 
-import { CompressionMethod } from "./constants";
-import * as utils from "./utils/actionUtils";
-
-async function getTarPath(args: string[]): Promise<string> {
+async function getTarPath(): Promise<string> {
     // Explicitly use BSD Tar on Windows
     const IS_WINDOWS = process.platform === "win32";
     if (IS_WINDOWS) {
         const systemTar = `${process.env["windir"]}\\System32\\tar.exe`;
         if (existsSync(systemTar)) {
             return systemTar;
-        } else if (await utils.useGnuTar()) {
-            args.push("--force-local");
         }
     }
     return await io.which("tar", true);
 }
 
-async function execTar(args: string[], cwd?: string): Promise<void> {
+async function execTar(args: string[]): Promise<void> {
     try {
-        await exec(`"${await getTarPath(args)}"`, args, { cwd: cwd });
+        await exec(`"${await getTarPath()}"`, args);
     } catch (error) {
+        const IS_WINDOWS = process.platform === "win32";
+        if (IS_WINDOWS) {
+            throw new Error(
+                `Tar failed with error: ${error?.message}. Ensure BSD tar is installed and on the PATH.`
+            );
+        }
         throw new Error(`Tar failed with error: ${error?.message}`);
     }
 }
 
-function getWorkingDirectory(): string {
-    return process.env["GITHUB_WORKSPACE"] ?? process.cwd();
-}
-
 export async function extractTar(
     archivePath: string,
-    compressionMethod: CompressionMethod
+    targetDirectory: string
 ): Promise<void> {
     // Create directory to extract tar into
-    const workingDirectory = getWorkingDirectory();
-    await io.mkdirP(workingDirectory);
-    // --d: Decompress.
-    // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
-    // Using 30 here because we also support 32-bit self-hosted runners.
-    const args = [
-        ...(compressionMethod == CompressionMethod.Zstd
-            ? ["--use-compress-program", "zstd -d --long=30"]
-            : ["-z"]),
-        "-xf",
-        archivePath.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "-P",
-        "-C",
-        workingDirectory.replace(new RegExp("\\" + path.sep, "g"), "/")
-    ];
+    await io.mkdirP(targetDirectory);
+    const args = ["-xz", "-f", archivePath, "-C", targetDirectory];
     await execTar(args);
 }
 
 export async function createTar(
-    archiveFolder: string,
-    sourceDirectories: string[],
-    compressionMethod: CompressionMethod
+    archivePath: string,
+    sourceDirectory: string
 ): Promise<void> {
-    // Write source directories to manifest.txt to avoid command length limits
-    const manifestFilename = "manifest.txt";
-    const cacheFileName = utils.getCacheFileName(compressionMethod);
-    writeFileSync(
-        path.join(archiveFolder, manifestFilename),
-        sourceDirectories.join("\n")
-    );
-    // -T#: Compress using # working thread. If # is 0, attempt to detect and use the number of physical CPU cores.
-    // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
-    // Using 30 here because we also support 32-bit self-hosted runners.
-    const workingDirectory = getWorkingDirectory();
-    const args = [
-        ...(compressionMethod == CompressionMethod.Zstd
-            ? ["--use-compress-program", "zstd -T0 --long=30"]
-            : ["-z"]),
-        "-cf",
-        cacheFileName.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "-P",
-        "-C",
-        workingDirectory.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "--files-from",
-        manifestFilename
-    ];
-    await execTar(args, archiveFolder);
+    const args = ["-cz", "-f", archivePath, "-C", sourceDirectory, "."];
+    await execTar(args);
 }

src/utils/actionUtils.ts

@@ -1,20 +1,11 @@
 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 os from "os";
 import * as path from "path";
-import * as util from "util";
 import * as uuidV4 from "uuid/v4";
 
-import {
-    CacheFilename,
-    CompressionMethod,
-    Events,
-    Outputs,
-    State
-} from "../constants";
+import { Events, Outputs, State } from "../constants";
 import { ArtifactCacheEntry } from "../contracts";
 
 // From https://github.com/actions/toolkit/blob/master/packages/tool-cache/src/tool-cache.ts#L23
@@ -37,7 +28,6 @@ export async function createTempDirectory(): Promise<string> {
         }
         tempDirectory = path.join(baseLocation, "actions", "temp");
     }
-
     const dest = path.join(tempDirectory, uuidV4.default());
     await io.mkdirP(dest);
     return dest;
@@ -92,21 +82,16 @@ 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}`);
+export function resolvePath(filePath: string): string {
+    if (filePath[0] === "~") {
+        const home = os.homedir();
+        if (!home) {
+            throw new Error("Unable to resolve `~` to HOME");
+        }
+        return path.join(home, filePath.slice(1));
     }
 
-    return paths;
+    return path.resolve(filePath);
 }
 
 export function getSupportedEvents(): string[] {
@@ -120,53 +105,3 @@ export function isValidEvent(): boolean {
     const githubEvent = process.env[Events.Key] || "";
     return getSupportedEvents().includes(githubEvent);
 }
-
-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> {
-    // Disabling zstd on Windows due to https://github.com/actions/cache/issues/301
-    if (os.platform() === "win32") {
-        return CompressionMethod.Gzip;
-    }
-
-    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");
-}