Merge pull request #1162 from actions/rentziass/actions-core

Bump actions/core to 1.10.0
bump version to 1.2.0
2025-06-25 03:41:10 +02:00 · 2023-04-27 17:32:58 +01:00 · 2023-04-27 17:26:14 +01:00 · 2023-04-27 17:18:36 +01:00 · 2023-04-27 17:06:31 +01:00 · 2020-05-14 11:11:05 -04:00
25 changed files with 8546 additions and 94729 deletions
--- a/.eslintrc.json
+++ b/.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"]
 }
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@ -1,52 +0,0 @@
-name: "Code scanning - action"
-
-on:
-  push:
-  pull_request:
-  schedule:
-    - cron: '0 19 * * 0'
-
-jobs:
-  CodeQL-Build:
-
-    # CodeQL runs on ubuntu-latest and windows-latest
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-      with:
-        # We must fetch at least the immediate parents so that if this is
-        # a pull request then we can checkout the head.
-        fetch-depth: 2
-
-    # If this run was triggered by a pull request event, then checkout
-    # the head of the pull request instead of the merge commit.
-    - run: git checkout HEAD^2
-      if: ${{ github.event_name == 'pull_request' }}
-      
-    # 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
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@ -3,13 +3,13 @@ name: Tests
 on:
  pull_request:
    branches:
-      - main
+      - master
      - releases/**
    paths-ignore:
      - '**.md'
  push:
    branches:
-      - main
+      - master
      - releases/**
    paths-ignore:
      - '**.md'
@ -19,7 +19,7 @@ jobs:
  build:
    strategy:
      matrix:
-        os: [ubuntu-latest, ubuntu-16.04, windows-latest, macOS-latest]
+        os: [ubuntu-latest, windows-latest, macOS-latest]
      fail-fast: false
    runs-on: ${{ matrix.os }}
    steps:
@ -34,7 +34,7 @@ jobs:
      run: |
        echo "::set-output name=dir::$(npm config get cache)"
    - name: Restore npm cache
-      uses: actions/cache@v2
+      uses: actions/cache@v1
      with:
        path: ${{ steps.npm-cache.outputs.dir }}
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@ -47,46 +47,30 @@ jobs:
      run: npm run lint
    - name: Build & Test
      run: npm run test
-    - name: Ensure dist/ folder is up-to-date
-      if: ${{ runner.os == 'Linux' }}
-      shell: bash
-      run: |
-        npm run build
-        if [ "$(git diff --ignore-space-at-eol | wc -l)" -gt "0" ]; then
-          echo "Detected uncommitted changes after build.  See status below:"
-          git diff
-          exit 1
-        fi
-        

  # End to end save and restore
  test-save:
    strategy:
      matrix:
-        os: [ubuntu-latest, ubuntu-16.04, windows-latest, macOS-latest]
+        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
+    - name: Generate files
      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
+      run: __tests__/create-cache-files.sh ${{ runner.os }}
    - name: Save cache
      uses: ./
      with:
        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: |
-          test-cache
-          ~/test-cache
+        path: test-cache
  test-restore:
    needs: test-save
    strategy:
      matrix:
-        os: [ubuntu-latest, ubuntu-16.04, windows-latest, macOS-latest]
+        os: [ubuntu-latest, windows-latest, macOS-latest]
      fail-fast: false
    runs-on: ${{ matrix.os }}
    steps:
@ -96,15 +80,10 @@ jobs:
      uses: ./
      with:
        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: |
-          test-cache
-          ~/test-cache
-    - name: Verify cache files in working directory
+        path: test-cache
+    - name: Verify cache
      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
+      run: __tests__/verify-cache-files.sh ${{ runner.os }}

  # End to end with proxy
  test-proxy-save:
@ -114,7 +93,7 @@ jobs:
      options: --dns 127.0.0.1
    services:
      squid-proxy:
-        image: datadog/squid:latest
+        image: ubuntu/squid:latest
        ports:
          - 3128:3128
    env:
@ -123,7 +102,7 @@ jobs:
    - name: Checkout
      uses: actions/checkout@v2
    - name: Generate files
-      run: __tests__/create-cache-files.sh proxy test-cache
+      run: __tests__/create-cache-files.sh proxy
    - name: Save cache
      uses: ./
      with:
@ -137,7 +116,7 @@ jobs:
      options: --dns 127.0.0.1
    services:
      squid-proxy:
-        image: datadog/squid:latest
+        image: ubuntu/squid:latest
        ports:
          - 3128:3128
    env:
@ -151,4 +130,4 @@ jobs:
        key: test-proxy-${{ github.run_id }}
        path: test-cache
    - name: Verify cache
-      run: __tests__/verify-cache-files.sh proxy test-cache
+      run: __tests__/verify-cache-files.sh proxy
--- a/.gitignore
+++ b/.gitignore
@ -1,5 +1,8 @@
 __tests__/runner/*

+# comment out in distribution branches
+dist/
+
 node_modules/
 lib/

--- a/README.md
+++ b/README.md
@ -2,34 +2,12 @@

 This action allows caching dependencies and build outputs to improve workflow execution time.

-<a href="https://github.com/actions/cache/actions?query=workflow%3ATests"><img alt="GitHub Actions status" src="https://github.com/actions/cache/workflows/Tests/badge.svg?branch=main&event=push"></a>
+<a href="https://github.com/actions/cache/actions?query=workflow%3ATests"><img alt="GitHub Actions status" src="https://github.com/actions/cache/workflows/Tests/badge.svg?branch=master&event=push"></a>

 ## Documentation

 See ["Caching dependencies to speed up workflows"](https://help.github.com/github/automating-your-workflow-with-github-actions/caching-dependencies-to-speed-up-workflows).

-## What's New
-
-* Added support for multiple paths, [glob patterns](https://github.com/actions/toolkit/tree/main/packages/glob), and single file caches. 
-
-```yaml
- name: Cache multiple paths
-  uses: actions/cache@v2
-  with:
-    path: |
-      ~/cache
-      !~/cache/exclude
-      **/node_modules
-    key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
-```
-
-* Increased performance and improved cache sizes using `zstd` compression for Linux and macOS runners
-* Allowed caching for all events with a ref. See [events that trigger workflow](https://help.github.com/en/actions/reference/events-that-trigger-workflows) for info on which events do not have a `GITHUB_REF`
-* Released the [`@actions/cache`](https://github.com/actions/toolkit/tree/main/packages/cache) npm package to allow other actions to utilize caching
-* Added a best-effort cleanup step to delete the archive after extraction to reduce storage space
-
-Refer [here](https://github.com/actions/cache/blob/v1/README.md) for previous versions
-
 ## Usage

 ### Pre-requisites
@ -37,7 +15,7 @@ Create a workflow `.yml` file in your repositories `.github/workflows` directory

 ### Inputs

-* `path` - A list of files, directories, and wildcard patterns to cache and restore. See [`@actions/glob`](https://github.com/actions/toolkit/tree/main/packages/glob) for supported patterns. 
+* `path` - A directory to store and save the cache
 * `key` - An explicit key for restoring and saving the cache
 * `restore-keys` - An ordered list of keys to use for restoring the cache if no cache hit occurred for key

@ -47,11 +25,6 @@ Create a workflow `.yml` file in your repositories `.github/workflows` directory

 > See [Skipping steps based on cache-hit](#Skipping-steps-based-on-cache-hit) for info on using this output

-### Cache scopes
-The cache is scoped to the key and branch. The default branch cache is available to other branches. 
-
-See [Matching a cache key](https://help.github.com/en/actions/configuring-and-managing-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key) for more info.
-
 ### Example workflow

 ```yaml
@ -64,11 +37,11 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v1

    - name: Cache Primes
      id: cache-primes
-      uses: actions/cache@v2
+      uses: actions/cache@v1
      with:
        path: prime-numbers
        key: ${{ runner.os }}-primes
@ -88,16 +61,13 @@ Every programming language and framework has its own way of caching.
 See [Examples](examples.md) for a list of `actions/cache` implementations for use with:

 - [C# - Nuget](./examples.md#c---nuget)
- [D - DUB](./examples.md#d---dub)
 - [Elixir - Mix](./examples.md#elixir---mix)
 - [Go - Modules](./examples.md#go---modules)
 - [Haskell - Cabal](./examples.md#haskell---cabal)
 - [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)
@ -108,39 +78,6 @@ See [Examples](examples.md) for a list of `actions/cache` implementations for us
 - [Swift, Objective-C - CocoaPods](./examples.md#swift-objective-c---cocoapods)
 - [Swift - Swift Package Manager](./examples.md#swift---swift-package-manager)

-## Creating a cache key
-
-A cache key can include any of the contexts, functions, literals, and operators supported by GitHub Actions.
-
-For example, using the [`hashFiles`](https://help.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#hashfiles) function allows you to create a new cache when dependencies change.
-
-```yaml
-  - uses: actions/cache@v2
-    with:
-      path: | 
-        path/to/dependencies
-        some/other/dependencies 
-      key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
-```
-
-Additionally, you can use arbitrary command output in a cache key, such as a date or software version:
-
-```yaml
-  # http://man7.org/linux/man-pages/man1/date.1.html
-  - name: Get Date
-    id: get-date
-    run: |
-      echo "::set-output name=date::$(/bin/date -u "+%Y%m%d")"
-    shell: bash
-
-  - uses: actions/cache@v2
-    with:
-      path: path/to/dependencies
-      key: ${{ runner.os }}-${{ steps.get-date.outputs.date }}-${{ hashFiles('**/lockfiles') }}
-```
-
-See [Using contexts to create cache keys](https://help.github.com/en/actions/configuring-and-managing-workflows/caching-dependencies-to-speed-up-workflows#using-contexts-to-create-cache-keys)
-
 ## Cache Limits

 A repository can have up to 5GB of caches. Once the 5GB limit is reached, older caches will be evicted based on when the cache was last accessed.  Caches that are not accessed within the last week will also be evicted.
@ -152,9 +89,9 @@ 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@v2
+  - uses: actions/cache@v1
    id: cache
    with:
      path: path/to/dependencies
@ -168,7 +105,7 @@ steps:
 > Note: The `id` defined in `actions/cache` must match the `id` in the `if` statement (i.e. `steps.[ID].outputs.cache-hit`)

 ## Contributing
-We would love for you to contribute to `actions/cache`, pull requests are welcome! Please see the [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
+We would love for you to contribute to `@actions/cache`, pull requests are welcome! Please see the [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

 ## License
 The scripts and documentation in this project are released under the [MIT License](LICENSE)
--- a/tests/actionUtils.test.ts
+++ b/tests/actionUtils.test.ts
@ -1,72 +1,84 @@
 import * as core from "@actions/core";
+import * as os from "os";
+import * as path from "path";

-import { Events, Outputs, RefKey, State } from "../src/constants";
+import { Events, Outputs, State } from "../src/constants";
+import { ArtifactCacheEntry } from "../src/contracts";
 import * as actionUtils from "../src/utils/actionUtils";
-import * as testUtils from "../src/utils/testUtils";

 jest.mock("@actions/core");
-
-beforeAll(() => {
-    jest.spyOn(core, "getInput").mockImplementation((name, options) => {
-        return jest.requireActual("@actions/core").getInput(name, options);
-    });
-});
+jest.mock("os");

 afterEach(() => {
    delete process.env[Events.Key];
-    delete process.env[RefKey];
 });

-test("isExactKeyMatch with undefined cache key returns false", () => {
-    const key = "linux-rust";
-    const cacheKey = undefined;
+test("getArchiveFileSize returns file size", () => {
+    const filePath = path.join(__dirname, "__fixtures__", "helloWorld.txt");

-    expect(actionUtils.isExactKeyMatch(key, cacheKey)).toBe(false);
+    const size = actionUtils.getArchiveFileSize(filePath);
+
+    expect(size).toBe(11);
 });

-test("isExactKeyMatch with empty cache key returns false", () => {
+test("isExactKeyMatch with undefined cache entry returns false", () => {
    const key = "linux-rust";
-    const cacheKey = "";
+    const cacheEntry = undefined;

-    expect(actionUtils.isExactKeyMatch(key, cacheKey)).toBe(false);
+    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
+});
+
+test("isExactKeyMatch with empty cache entry returns false", () => {
+    const key = "linux-rust";
+    const cacheEntry: ArtifactCacheEntry = {};
+
+    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
 });

 test("isExactKeyMatch with different keys returns false", () => {
    const key = "linux-rust";
-    const cacheKey = "linux-";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "linux-"
+    };

-    expect(actionUtils.isExactKeyMatch(key, cacheKey)).toBe(false);
+    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
 });

 test("isExactKeyMatch with different key accents returns false", () => {
    const key = "linux-áccent";
-    const cacheKey = "linux-accent";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "linux-accent"
+    };

-    expect(actionUtils.isExactKeyMatch(key, cacheKey)).toBe(false);
+    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(false);
 });

 test("isExactKeyMatch with same key returns true", () => {
    const key = "linux-rust";
-    const cacheKey = "linux-rust";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "linux-rust"
+    };

-    expect(actionUtils.isExactKeyMatch(key, cacheKey)).toBe(true);
+    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(true);
 });

 test("isExactKeyMatch with same key and different casing returns true", () => {
    const key = "linux-rust";
-    const cacheKey = "LINUX-RUST";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "LINUX-RUST"
+    };

-    expect(actionUtils.isExactKeyMatch(key, cacheKey)).toBe(true);
+    expect(actionUtils.isExactKeyMatch(key, cacheEntry)).toBe(true);
 });

 test("setOutputAndState with undefined entry to set cache-hit output", () => {
    const key = "linux-rust";
-    const cacheKey = undefined;
+    const cacheEntry = undefined;

    const setOutputMock = jest.spyOn(core, "setOutput");
    const saveStateMock = jest.spyOn(core, "saveState");

-    actionUtils.setOutputAndState(key, cacheKey);
+    actionUtils.setOutputAndState(key, cacheEntry);

    expect(setOutputMock).toHaveBeenCalledWith(Outputs.CacheHit, "false");
    expect(setOutputMock).toHaveBeenCalledTimes(1);
@ -76,33 +88,43 @@ test("setOutputAndState with undefined entry to set cache-hit output", () => {

 test("setOutputAndState with exact match to set cache-hit output and state", () => {
    const key = "linux-rust";
-    const cacheKey = "linux-rust";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "linux-rust"
+    };

    const setOutputMock = jest.spyOn(core, "setOutput");
    const saveStateMock = jest.spyOn(core, "saveState");

-    actionUtils.setOutputAndState(key, cacheKey);
+    actionUtils.setOutputAndState(key, cacheEntry);

    expect(setOutputMock).toHaveBeenCalledWith(Outputs.CacheHit, "true");
    expect(setOutputMock).toHaveBeenCalledTimes(1);

-    expect(saveStateMock).toHaveBeenCalledWith(State.CacheMatchedKey, cacheKey);
+    expect(saveStateMock).toHaveBeenCalledWith(
+        State.CacheResult,
+        JSON.stringify(cacheEntry)
+    );
    expect(saveStateMock).toHaveBeenCalledTimes(1);
 });

 test("setOutputAndState with no exact match to set cache-hit output and state", () => {
    const key = "linux-rust";
-    const cacheKey = "linux-rust-bb828da54c148048dd17899ba9fda624811cfb43";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "linux-rust-bb828da54c148048dd17899ba9fda624811cfb43"
+    };

    const setOutputMock = jest.spyOn(core, "setOutput");
    const saveStateMock = jest.spyOn(core, "saveState");

-    actionUtils.setOutputAndState(key, cacheKey);
+    actionUtils.setOutputAndState(key, cacheEntry);

    expect(setOutputMock).toHaveBeenCalledWith(Outputs.CacheHit, "false");
    expect(setOutputMock).toHaveBeenCalledTimes(1);

-    expect(saveStateMock).toHaveBeenCalledWith(State.CacheMatchedKey, cacheKey);
+    expect(saveStateMock).toHaveBeenCalledWith(
+        State.CacheResult,
+        JSON.stringify(cacheEntry)
+    );
    expect(saveStateMock).toHaveBeenCalledTimes(1);
 });

@ -116,23 +138,27 @@ test("getCacheState with no state returns undefined", () => {

    expect(state).toBe(undefined);

-    expect(getStateMock).toHaveBeenCalledWith(State.CacheMatchedKey);
+    expect(getStateMock).toHaveBeenCalledWith(State.CacheResult);
    expect(getStateMock).toHaveBeenCalledTimes(1);
 });

 test("getCacheState with valid state", () => {
-    const cacheKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43",
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };
    const getStateMock = jest.spyOn(core, "getState");
    getStateMock.mockImplementation(() => {
-        return cacheKey;
+        return JSON.stringify(cacheEntry);
    });

    const state = actionUtils.getCacheState();

-    expect(state).toEqual(cacheKey);
+    expect(state).toEqual(cacheEntry);

-    expect(getStateMock).toHaveBeenCalledWith(State.CacheMatchedKey);
+    expect(getStateMock).toHaveBeenCalledWith(State.CacheResult);
    expect(getStateMock).toHaveBeenCalledTimes(1);
 });

@ -146,7 +172,7 @@ test("logWarning logs a message with a warning prefix", () => {
    expect(infoMock).toHaveBeenCalledWith(`[warning]${message}`);
 });

-test("isValidEvent returns false for event that does not have a branch or tag", () => {
+test("isValidEvent returns false for unknown event", () => {
    const event = "foo";
    process.env[Events.Key] = event;

@ -155,42 +181,56 @@ test("isValidEvent returns false for event that does not have a branch or tag",
    expect(isValidEvent).toBe(false);
 });

-test("isValidEvent returns true for event that has a ref", () => {
+test("resolvePath with no ~ in path", () => {
+    const filePath = ".cache/yarn";
+
+    const resolvedPath = actionUtils.resolvePath(filePath);
+
+    const expectedPath = path.resolve(filePath);
+    expect(resolvedPath).toBe(expectedPath);
+});
+
+test("resolvePath with ~ in path", () => {
+    const filePath = "~/.cache/yarn";
+
+    const homedir = jest.requireActual("os").homedir();
+    const homedirMock = jest.spyOn(os, "homedir");
+    homedirMock.mockImplementation(() => {
+        return homedir;
+    });
+
+    const resolvedPath = actionUtils.resolvePath(filePath);
+
+    const expectedPath = path.join(homedir, ".cache/yarn");
+    expect(resolvedPath).toBe(expectedPath);
+});
+
+test("resolvePath with home not found", () => {
+    const filePath = "~/.cache/yarn";
+    const homedirMock = jest.spyOn(os, "homedir");
+    homedirMock.mockImplementation(() => {
+        return "";
+    });
+
+    expect(() => actionUtils.resolvePath(filePath)).toThrow(
+        "Unable to resolve `~` to HOME"
+    );
+});
+
+test("isValidEvent returns true for push event", () => {
    const event = Events.Push;
    process.env[Events.Key] = event;
-    process.env[RefKey] = "ref/heads/feature";

    const isValidEvent = actionUtils.isValidEvent();

    expect(isValidEvent).toBe(true);
 });

-test("getInputAsArray returns empty array if not required and missing", () => {
-    expect(actionUtils.getInputAsArray("foo")).toEqual([]);
-});
+test("isValidEvent returns true for pull request event", () => {
+    const event = Events.PullRequest;
+    process.env[Events.Key] = event;

-test("getInputAsArray throws error if required and missing", () => {
-    expect(() =>
-        actionUtils.getInputAsArray("foo", { required: true })
-    ).toThrowError();
-});
+    const isValidEvent = actionUtils.isValidEvent();

-test("getInputAsArray handles single line correctly", () => {
-    testUtils.setInput("foo", "bar");
-    expect(actionUtils.getInputAsArray("foo")).toEqual(["bar"]);
-});
-
-test("getInputAsArray handles multiple lines correctly", () => {
-    testUtils.setInput("foo", "bar\nbaz");
-    expect(actionUtils.getInputAsArray("foo")).toEqual(["bar", "baz"]);
-});
-
-test("getInputAsArray handles different new lines correctly", () => {
-    testUtils.setInput("foo", "bar\r\nbaz");
-    expect(actionUtils.getInputAsArray("foo")).toEqual(["bar", "baz"]);
-});
-
-test("getInputAsArray handles empty lines correctly", () => {
-    testUtils.setInput("foo", "\n\nbar\n\nbaz\n\n");
-    expect(actionUtils.getInputAsArray("foo")).toEqual(["bar", "baz"]);
+    expect(isValidEvent).toBe(true);
 });
--- a/tests/cacheHttpsClient.test.ts
+++ b/tests/cacheHttpsClient.test.ts
@ -0,0 +1,144 @@
+import { retry } from "../src/cacheHttpClient";
+import * as testUtils from "../src/utils/testUtils";
+
+afterEach(() => {
+    testUtils.clearInputs();
+});
+
+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
+    );
+});
--- a/tests/create-cache-files.sh
+++ b/tests/create-cache-files.sh
@ -7,11 +7,5 @@ if [ -z "$prefix" ]; then
  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
+mkdir test-cache
+echo "$prefix $GITHUB_RUN_ID" > test-cache/test-file.txt
--- a/tests/restore.test.ts
+++ b/tests/restore.test.ts
@ -1,14 +1,22 @@
-import * as cache from "@actions/cache";
 import * as core from "@actions/core";
-
-import { Events, Inputs, RefKey } from "../src/constants";
+import * as path from "path";
+import * as cacheHttpClient from "../src/cacheHttpClient";
+import { Events, Inputs } from "../src/constants";
+import { ArtifactCacheEntry } from "../src/contracts";
 import run from "../src/restore";
+import * as tar from "../src/tar";
 import * as actionUtils from "../src/utils/actionUtils";
 import * as testUtils from "../src/utils/testUtils";

+jest.mock("../src/cacheHttpClient");
+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");
@ -21,23 +29,19 @@ beforeAll(() => {
        return actualUtils.isValidEvent();
    });

-    jest.spyOn(actionUtils, "getInputAsArray").mockImplementation(
-        (name, options) => {
-            const actualUtils = jest.requireActual("../src/utils/actionUtils");
-            return actualUtils.getInputAsArray(name, options);
-        }
-    );
+    jest.spyOn(actionUtils, "getSupportedEvents").mockImplementation(() => {
+        const actualUtils = jest.requireActual("../src/utils/actionUtils");
+        return actualUtils.getSupportedEvents();
+    });
 });

 beforeEach(() => {
    process.env[Events.Key] = Events.Push;
-    process.env[RefKey] = "refs/heads/feature-branch";
 });

 afterEach(() => {
    testUtils.clearInputs();
    delete process.env[Events.Key];
-    delete process.env[RefKey];
 });

 test("restore with invalid event outputs warning", async () => {
@ -45,21 +49,17 @@ test("restore with invalid event outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");
    const invalidEvent = "commit_comment";
    process.env[Events.Key] = invalidEvent;
-    delete process.env[RefKey];
    await run();
    expect(logWarningMock).toHaveBeenCalledWith(
-        `Event Validation Error: The event type ${invalidEvent} is not supported because it's not tied to a branch or tag ref.`
+        `Event Validation Error: The event type ${invalidEvent} is not supported. Only push, pull_request events are supported at this time.`
    );
    expect(failedMock).toHaveBeenCalledTimes(0);
 });

 test("restore with no path should fail", async () => {
    const failedMock = jest.spyOn(core, "setFailed");
-    const restoreCacheMock = jest.spyOn(cache, "restoreCache");
    await run();
-    expect(restoreCacheMock).toHaveBeenCalledTimes(0);
-    // 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"
    );
 });
@ -67,120 +67,99 @@ test("restore with no path should fail", async () => {
 test("restore with no key", async () => {
    testUtils.setInput(Inputs.Path, "node_modules");
    const failedMock = jest.spyOn(core, "setFailed");
-    const restoreCacheMock = jest.spyOn(cache, "restoreCache");
    await run();
-    expect(restoreCacheMock).toHaveBeenCalledTimes(0);
    expect(failedMock).toHaveBeenCalledWith(
        "Input required and not supplied: key"
    );
 });

 test("restore with too many keys should fail", async () => {
-    const path = "node_modules";
    const key = "node-test";
    const restoreKeys = [...Array(20).keys()].map(x => x.toString());
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key,
        restoreKeys
    });
    const failedMock = jest.spyOn(core, "setFailed");
-    const restoreCacheMock = jest.spyOn(cache, "restoreCache");
    await run();
-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, restoreKeys);
    expect(failedMock).toHaveBeenCalledWith(
        `Key Validation Error: Keys are limited to a maximum of 10.`
    );
 });

 test("restore with large key should fail", async () => {
-    const path = "node_modules";
    const key = "foo".repeat(512); // Over the 512 character limit
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key
    });
    const failedMock = jest.spyOn(core, "setFailed");
-    const restoreCacheMock = jest.spyOn(cache, "restoreCache");
    await run();
-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, []);
    expect(failedMock).toHaveBeenCalledWith(
        `Key Validation Error: ${key} cannot be larger than 512 characters.`
    );
 });

 test("restore with invalid key should fail", async () => {
-    const path = "node_modules";
    const key = "comma,comma";
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key
    });
    const failedMock = jest.spyOn(core, "setFailed");
-    const restoreCacheMock = jest.spyOn(cache, "restoreCache");
    await run();
-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, []);
    expect(failedMock).toHaveBeenCalledWith(
        `Key Validation Error: ${key} cannot contain commas.`
    );
 });

 test("restore with no cache found", async () => {
-    const path = "node_modules";
    const key = "node-test";
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key
    });

    const infoMock = jest.spyOn(core, "info");
    const failedMock = jest.spyOn(core, "setFailed");
    const stateMock = jest.spyOn(core, "saveState");
-    const restoreCacheMock = jest
-        .spyOn(cache, "restoreCache")
-        .mockImplementationOnce(() => {
-            return Promise.resolve(undefined);
-        });
+
+    const clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
+    clientMock.mockImplementation(() => {
+        return Promise.resolve(null);
+    });

    await run();

-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, []);
-
    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
    expect(failedMock).toHaveBeenCalledTimes(0);

    expect(infoMock).toHaveBeenCalledWith(
-        `Cache not found for input keys: ${key}`
+        `Cache not found for input keys: ${key}.`
    );
 });

 test("restore with server error should fail", async () => {
-    const path = "node_modules";
    const key = "node-test";
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key
    });

    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
    const failedMock = jest.spyOn(core, "setFailed");
    const stateMock = jest.spyOn(core, "saveState");
-    const restoreCacheMock = jest
-        .spyOn(cache, "restoreCache")
-        .mockImplementationOnce(() => {
-            throw new Error("HTTP Error Occurred");
-        });
+
+    const clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
+    clientMock.mockImplementation(() => {
+        throw new Error("HTTP Error Occurred");
+    });
+
    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");

    await run();

-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, []);
-
    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);

    expect(logWarningMock).toHaveBeenCalledTimes(1);
@ -193,11 +172,10 @@ test("restore with server error should fail", async () => {
 });

 test("restore with restore keys and no cache found", async () => {
-    const path = "node_modules";
    const key = "node-test";
    const restoreKey = "node-";
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key,
        restoreKeys: [restoreKey]
    });
@ -205,49 +183,148 @@ test("restore with restore keys and no cache found", async () => {
    const infoMock = jest.spyOn(core, "info");
    const failedMock = jest.spyOn(core, "setFailed");
    const stateMock = jest.spyOn(core, "saveState");
-    const restoreCacheMock = jest
-        .spyOn(cache, "restoreCache")
-        .mockImplementationOnce(() => {
-            return Promise.resolve(undefined);
-        });
+
+    const clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
+    clientMock.mockImplementation(() => {
+        return Promise.resolve(null);
+    });

    await run();

-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, [restoreKey]);
-
    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
    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 cache found for key", async () => {
-    const path = "node_modules";
+test("restore with cache found", async () => {
    const key = "node-test";
+    const cachePath = path.resolve("node_modules");
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key
    });

    const infoMock = jest.spyOn(core, "info");
    const failedMock = jest.spyOn(core, "setFailed");
    const stateMock = jest.spyOn(core, "saveState");
+
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: key,
+        scope: "refs/heads/master",
+        archiveLocation: "www.actionscache.test/download"
+    };
+    const getCacheMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
+    getCacheMock.mockImplementation(() => {
+        return Promise.resolve(cacheEntry);
+    });
+    const tempPath = "/foo/bar";
+
+    const createTempDirectoryMock = jest.spyOn(
+        actionUtils,
+        "createTempDirectory"
+    );
+    createTempDirectoryMock.mockImplementation(() => {
+        return Promise.resolve(tempPath);
+    });
+
+    const archivePath = path.join(tempPath, "cache.tgz");
+    const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
+    const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
+
+    const fileSize = 142;
+    const getArchiveFileSizeMock = jest
+        .spyOn(actionUtils, "getArchiveFileSize")
+        .mockReturnValue(fileSize);
+
+    const extractTarMock = jest.spyOn(tar, "extractTar");
    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-    const restoreCacheMock = jest
-        .spyOn(cache, "restoreCache")
-        .mockImplementationOnce(() => {
-            return Promise.resolve(key);
-        });

    await run();

-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, []);
+    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
+    expect(getCacheMock).toHaveBeenCalledWith([key]);
+    expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
+    expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
+    expect(downloadCacheMock).toHaveBeenCalledWith(
+        cacheEntry.archiveLocation,
+        archivePath
+    );
+    expect(getArchiveFileSizeMock).toHaveBeenCalledWith(archivePath);
+
+    expect(extractTarMock).toHaveBeenCalledTimes(1);
+    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);
+});
+
+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
+    });
+
+    process.env[Events.Key] = Events.PullRequest;
+
+    const infoMock = jest.spyOn(core, "info");
+    const failedMock = jest.spyOn(core, "setFailed");
+    const stateMock = jest.spyOn(core, "saveState");
+
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: key,
+        scope: "refs/heads/master",
+        archiveLocation: "www.actionscache.test/download"
+    };
+    const getCacheMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
+    getCacheMock.mockImplementation(() => {
+        return Promise.resolve(cacheEntry);
+    });
+    const tempPath = "/foo/bar";
+
+    const createTempDirectoryMock = jest.spyOn(
+        actionUtils,
+        "createTempDirectory"
+    );
+    createTempDirectoryMock.mockImplementation(() => {
+        return Promise.resolve(tempPath);
+    });
+
+    const archivePath = path.join(tempPath, "cache.tgz");
+    const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
+    const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
+
+    const fileSize = 62915000;
+    const getArchiveFileSizeMock = jest
+        .spyOn(actionUtils, "getArchiveFileSize")
+        .mockReturnValue(fileSize);
+
+    const extractTarMock = jest.spyOn(tar, "extractTar");
+    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
+
+    await run();

    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
+    expect(getCacheMock).toHaveBeenCalledWith([key]);
+    expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
+    expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
+    expect(downloadCacheMock).toHaveBeenCalledWith(
+        cacheEntry.archiveLocation,
+        archivePath
+    );
+    expect(getArchiveFileSizeMock).toHaveBeenCalledWith(archivePath);
+    expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~60 MB (62915000 B)`);
+
+    expect(extractTarMock).toHaveBeenCalledTimes(1);
+    expect(extractTarMock).toHaveBeenCalledWith(archivePath, cachePath);
+
    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
    expect(setCacheHitOutputMock).toHaveBeenCalledWith(true);

@ -256,11 +333,11 @@ test("restore with cache found for key", async () => {
 });

 test("restore with cache found for restore key", async () => {
-    const path = "node_modules";
    const key = "node-test";
    const restoreKey = "node-";
+    const cachePath = path.resolve("node_modules");
    testUtils.setInputs({
-        path: path,
+        path: "node_modules",
        key,
        restoreKeys: [restoreKey]
    });
@ -268,19 +345,54 @@ test("restore with cache found for restore key", async () => {
    const infoMock = jest.spyOn(core, "info");
    const failedMock = jest.spyOn(core, "setFailed");
    const stateMock = jest.spyOn(core, "saveState");
+
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: restoreKey,
+        scope: "refs/heads/master",
+        archiveLocation: "www.actionscache.test/download"
+    };
+    const getCacheMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
+    getCacheMock.mockImplementation(() => {
+        return Promise.resolve(cacheEntry);
+    });
+    const tempPath = "/foo/bar";
+
+    const createTempDirectoryMock = jest.spyOn(
+        actionUtils,
+        "createTempDirectory"
+    );
+    createTempDirectoryMock.mockImplementation(() => {
+        return Promise.resolve(tempPath);
+    });
+
+    const archivePath = path.join(tempPath, "cache.tgz");
+    const setCacheStateMock = jest.spyOn(actionUtils, "setCacheState");
+    const downloadCacheMock = jest.spyOn(cacheHttpClient, "downloadCache");
+
+    const fileSize = 142;
+    const getArchiveFileSizeMock = jest
+        .spyOn(actionUtils, "getArchiveFileSize")
+        .mockReturnValue(fileSize);
+
+    const extractTarMock = jest.spyOn(tar, "extractTar");
    const setCacheHitOutputMock = jest.spyOn(actionUtils, "setCacheHitOutput");
-    const restoreCacheMock = jest
-        .spyOn(cache, "restoreCache")
-        .mockImplementationOnce(() => {
-            return Promise.resolve(restoreKey);
-        });

    await run();

-    expect(restoreCacheMock).toHaveBeenCalledTimes(1);
-    expect(restoreCacheMock).toHaveBeenCalledWith([path], key, [restoreKey]);
-
    expect(stateMock).toHaveBeenCalledWith("CACHE_KEY", key);
+    expect(getCacheMock).toHaveBeenCalledWith([key, restoreKey]);
+    expect(setCacheStateMock).toHaveBeenCalledWith(cacheEntry);
+    expect(createTempDirectoryMock).toHaveBeenCalledTimes(1);
+    expect(downloadCacheMock).toHaveBeenCalledWith(
+        cacheEntry.archiveLocation,
+        archivePath
+    );
+    expect(getArchiveFileSizeMock).toHaveBeenCalledWith(archivePath);
+    expect(infoMock).toHaveBeenCalledWith(`Cache Size: ~0 MB (142 B)`);
+
+    expect(extractTarMock).toHaveBeenCalledTimes(1);
+    expect(extractTarMock).toHaveBeenCalledWith(archivePath, cachePath);
+
    expect(setCacheHitOutputMock).toHaveBeenCalledTimes(1);
    expect(setCacheHitOutputMock).toHaveBeenCalledWith(false);

--- a/tests/save.test.ts
+++ b/tests/save.test.ts
@ -1,13 +1,16 @@
-import * as cache from "@actions/cache";
 import * as core from "@actions/core";
-
-import { Events, Inputs, RefKey } from "../src/constants";
+import * as path from "path";
+import * as cacheHttpClient from "../src/cacheHttpClient";
+import { Events, Inputs } from "../src/constants";
+import { ArtifactCacheEntry } from "../src/contracts";
 import run from "../src/save";
+import * as tar from "../src/tar";
 import * as actionUtils from "../src/utils/actionUtils";
 import * as testUtils from "../src/utils/testUtils";

 jest.mock("@actions/core");
-jest.mock("@actions/cache");
+jest.mock("../src/cacheHttpClient");
+jest.mock("../src/tar");
 jest.mock("../src/utils/actionUtils");

 beforeAll(() => {
@ -19,14 +22,6 @@ beforeAll(() => {
        return jest.requireActual("../src/utils/actionUtils").getCacheState();
    });

-    jest.spyOn(actionUtils, "getInputAsArray").mockImplementation(
-        (name, options) => {
-            return jest
-                .requireActual("../src/utils/actionUtils")
-                .getInputAsArray(name, options);
-        }
-    );
-
    jest.spyOn(actionUtils, "isExactKeyMatch").mockImplementation(
        (key, cacheResult) => {
            return jest
@ -39,17 +34,28 @@ beforeAll(() => {
        const actualUtils = jest.requireActual("../src/utils/actionUtils");
        return actualUtils.isValidEvent();
    });
+
+    jest.spyOn(actionUtils, "getSupportedEvents").mockImplementation(() => {
+        const actualUtils = jest.requireActual("../src/utils/actionUtils");
+        return actualUtils.getSupportedEvents();
+    });
+
+    jest.spyOn(actionUtils, "resolvePath").mockImplementation(filePath => {
+        return path.resolve(filePath);
+    });
+
+    jest.spyOn(actionUtils, "createTempDirectory").mockImplementation(() => {
+        return Promise.resolve("/foo/bar");
+    });
 });

 beforeEach(() => {
    process.env[Events.Key] = Events.Push;
-    process.env[RefKey] = "refs/heads/feature-branch";
 });

 afterEach(() => {
    testUtils.clearInputs();
    delete process.env[Events.Key];
-    delete process.env[RefKey];
 });

 test("save with invalid event outputs warning", async () => {
@ -57,10 +63,9 @@ test("save with invalid event outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");
    const invalidEvent = "commit_comment";
    process.env[Events.Key] = invalidEvent;
-    delete process.env[RefKey];
    await run();
    expect(logWarningMock).toHaveBeenCalledWith(
-        `Event Validation Error: The event type ${invalidEvent} is not supported because it's not tied to a branch or tag ref.`
+        `Event Validation Error: The event type ${invalidEvent} is not supported. Only push, pull_request events are supported at this time.`
    );
    expect(failedMock).toHaveBeenCalledTimes(0);
 });
@ -69,21 +74,25 @@ test("save with no primary key in state outputs warning", async () => {
    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
    const failedMock = jest.spyOn(core, "setFailed");

-    const savedCacheKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43",
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };
+
    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return savedCacheKey;
+            return JSON.stringify(cacheEntry);
        })
        // Cache Key State
        .mockImplementationOnce(() => {
            return "";
        });
-    const saveCacheMock = jest.spyOn(cache, "saveCache");

    await run();

-    expect(saveCacheMock).toHaveBeenCalledTimes(0);
    expect(logWarningMock).toHaveBeenCalledWith(
        `Error retrieving key from state.`
    );
@ -96,25 +105,33 @@ test("save with exact match returns early", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const savedCacheKey = primaryKey;
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: primaryKey,
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };

    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return savedCacheKey;
+            return JSON.stringify(cacheEntry);
        })
        // Cache Key State
        .mockImplementationOnce(() => {
            return primaryKey;
        });
-    const saveCacheMock = jest.spyOn(cache, "saveCache");
+
+    const createTarMock = jest.spyOn(tar, "createTar");

    await run();

-    expect(saveCacheMock).toHaveBeenCalledTimes(0);
    expect(infoMock).toHaveBeenCalledWith(
        `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
    );
+
+    expect(createTarMock).toHaveBeenCalledTimes(0);
+
    expect(failedMock).toHaveBeenCalledTimes(0);
 });

@ -123,22 +140,25 @@ test("save with missing input outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const savedCacheKey = "Linux-node-";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "Linux-node-",
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };

    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return savedCacheKey;
+            return JSON.stringify(cacheEntry);
        })
        // Cache Key State
        .mockImplementationOnce(() => {
            return primaryKey;
        });
-    const saveCacheMock = jest.spyOn(cache, "saveCache");

    await run();

-    expect(saveCacheMock).toHaveBeenCalledTimes(0);
    expect(logWarningMock).toHaveBeenCalledWith(
        "Input required and not supplied: path"
    );
@ -151,12 +171,17 @@ test("save with large cache outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const savedCacheKey = "Linux-node-";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "Linux-node-",
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };

    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return savedCacheKey;
+            return JSON.stringify(cacheEntry);
        })
        // Cache Key State
        .mockImplementationOnce(() => {
@ -164,25 +189,28 @@ test("save with large cache outputs warning", async () => {
        });

    const inputPath = "node_modules";
+    const cachePath = path.resolve(inputPath);
    testUtils.setInput(Inputs.Path, inputPath);

-    const saveCacheMock = jest
-        .spyOn(cache, "saveCache")
-        .mockImplementationOnce(() => {
-            throw new Error(
-                "Cache size of ~6144 MB (6442450944 B) is over the 5GB limit, not saving cache."
-            );
-        });
+    const createTarMock = jest.spyOn(tar, "createTar");
+
+    const cacheSize = 6 * 1024 * 1024 * 1024; //~6GB, over the 5GB limit
+    jest.spyOn(actionUtils, "getArchiveFileSize").mockImplementationOnce(() => {
+        return cacheSize;
+    });

    await run();

-    expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith([inputPath], primaryKey);
+    const archivePath = path.join("/foo/bar", "cache.tgz");
+
+    expect(createTarMock).toHaveBeenCalledTimes(1);
+    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);
 });

@ -192,12 +220,17 @@ test("save with reserve cache failure outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const savedCacheKey = "Linux-node-";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "Linux-node-",
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };

    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return savedCacheKey;
+            return JSON.stringify(cacheEntry);
        })
        // Cache Key State
        .mockImplementationOnce(() => {
@ -207,24 +240,27 @@ test("save with reserve cache failure outputs warning", async () => {
    const inputPath = "node_modules";
    testUtils.setInput(Inputs.Path, inputPath);

-    const saveCacheMock = jest
-        .spyOn(cache, "saveCache")
+    const reserveCacheMock = jest
+        .spyOn(cacheHttpClient, "reserveCache")
        .mockImplementationOnce(() => {
-            const actualCache = jest.requireActual("@actions/cache");
-            const error = new actualCache.ReserveCacheError(
-                `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
-            );
-            throw error;
+            return Promise.resolve(-1);
        });

+    const createTarMock = jest.spyOn(tar, "createTar");
+
+    const saveCacheMock = jest.spyOn(cacheHttpClient, "saveCache");
+
    await run();

-    expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith([inputPath], primaryKey);
+    expect(reserveCacheMock).toHaveBeenCalledTimes(1);
+    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey);

    expect(infoMock).toHaveBeenCalledWith(
        `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
    );
+
+    expect(createTarMock).toHaveBeenCalledTimes(0);
+    expect(saveCacheMock).toHaveBeenCalledTimes(0);
    expect(logWarningMock).toHaveBeenCalledTimes(0);
    expect(failedMock).toHaveBeenCalledTimes(0);
 });
@ -234,12 +270,17 @@ test("save with server error outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const savedCacheKey = "Linux-node-";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "Linux-node-",
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };

    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return savedCacheKey;
+            return JSON.stringify(cacheEntry);
        })
        // Cache Key State
        .mockImplementationOnce(() => {
@ -247,18 +288,36 @@ test("save with server error outputs warning", async () => {
        });

    const inputPath = "node_modules";
+    const cachePath = path.resolve(inputPath);
    testUtils.setInput(Inputs.Path, inputPath);

+    const cacheId = 4;
+    const reserveCacheMock = jest
+        .spyOn(cacheHttpClient, "reserveCache")
+        .mockImplementationOnce(() => {
+            return Promise.resolve(cacheId);
+        });
+
+    const createTarMock = jest.spyOn(tar, "createTar");
+
    const saveCacheMock = jest
-        .spyOn(cache, "saveCache")
+        .spyOn(cacheHttpClient, "saveCache")
        .mockImplementationOnce(() => {
            throw new Error("HTTP Error Occurred");
        });

    await run();

+    expect(reserveCacheMock).toHaveBeenCalledTimes(1);
+    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey);
+
+    const archivePath = path.join("/foo/bar", "cache.tgz");
+
+    expect(createTarMock).toHaveBeenCalledTimes(1);
+    expect(createTarMock).toHaveBeenCalledWith(archivePath, cachePath);
+
    expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith([inputPath], primaryKey);
+    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archivePath);

    expect(logWarningMock).toHaveBeenCalledTimes(1);
    expect(logWarningMock).toHaveBeenCalledWith("HTTP Error Occurred");
@ -270,12 +329,17 @@ test("save with valid inputs uploads a cache", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
-    const savedCacheKey = "Linux-node-";
+    const cacheEntry: ArtifactCacheEntry = {
+        cacheKey: "Linux-node-",
+        scope: "refs/heads/master",
+        creationTime: "2019-11-13T19:18:02+00:00",
+        archiveLocation: "www.actionscache.test/download"
+    };

    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return savedCacheKey;
+            return JSON.stringify(cacheEntry);
        })
        // Cache Key State
        .mockImplementationOnce(() => {
@ -283,19 +347,32 @@ test("save with valid inputs uploads a cache", async () => {
        });

    const inputPath = "node_modules";
+    const cachePath = path.resolve(inputPath);
    testUtils.setInput(Inputs.Path, inputPath);

    const cacheId = 4;
-    const saveCacheMock = jest
-        .spyOn(cache, "saveCache")
+    const reserveCacheMock = jest
+        .spyOn(cacheHttpClient, "reserveCache")
        .mockImplementationOnce(() => {
            return Promise.resolve(cacheId);
        });

+    const createTarMock = jest.spyOn(tar, "createTar");
+
+    const saveCacheMock = jest.spyOn(cacheHttpClient, "saveCache");
+
    await run();

+    expect(reserveCacheMock).toHaveBeenCalledTimes(1);
+    expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey);
+
+    const archivePath = path.join("/foo/bar", "cache.tgz");
+
+    expect(createTarMock).toHaveBeenCalledTimes(1);
+    expect(createTarMock).toHaveBeenCalledWith(archivePath, cachePath);
+
    expect(saveCacheMock).toHaveBeenCalledTimes(1);
-    expect(saveCacheMock).toHaveBeenCalledWith([inputPath], primaryKey);
+    expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archivePath);

    expect(failedMock).toHaveBeenCalledTimes(0);
 });
--- a/tests/tar.test.ts
+++ b/tests/tar.test.ts
@ -0,0 +1,86 @@
+import * as exec from "@actions/exec";
+import * as io from "@actions/io";
+import * as tar from "../src/tar";
+
+import fs = require("fs");
+
+jest.mock("@actions/exec");
+jest.mock("@actions/io");
+
+beforeAll(() => {
+    jest.spyOn(io, "which").mockImplementation(tool => {
+        return Promise.resolve(tool);
+    });
+});
+
+test("extract BSD tar", async () => {
+    const mkdirMock = jest.spyOn(io, "mkdirP");
+    const execMock = jest.spyOn(exec, "exec");
+
+    const IS_WINDOWS = process.platform === "win32";
+    const archivePath = IS_WINDOWS
+        ? `${process.env["windir"]}\\fakepath\\cache.tar`
+        : "cache.tar";
+    const targetDirectory = "~/.npm/cache";
+    await tar.extractTar(archivePath, targetDirectory);
+
+    expect(mkdirMock).toHaveBeenCalledWith(targetDirectory);
+
+    const tarPath = IS_WINDOWS
+        ? `${process.env["windir"]}\\System32\\tar.exe`
+        : "tar";
+    expect(execMock).toHaveBeenCalledTimes(1);
+    expect(execMock).toHaveBeenCalledWith(`"${tarPath}"`, [
+        "-xz",
+        "-f",
+        IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
+        "-C",
+        IS_WINDOWS ? targetDirectory?.replace(/\\/g, "/") : targetDirectory
+    ]);
+});
+
+test("extract GNU tar", async () => {
+    const IS_WINDOWS = process.platform === "win32";
+    if (IS_WINDOWS) {
+        jest.spyOn(fs, "existsSync").mockReturnValueOnce(false);
+        jest.spyOn(tar, "isGnuTar").mockReturnValue(Promise.resolve(true));
+
+        const execMock = jest.spyOn(exec, "exec");
+        const archivePath = `${process.env["windir"]}\\fakepath\\cache.tar`;
+        const targetDirectory = "~/.npm/cache";
+
+        await tar.extractTar(archivePath, targetDirectory);
+
+        expect(execMock).toHaveBeenCalledTimes(1);
+        expect(execMock).toHaveBeenLastCalledWith(`"tar"`, [
+            "-xz",
+            "-f",
+            archivePath.replace(/\\/g, "/"),
+            "-C",
+            targetDirectory?.replace(/\\/g, "/"),
+            "--force-local"
+        ]);
+    }
+});
+
+test("create BSD tar", async () => {
+    const execMock = jest.spyOn(exec, "exec");
+
+    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}"`, [
+        "-cz",
+        "-f",
+        IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
+        "-C",
+        IS_WINDOWS ? sourceDirectory?.replace(/\\/g, "/") : sourceDirectory,
+        "."
+    ]);
+});
--- a/tests/verify-cache-files.sh
+++ b/tests/verify-cache-files.sh
@ -7,12 +7,6 @@ if [ -z "$prefix" ]; then
  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"
@ -20,7 +14,7 @@ if [ -z "$GITHUB_RUN_ID" ]; then
 fi

 # Verify file exists
-file="$path/test-file.txt"
+file="test-cache/test-file.txt"
 echo "Checking for $file"
 if [ ! -e $file ]; then
  echo "File does not exist"
@ -33,4 +27,4 @@ echo "File content:\n$content"
 if [ -z "$(echo $content | grep --fixed-strings "$prefix $GITHUB_RUN_ID")" ]; then
  echo "Unexpected file content"
  exit 1
-fi
+fi
--- a/action.yml
+++ b/action.yml
@ -3,7 +3,7 @@ description: 'Cache artifacts like dependencies and build outputs to improve wor
 author: 'GitHub'
 inputs:
  path:
-    description: 'A list of files, directories, and wildcard patterns to cache and restore'
+    description: 'A directory to store and save the cache'
    required: true
  key:
    description: 'An explicit key for restoring and saving the cache'
--- a/dist/restore/index.js
+++ b/dist/restore/index.js
--- a/dist/save/index.js
+++ b/dist/save/index.js
--- a/examples.md
+++ b/examples.md
@ -1,42 +1,28 @@
 # Examples

- [Examples](#examples)
-  - [C# - NuGet](#c---nuget)
-  - [D - DUB](#d---dub)
-  - [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)
-  - [Node - Yarn 2](#node---yarn-2)
-  - [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):

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ~/.nuget/packages
    key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
@ -45,25 +31,13 @@ Using [NuGet lock files](https://docs.microsoft.com/nuget/consume-packages/packa
 ```

 Depending on the environment, huge packages might be pre-installed in the global cache folder.
-With `actions/cache@v2` you can now exclude unwanted packages with [exclude pattern](https://github.com/actions/toolkit/tree/main/packages/glob#exclude-patterns)
-```yaml
- uses: actions/cache@v2
-  with:
-    path: | 
-      ~/.nuget/packages
-      !~/.nuget/packages/unwanted
-    key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
-    restore-keys: |
-      ${{ runner.os }}-nuget-
-```
-
-Or you could move the cache folder like below.
+If you do not want to include them, consider to move the cache folder like below.
 >Note: This workflow does not work for projects that require files to be placed in user profile package folder
 ```yaml
 env:
  NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
 steps:
-  - uses: actions/cache@v2
+  - uses: actions/cache@v1
    with:
      path: ${{ github.workspace }}/.nuget/packages
      key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
@ -71,33 +45,9 @@ steps:
        ${{ runner.os }}-nuget-
 ```

-## D - DUB
-
-### POSIX
-
-```yaml
- uses: actions/cache@v2
-  with:
-    path: ~/.dub
-    key: ${{ runner.os }}-dub-${{ hashFiles('**/dub.json') }}
-    restore-keys: |
-      ${{ runner.os }}-dub-
-```
-
-### Windows
-
-```yaml
- uses: actions/cache@v2
-  with:
-    path: ~\AppData\Local\dub
-    key: ${{ runner.os }}-dub-${{ hashFiles('**/dub.json') }}
-    restore-keys: |
-      ${{ runner.os }}-dub-
-```
-
 ## Elixir - Mix
 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: deps
    key: ${{ runner.os }}-mix-${{ hashFiles(format('{0}{1}', github.workspace, '/mix.lock')) }}
@ -108,7 +58,7 @@ steps:
 ## Go - Modules

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ~/go/pkg/mod
    key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
@ -121,25 +71,30 @@ steps:
 We cache the elements of the Cabal store separately, as the entirety of `~/.cabal` can grow very large for projects with many dependencies.

 ```yaml
- name: Cache ~/.cabal/packages, ~/.cabal/store and dist-newstyle
-  uses: actions/cache@v2
+- uses: actions/cache@v1
+  name: Cache ~/.cabal/packages
  with:
-    path: |
-      ~/.cabal/packages
-      ~/.cabal/store
-      dist-newstyle
-    key: ${{ runner.os }}-${{ matrix.ghc }}
+    path: ~/.cabal/packages
+    key: ${{ runner.os }}-${{ matrix.ghc }}-cabal-packages
+- uses: actions/cache@v1
+  name: Cache ~/.cabal/store
+  with:
+    path: ~/.cabal/store
+    key: ${{ runner.os }}-${{ matrix.ghc }}-cabal-store
+- uses: actions/cache@v1
+  name: Cache dist-newstyle
+  with:
+    path: dist-newstyle
+    key: ${{ runner.os }}-${{ matrix.ghc }}-dist-newstyle
 ```

 ## Java - Gradle

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
-    path: |
-      ~/.gradle/caches
-      ~/.gradle/wrapper
-    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
+    path: ~/.gradle/caches
+    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
    restore-keys: |
      ${{ runner.os }}-gradle-
 ```
@ -147,8 +102,7 @@ We cache the elements of the Cabal store separately, as the entirety of `~/.caba
 ## Java - Maven

 ```yaml
- name: Cache local Maven repository
-  uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ~/.m2/repository
    key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
@ -160,14 +114,12 @@ We cache the elements of the Cabal store separately, as the entirety of `~/.caba

 For npm, cache files are stored in `~/.npm` on Posix, or `%AppData%/npm-cache` on Windows. See https://docs.npmjs.com/cli/cache#cache

-If using `npm config` to retrieve the cache directory, ensure you run [actions/setup-node](https://github.com/actions/setup-node) first to ensure your `npm` version is correct.
-
 >Note: It is not recommended to cache `node_modules`, as it can break across Node versions and won't work with `npm ci`

 ### macOS and Ubuntu

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@ -178,26 +130,22 @@ If using `npm config` to retrieve the cache directory, ensure you run [actions/s
 ### Windows

 ```yaml
- name: Get npm cache directory
-  id: npm-cache
-  run: |
-    echo "::set-output name=dir::$(npm config get cache)"
- uses: actions/cache@v2
+- 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: |
    echo "::set-output name=dir::$(npm config get cache)"
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ${{ steps.npm-cache.outputs.dir }}
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@ -205,89 +153,30 @@ If using `npm config` to retrieve the cache directory, ensure you run [actions/s
      ${{ runner.os }}-node-
 ```

-## Node - Lerna
-
-```yaml
- name: restore lerna
-  uses: actions/cache@v2
-  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@v2
-  id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
+- uses: actions/cache@v1
  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-
 ```

-
-## Node - Yarn 2
-The yarn 2 cache directory will depend on your config. See https://yarnpkg.com/configuration/yarnrc#cacheFolder for more info.
-
-```yaml
- name: Get yarn cache directory path
-  id: yarn-cache-dir-path
-  run: echo "::set-output name=dir::$(yarn config get cacheFolder)"
-
- uses: actions/cache@v2
-  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 }}
-    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@v2
-      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: |
    echo "::set-output name=dir::$(composer config cache-files-dir)"
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ${{ steps.composer-cache.outputs.dir }}
    key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
@ -306,7 +195,7 @@ Locations:

 ### Simple example
 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ~/.cache/pip
    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
@ -319,7 +208,7 @@ Replace `~/.cache/pip` with the correct `path` if not using Ubuntu.
 ### Multiple OS's in a workflow

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  if: startsWith(runner.os, 'Linux')
  with:
    path: ~/.cache/pip
@ -327,7 +216,7 @@ Replace `~/.cache/pip` with the correct `path` if not using Ubuntu.
    restore-keys: |
      ${{ runner.os }}-pip-

- uses: actions/cache@v2
+- uses: actions/cache@v1
  if: startsWith(runner.os, 'macOS')
  with:
    path: ~/Library/Caches/pip
@ -335,7 +224,7 @@ Replace `~/.cache/pip` with the correct `path` if not using Ubuntu.
    restore-keys: |
      ${{ runner.os }}-pip-

- uses: actions/cache@v2
+- uses: actions/cache@v1
  if: startsWith(runner.os, 'Windows')
  with:
    path: ~\AppData\Local\pip\Cache
@ -344,34 +233,16 @@ 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@v2
-  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@v2
+- uses: actions/cache@v1
  with:
    path: ${{ steps.pip-cache.outputs.dir }}
    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
@ -390,7 +261,7 @@ Locations:

 ### Simple example
 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: ~/.local/share/renv
    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
@ -403,7 +274,7 @@ Replace `~/.local/share/renv` with the correct `path` if not using Ubuntu.
 ### Multiple OS's in a workflow

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  if: startsWith(runner.os, 'Linux')
  with:
    path: ~/.local/share/renv
@ -411,7 +282,7 @@ Replace `~/.local/share/renv` with the correct `path` if not using Ubuntu.
    restore-keys: |
      ${{ runner.os }}-renv-

- uses: actions/cache@v2
+- uses: actions/cache@v1
  if: startsWith(runner.os, 'macOS')
  with:
    path: ~/Library/Application Support/renv
@ -419,7 +290,7 @@ Replace `~/.local/share/renv` with the correct `path` if not using Ubuntu.
    restore-keys: |
      ${{ runner.os }}-renv-

- uses: actions/cache@v2
+- uses: actions/cache@v1
  if: startsWith(runner.os, 'Windows')
  with:
    path: ~\AppData\Local\renv
@ -431,7 +302,7 @@ Replace `~/.local/share/renv` with the correct `path` if not using Ubuntu.
 ## Ruby - Bundler

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: vendor/bundle
    key: ${{ runner.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
@ -450,31 +321,42 @@ When dependencies are installed later in the workflow, we must specify the same
 ## Rust - Cargo

 ```yaml
- uses: actions/cache@v2
+- name: Cache cargo registry
+  uses: actions/cache@v1
  with:
-    path: |
-      ~/.cargo/registry
-      ~/.cargo/git
-      target
-    key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+    path: ~/.cargo/registry
+    key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+- name: Cache cargo index
+  uses: actions/cache@v1
+  with:
+    path: ~/.cargo/git
+    key: ${{ runner.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}
+- name: Cache cargo build
+  uses: actions/cache@v1
+  with:
+    path: target
+    key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
 ```

 ## Scala - SBT

 ```yaml
- name: Cache SBT
-  uses: actions/cache@v2
+- name: Cache SBT ivy cache
+  uses: actions/cache@v1
  with:
-    path: | 
-      ~/.ivy2/cache
-      ~/.sbt
+    path: ~/.ivy2/cache
+    key: ${{ runner.os }}-sbt-ivy-cache-${{ hashFiles('**/build.sbt') }}
+- name: Cache SBT
+  uses: actions/cache@v1
+  with:
+    path: ~/.sbt
    key: ${{ runner.os }}-sbt-${{ hashFiles('**/build.sbt') }}
 ```

 ## Swift, Objective-C - Carthage

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: Carthage
    key: ${{ runner.os }}-carthage-${{ hashFiles('**/Cartfile.resolved') }}
@ -485,7 +367,7 @@ When dependencies are installed later in the workflow, we must specify the same
 ## Swift, Objective-C - CocoaPods

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: Pods
    key: ${{ runner.os }}-pods-${{ hashFiles('**/Podfile.lock') }}
@ -496,7 +378,7 @@ When dependencies are installed later in the workflow, we must specify the same
 ## Swift - Swift Package Manager

 ```yaml
- uses: actions/cache@v2
+- uses: actions/cache@v1
  with:
    path: .build
    key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,15 +1,16 @@
 {
  "name": "cache",
-  "version": "2.1.1",
+  "version": "1.2.0",
  "private": true,
  "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",
@ -23,15 +24,17 @@
  "author": "GitHub",
  "license": "MIT",
  "dependencies": {
-    "@actions/core": "^1.2.0",
+    "@actions/core": "^1.10.0",
    "@actions/exec": "^1.0.1",
+    "@actions/http-client": "^1.0.6",
    "@actions/io": "^1.0.1",
-    "@actions/cache": "^1.0.2"
+    "uuid": "^3.3.3"
  },
  "devDependencies": {
    "@types/jest": "^24.0.13",
    "@types/nock": "^11.1.0",
    "@types/node": "^12.0.4",
+    "@types/uuid": "^3.4.5",
    "@typescript-eslint/eslint-plugin": "^2.7.0",
    "@typescript-eslint/parser": "^2.7.0",
    "@zeit/ncc": "^0.20.5",
@ -40,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",
--- a/src/cacheHttpClient.ts
+++ b/src/cacheHttpClient.ts
@ -0,0 +1,397 @@
+import * as core from "@actions/core";
+import { HttpClient, HttpCodes } from "@actions/http-client";
+import { BearerCredentialHandler } from "@actions/http-client/auth";
+import {
+    IHttpClientResponse,
+    IRequestOptions,
+    ITypedResponse
+} from "@actions/http-client/interfaces";
+import * as fs from "fs";
+import * as stream from "stream";
+import * as util from "util";
+
+import { SocketTimeout } from "./constants";
+import {
+    ArtifactCacheEntry,
+    CommitCacheRequest,
+    ReserveCacheRequest,
+    ReserveCacheResponse
+} from "./contracts";
+import * as utils from "./utils/actionUtils";
+
+function isSuccessStatusCode(statusCode?: number): boolean {
+    if (!statusCode) {
+        return false;
+    }
+    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;
+    }
+    const retryableStatusCodes = [
+        HttpCodes.BadGateway,
+        HttpCodes.ServiceUnavailable,
+        HttpCodes.GatewayTimeout
+    ];
+    return retryableStatusCodes.includes(statusCode);
+}
+
+function getCacheApiUrl(resource: string): string {
+    // Ideally we just use ACTIONS_CACHE_URL
+    const baseUrl: string = (
+        process.env["ACTIONS_CACHE_URL"] ||
+        process.env["ACTIONS_RUNTIME_URL"] ||
+        ""
+    ).replace("pipelines", "artifactcache");
+    if (!baseUrl) {
+        throw new Error(
+            "Cache Service Url not found, unable to restore cache."
+        );
+    }
+
+    const url = `${baseUrl}_apis/artifactcache/${resource}`;
+    core.debug(`Resource Url: ${url}`);
+    return url;
+}
+
+function createAcceptHeader(type: string, apiVersion: string): string {
+    return `${type};api-version=${apiVersion}`;
+}
+
+function getRequestOptions(): IRequestOptions {
+    const requestOptions: IRequestOptions = {
+        headers: {
+            Accept: createAcceptHeader("application/json", "6.0-preview.1")
+        }
+    };
+
+    return requestOptions;
+}
+
+function createHttpClient(): HttpClient {
+    const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
+    const bearerCredentialHandler = new BearerCredentialHandler(token);
+
+    return new HttpClient(
+        "actions/cache",
+        [bearerCredentialHandler],
+        getRequestOptions()
+    );
+}
+
+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[]
+): Promise<ArtifactCacheEntry | null> {
+    const httpClient = createHttpClient();
+    const resource = `cache?keys=${encodeURIComponent(keys.join(","))}`;
+
+    const response = await retryTypedResponse("getCacheEntry", () =>
+        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;
+    if (!cacheDownloadUrl) {
+        throw new Error("Cache not found.");
+    }
+    core.setSecret(cacheDownloadUrl);
+    core.debug(`Cache Result:`);
+    core.debug(JSON.stringify(cacheResult));
+
+    return cacheResult;
+}
+
+async function pipeResponseToStream(
+    response: IHttpClientResponse,
+    output: NodeJS.WritableStream
+): Promise<void> {
+    const pipeline = util.promisify(stream.pipeline);
+    await pipeline(response.message, output);
+}
+
+export async function downloadCache(
+    archiveLocation: string,
+    archivePath: string
+): 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`
+        );
+    });
+
+    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): Promise<number> {
+    const httpClient = createHttpClient();
+
+    const reserveCacheRequest: ReserveCacheRequest = {
+        key
+    };
+    const response = await retryTypedResponse("reserveCache", () =>
+        httpClient.postJson<ReserveCacheResponse>(
+            getCacheApiUrl("caches"),
+            reserveCacheRequest
+        )
+    );
+    return response?.result?.cacheId ?? -1;
+}
+
+function getContentRange(start: number, end: number): string {
+    // Format: `bytes start-end/filesize
+    // start and end are inclusive
+    // filesize can be *
+    // For a 200 byte chunk starting at byte 0:
+    // Content-Range: bytes 0-199/*
+    return `bytes ${start}-${end}/*`;
+}
+
+async function uploadChunk(
+    httpClient: HttpClient,
+    resourceUrl: string,
+    openStream: () => NodeJS.ReadableStream,
+    start: number,
+    end: number
+): Promise<void> {
+    core.debug(
+        `Uploading chunk of size ${end -
+            start +
+            1} bytes at offset ${start} with content range: ${getContentRange(
+            start,
+            end
+        )}`
+    );
+    const additionalHeaders = {
+        "Content-Type": "application/octet-stream",
+        "Content-Range": getContentRange(start, end)
+    };
+
+    await retryHttpClientResponse(
+        `uploadChunk (start: ${start}, end: ${end})`,
+        () =>
+            httpClient.sendStream(
+                "PATCH",
+                resourceUrl,
+                openStream(),
+                additionalHeaders
+            )
+    );
+}
+
+function parseEnvNumber(key: string): number | undefined {
+    const value = Number(process.env[key]);
+    if (Number.isNaN(value) || value < 0) {
+        return undefined;
+    }
+    return value;
+}
+
+async function uploadFile(
+    httpClient: HttpClient,
+    cacheId: number,
+    archivePath: string
+): Promise<void> {
+    // Upload Chunks
+    const fileSize = fs.statSync(archivePath).size;
+    const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`);
+    const fd = fs.openSync(archivePath, "r");
+
+    const concurrency = parseEnvNumber("CACHE_UPLOAD_CONCURRENCY") ?? 4; // # of HTTP requests in parallel
+    const MAX_CHUNK_SIZE =
+        parseEnvNumber("CACHE_UPLOAD_CHUNK_SIZE") ?? 32 * 1024 * 1024; // 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 = Math.min(
+                        fileSize - offset,
+                        MAX_CHUNK_SIZE
+                    );
+                    const start = offset;
+                    const end = offset + chunkSize - 1;
+                    offset += MAX_CHUNK_SIZE;
+
+                    await uploadChunk(
+                        httpClient,
+                        resourceUrl,
+                        () =>
+                            fs
+                                .createReadStream(archivePath, {
+                                    fd,
+                                    start,
+                                    end,
+                                    autoClose: false
+                                })
+                                .on("error", error => {
+                                    throw new Error(
+                                        `Cache upload failed because file read failed with ${error.Message}`
+                                    );
+                                }),
+                        start,
+                        end
+                    );
+                }
+            })
+        );
+    } finally {
+        fs.closeSync(fd);
+    }
+    return;
+}
+
+async function commitCache(
+    httpClient: HttpClient,
+    cacheId: number,
+    filesize: number
+): Promise<ITypedResponse<null>> {
+    const commitCacheRequest: CommitCacheRequest = { size: filesize };
+    return await retryTypedResponse("commitCache", () =>
+        httpClient.postJson<null>(
+            getCacheApiUrl(`caches/${cacheId.toString()}`),
+            commitCacheRequest
+        )
+    );
+}
+
+export async function saveCache(
+    cacheId: number,
+    archivePath: string
+): Promise<void> {
+    const httpClient = createHttpClient();
+
+    core.debug("Upload cache");
+    await uploadFile(httpClient, cacheId, archivePath);
+
+    // Commit Cache
+    core.debug("Commiting cache");
+    const cacheSize = utils.getArchiveFileSize(archivePath);
+    const commitCacheResponse = await commitCache(
+        httpClient,
+        cacheId,
+        cacheSize
+    );
+    if (!isSuccessStatusCode(commitCacheResponse.statusCode)) {
+        throw new Error(
+            `Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`
+        );
+    }
+
+    core.info("Cache saved successfully");
+}
--- a/src/constants.ts
+++ b/src/constants.ts
@ -9,8 +9,8 @@ export enum Outputs {
 }

 export enum State {
-    CachePrimaryKey = "CACHE_KEY",
-    CacheMatchedKey = "CACHE_RESULT"
+    CacheKey = "CACHE_KEY",
+    CacheResult = "CACHE_RESULT"
 }

 export enum Events {
@ -19,4 +19,7 @@ export enum Events {
    PullRequest = "pull_request"
 }

-export const RefKey = "GITHUB_REF";
+// 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;
--- a/src/contracts.d.ts
+++ b/src/contracts.d.ts
@ -0,0 +1,19 @@
+export interface ArtifactCacheEntry {
+    cacheKey?: string;
+    scope?: string;
+    creationTime?: string;
+    archiveLocation?: string;
+}
+
+export interface CommitCacheRequest {
+    size: number;
+}
+
+export interface ReserveCacheRequest {
+    key: string;
+    version?: string;
+}
+
+export interface ReserveCacheResponse {
+    cacheId: number;
+}
--- a/src/restore.ts
+++ b/src/restore.ts
@ -1,7 +1,8 @@
-import * as cache from "@actions/cache";
 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";
 import * as utils from "./utils/actionUtils";

 async function run(): Promise<void> {
@ -11,49 +12,97 @@ async function run(): Promise<void> {
            utils.logWarning(
                `Event Validation Error: The event type ${
                    process.env[Events.Key]
-                } is not supported because it's not tied to a branch or tag ref.`
+                } is not supported. Only ${utils
+                    .getSupportedEvents()
+                    .join(", ")} events are supported at this time.`
            );
            return;
        }

-        const primaryKey = core.getInput(Inputs.Key, { required: true });
-        core.saveState(State.CachePrimaryKey, primaryKey);
+        const cachePath = utils.resolvePath(
+            core.getInput(Inputs.Path, { required: true })
+        );
+        core.debug(`Cache Path: ${cachePath}`);

-        const restoreKeys = utils.getInputAsArray(Inputs.RestoreKeys);
-        const cachePaths = utils.getInputAsArray(Inputs.Path, {
-            required: true
-        });
+        const primaryKey = core.getInput(Inputs.Key, { required: true });
+        core.saveState(State.CacheKey, primaryKey);
+
+        const restoreKeys = core
+            .getInput(Inputs.RestoreKeys)
+            .split("\n")
+            .filter(x => x !== "");
+        const keys = [primaryKey, ...restoreKeys];
+
+        core.debug("Resolved Keys:");
+        core.debug(JSON.stringify(keys));
+
+        if (keys.length > 10) {
+            core.setFailed(
+                `Key Validation Error: Keys are limited to a maximum of 10.`
+            );
+            return;
+        }
+        for (const key of keys) {
+            if (key.length > 512) {
+                core.setFailed(
+                    `Key Validation Error: ${key} cannot be larger than 512 characters.`
+                );
+                return;
+            }
+            const regex = /^[^,]*$/;
+            if (!regex.test(key)) {
+                core.setFailed(
+                    `Key Validation Error: ${key} cannot contain commas.`
+                );
+                return;
+            }
+        }

        try {
-            const cacheKey = await cache.restoreCache(
-                cachePaths,
-                primaryKey,
-                restoreKeys
-            );
-            if (!cacheKey) {
+            const cacheEntry = await cacheHttpClient.getCacheEntry(keys);
+            if (!cacheEntry?.archiveLocation) {
                core.info(
-                    `Cache not found for input keys: ${[
-                        primaryKey,
-                        ...restoreKeys
-                    ].join(", ")}`
+                    `Cache not found for input keys: ${keys.join(", ")}.`
                );
                return;
            }

-            // Store the matched cache key
-            utils.setCacheState(cacheKey);
+            const archivePath = path.join(
+                await utils.createTempDirectory(),
+                "cache.tgz"
+            );
+            core.debug(`Archive Path: ${archivePath}`);

-            const isExactKeyMatch = utils.isExactKeyMatch(primaryKey, cacheKey);
+            // Store the cache result
+            utils.setCacheState(cacheEntry);
+
+            // 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)`
+            );
+
+            await extractTar(archivePath, cachePath);
+
+            const isExactKeyMatch = utils.isExactKeyMatch(
+                primaryKey,
+                cacheEntry
+            );
            utils.setCacheHitOutput(isExactKeyMatch);

-            core.info(`Cache restored from key: ${cacheKey}`);
+            core.info(
+                `Cache restored from key: ${cacheEntry && cacheEntry.cacheKey}`
+            );
        } catch (error) {
-            if (error.name === cache.ValidationError.name) {
-                throw error;
-            } else {
-                utils.logWarning(error.message);
-                utils.setCacheHitOutput(false);
-            }
+            utils.logWarning(error.message);
+            utils.setCacheHitOutput(false);
        }
    } catch (error) {
        core.setFailed(error.message);
--- a/src/save.ts
+++ b/src/save.ts
@ -1,7 +1,8 @@
-import * as cache from "@actions/cache";
 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";
 import * as utils from "./utils/actionUtils";

 async function run(): Promise<void> {
@ -10,7 +11,9 @@ async function run(): Promise<void> {
            utils.logWarning(
                `Event Validation Error: The event type ${
                    process.env[Events.Key]
-                } is not supported because it's not tied to a branch or tag ref.`
+                } is not supported. Only ${utils
+                    .getSupportedEvents()
+                    .join(", ")} events are supported at this time.`
            );
            return;
        }
@ -18,7 +21,7 @@ async function run(): Promise<void> {
        const state = utils.getCacheState();

        // Inputs are re-evaluted before the post action, so we want the original key used for restore
-        const primaryKey = core.getState(State.CachePrimaryKey);
+        const primaryKey = core.getState(State.CacheKey);
        if (!primaryKey) {
            utils.logWarning(`Error retrieving key from state.`);
            return;
@ -31,21 +34,42 @@ async function run(): Promise<void> {
            return;
        }

-        const cachePaths = utils.getInputAsArray(Inputs.Path, {
-            required: true
-        });
-
-        try {
-            await cache.saveCache(cachePaths, primaryKey);
-        } catch (error) {
-            if (error.name === cache.ValidationError.name) {
-                throw error;
-            } else if (error.name === cache.ReserveCacheError.name) {
-                core.info(error.message);
-            } else {
-                utils.logWarning(error.message);
-            }
+        core.debug("Reserving Cache");
+        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.`
+            );
+            return;
        }
+        core.debug(`Cache ID: ${cacheId}`);
+        const cachePath = utils.resolvePath(
+            core.getInput(Inputs.Path, { required: true })
+        );
+        core.debug(`Cache Path: ${cachePath}`);
+
+        const archivePath = path.join(
+            await utils.createTempDirectory(),
+            "cache.tgz"
+        );
+        core.debug(`Archive Path: ${archivePath}`);
+
+        await createTar(archivePath, cachePath);
+
+        const fileSizeLimit = 5 * 1024 * 1024 * 1024; // 5GB per repo limit
+        const archiveFileSize = utils.getArchiveFileSize(archivePath);
+        core.debug(`File Size: ${archiveFileSize}`);
+        if (archiveFileSize > fileSizeLimit) {
+            utils.logWarning(
+                `Cache size of ~${Math.round(
+                    archiveFileSize / (1024 * 1024)
+                )} MB (${archiveFileSize} B) is over the 5GB limit, not saving cache.`
+            );
+            return;
+        }
+
+        core.debug(`Saving Cache (ID: ${cacheId})`);
+        await cacheHttpClient.saveCache(cacheId, archivePath);
    } catch (error) {
        utils.logWarning(error.message);
    }
--- a/src/tar.ts
+++ b/src/tar.ts
@ -0,0 +1,76 @@
+import * as core from "@actions/core";
+import { exec } from "@actions/exec";
+import * as io from "@actions/io";
+import { existsSync } from "fs";
+import * as path from "path";
+import * as tar from "./tar";
+
+export async function isGnuTar(): Promise<boolean> {
+    core.debug("Checking tar --version");
+    let versionOutput = "";
+    await exec("tar --version", [], {
+        ignoreReturnCode: true,
+        silent: true,
+        listeners: {
+            stdout: (data: Buffer): string =>
+                (versionOutput += data.toString()),
+            stderr: (data: Buffer): string => (versionOutput += data.toString())
+        }
+    });
+
+    core.debug(versionOutput.trim());
+    return versionOutput.toUpperCase().includes("GNU TAR");
+}
+
+async function getTarPath(args: string[]): 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 tar.isGnuTar()) {
+            args.push("--force-local");
+        }
+    }
+    return await io.which("tar", true);
+}
+
+async function execTar(args: string[]): Promise<void> {
+    try {
+        await exec(`"${await getTarPath(args)}"`, args);
+    } catch (error) {
+        throw new Error(`Tar failed with error: ${error?.message}`);
+    }
+}
+
+export async function extractTar(
+    archivePath: string,
+    targetDirectory: string
+): Promise<void> {
+    // Create directory to extract tar into
+    await io.mkdirP(targetDirectory);
+    const args = [
+        "-xz",
+        "-f",
+        archivePath.replace(new RegExp("\\" + path.sep, "g"), "/"),
+        "-C",
+        targetDirectory.replace(new RegExp("\\" + path.sep, "g"), "/")
+    ];
+    await execTar(args);
+}
+
+export async function createTar(
+    archivePath: string,
+    sourceDirectory: string
+): Promise<void> {
+    const args = [
+        "-cz",
+        "-f",
+        archivePath.replace(new RegExp("\\" + path.sep, "g"), "/"),
+        "-C",
+        sourceDirectory.replace(new RegExp("\\" + path.sep, "g"), "/"),
+        "."
+    ];
+    await execTar(args);
+}
--- a/src/utils/actionUtils.ts
+++ b/src/utils/actionUtils.ts
@ -1,35 +1,77 @@
 import * as core from "@actions/core";
+import * as io from "@actions/io";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as uuidV4 from "uuid/v4";

-import { Outputs, RefKey, State } from "../constants";
+import { Events, Outputs, State } from "../constants";
+import { ArtifactCacheEntry } from "../contracts";

-export function isExactKeyMatch(key: string, cacheKey?: string): boolean {
+// 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 {
    return !!(
-        cacheKey &&
-        cacheKey.localeCompare(key, undefined, {
+        cacheResult &&
+        cacheResult.cacheKey &&
+        cacheResult.cacheKey.localeCompare(key, undefined, {
            sensitivity: "accent"
        }) === 0
    );
 }

-export function setCacheState(state: string): void {
-    core.saveState(State.CacheMatchedKey, state);
+export function setCacheState(state: ArtifactCacheEntry): void {
+    core.saveState(State.CacheResult, JSON.stringify(state));
 }

 export function setCacheHitOutput(isCacheHit: boolean): void {
    core.setOutput(Outputs.CacheHit, isCacheHit.toString());
 }

-export function setOutputAndState(key: string, cacheKey?: string): void {
-    setCacheHitOutput(isExactKeyMatch(key, cacheKey));
-    // Store the matched cache key if it exists
-    cacheKey && setCacheState(cacheKey);
+export function setOutputAndState(
+    key: string,
+    cacheResult?: ArtifactCacheEntry
+): void {
+    setCacheHitOutput(isExactKeyMatch(key, cacheResult));
+    // Store the cache result if it exists
+    cacheResult && setCacheState(cacheResult);
 }

-export function getCacheState(): string | undefined {
-    const cacheKey = core.getState(State.CacheMatchedKey);
-    if (cacheKey) {
-        core.debug(`Cache state/key: ${cacheKey}`);
-        return cacheKey;
+export function getCacheState(): ArtifactCacheEntry | undefined {
+    const stateData = core.getState(State.CacheResult);
+    core.debug(`State: ${stateData}`);
+    if (stateData) {
+        return JSON.parse(stateData) as ArtifactCacheEntry;
    }

    return undefined;
@ -40,19 +82,26 @@ export function logWarning(message: string): void {
    core.info(`${warningPrefix}${message}`);
 }

-// 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 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 path.resolve(filePath);
 }

-export function getInputAsArray(
-    name: string,
-    options?: core.InputOptions
-): string[] {
-    return core
-        .getInput(name, options)
-        .split("\n")
-        .map(s => s.trim())
-        .filter(x => x !== "");
+export function getSupportedEvents(): string[] {
+    return [Events.Push, Events.PullRequest];
+}
+
+// Currently the cache token is only authorized for push and pull_request events
+// All other events will fail when reading and saving the cache
+// 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 {
+    const githubEvent = process.env[Events.Key] || "";
+    return getSupportedEvents().includes(githubEvent);
 }
Author	SHA1	Message	Date
Francesco Renzi	f5ce41475b	Merge pull request #1162 from actions/rentziass/actions-core Bump actions/core to 1.10.0	2023-04-27 17:32:58 +01:00
Francesco Renzi	68fa0a8d81	bump version to 1.2.0	2023-04-27 17:26:14 +01:00
Francesco Renzi	56ec64e417	update squid image	2023-04-27 17:18:36 +01:00
Francesco Renzi	efbc4e162b	Bump actions/core to 1.10.0	2023-04-27 17:06:31 +01:00
Aiqiao Yan	d9747005de	Merge pull request #308 from actions/aiyan/v1-release Cherry-pick commits for v1	2020-05-14 11:11:05 -04:00
Aiqiao Yan	3f662ca624	Add Eric's e2e test change to get more coverage	2020-05-12 17:14:33 -04:00
Dave Hadka	0232e3178d	Add retries to all API calls	2020-05-12 16:16:48 -04:00
Aiqiao Yan	ee7a57c615	error handling for stream	2020-05-11 16:48:56 -04:00
Dave Hadka	da9f90cb83	Fix upload chunk retries	2020-05-11 14:46:06 -04:00
Dave Hadka	ec7f7ebd08	Use promisify of stream.pipeline for downloading	2020-05-11 14:41:48 -04:00
Dave Hadka	2a973a0f4e	Add comment for SocketTimeout	2020-05-11 14:32:38 -04:00
Dave Hadka	cbbb8b4d4f	Fix lint issue, build .js files	2020-05-11 14:31:13 -04:00
Dave Hadka	5a0add1806	Adds socket timeout and validate file size	2020-05-11 14:28:28 -04:00
Aiqiao Yan	9fe7ad8b07	Use path.sep in path replace	2020-05-11 14:20:33 -04:00
Aiqiao Yan	7c7d003bbb	Rebase and rebuild	2020-05-11 14:08:26 -04:00
Aiqiao Yan	96e5a46c57	Fix test	2020-05-11 14:08:26 -04:00
Aiqiao Yan	84e606dfac	Fallback to GNU tar if BSD tar is unavailable	2020-05-11 14:08:23 -04:00
Josh Gross	70655ec832	Release v1.1.2	2020-02-05 10:41:57 -05:00
Josh Gross	fe1055e9d1	Release v1.1.1	2020-02-05 10:01:01 -05:00
Josh Gross	a505c2e7a6	Merge branch 'master' into releases/v1	2020-01-06 14:10:16 -05:00
Josh Gross	10a14413e7	Update release binaries	2020-01-06 13:51:23 -05:00
Josh Gross	cf4f44db70	Fix invalid array	2020-01-06 13:50:39 -05:00
Josh Gross	4c4974aff1	Release v1.1	2020-01-06 13:36:33 -05:00
Josh Gross	cffae9552b	Release v1.0.3	2019-11-21 14:57:29 -05:00
Josh Gross	44543250bd	Release 1.0.2	2019-11-15 10:31:02 -05:00
Josh Gross	6491e51b66	Merge master into releases/v1	2019-11-15 10:29:58 -05:00
Josh Gross	86dff562ab	v1.0.1 release binaries	2019-11-05 15:43:33 -05:00
Josh Gross	0f810ad45a	Release v1.0.1	2019-11-05 15:42:18 -05:00
Josh Gross	9d8c7b4041	Release v1	2019-11-04 15:13:15 -05:00