Merge pull request #329 from actions/aiyan/v2-release-doc

Update readme and examples to use v2
React to feedback
2025-06-24 19:31:10 +02:00 · 2020-05-26 15:35:50 -04:00 · 2020-05-26 15:31:33 -04:00 · 2020-05-26 12:48:39 -04:00 · 2020-05-20 15:26:12 -04:00 · 2020-05-20 15:20:07 -04:00
24 changed files with 17550 additions and 3177 deletions
--- a/.eslintrc.json
+++ b/.eslintrc.json
@ -12,5 +12,12 @@
    "plugin:prettier/recommended",
    "prettier/@typescript-eslint"
  ],
-  "plugins": ["@typescript-eslint", "jest"]
+  "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"
+  }
 }
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@ -0,0 +1,35 @@
+name: "Code Scanning - Action"
+
+on:
+  push:
+  schedule:
+    - cron: '0 0 * * 0'
+
+jobs:
+  CodeQL-Build:
+
+    strategy:
+      fail-fast: false
+
+
+    # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      # Override language selection by uncommenting this and choosing your languages
+      # with:
+      #   languages: go, javascript, csharp, python, cpp, java
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below).
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@ -4,50 +4,151 @@ on:
  pull_request:
    branches:
      - master
+      - releases/**
    paths-ignore:
      - '**.md'
  push:
    branches:
      - master
+      - releases/**
    paths-ignore:
      - '**.md'

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

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

@ -94,3 +91,6 @@ typings/

 # DynamoDB Local files
 .dynamodb/
+
+# Text editor files
+.vscode/
--- a/README.md
+++ b/README.md
@ -1,6 +1,6 @@
 # cache

-This GitHub Action allows caching dependencies and build outputs to improve workflow execution time.
+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=master&event=push"></a>

@ -8,6 +8,28 @@ This GitHub Action allows caching dependencies and build outputs to improve work

 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/master/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/master/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
@ -15,7 +37,7 @@ Create a workflow `.yml` file in your repositories `.github/workflows` directory

 ### Inputs

-* `path` - A directory to store and save the cache
+* `path` - A list of files, directories, and wildcard patterns to cache and restore. See [`@actions/glob`](https://github.com/actions/toolkit/tree/master/packages/glob) for supported patterns. 
 * `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

@ -25,6 +47,11 @@ 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
@ -37,11 +64,11 @@ jobs:
    runs-on: ubuntu-latest

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

    - name: Cache Primes
      id: cache-primes
-      uses: actions/cache@v1
+      uses: actions/cache@v2
      with:
        path: prime-numbers
        key: ${{ runner.os }}-primes
@ -61,23 +88,62 @@ 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)
- [Ruby - Gem](./examples.md#ruby---gem)
+- [R - renv](./examples.md#r---renv)
+- [Ruby - Bundler](./examples.md#ruby---bundler)
 - [Rust - Cargo](./examples.md#rust---cargo)
+- [Scala - SBT](./examples.md#scala---sbt)
 - [Swift, Objective-C - Carthage](./examples.md#swift-objective-c---carthage)
 - [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

-Individual caches are limited to 400MB and a repository can have up to 2GB of caches. Once the 2GB 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.
+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.

 ## Skipping steps based on cache-hit

@ -86,9 +152,9 @@ Using the `cache-hit` output, subsequent steps (such as install or build) can be
 Example:
 ```yaml
 steps:
-  - uses: actions/checkout@v1
+  - uses: actions/checkout@v2

-  - uses: actions/cache@v1
+  - uses: actions/cache@v2
    id: cache
    with:
      path: path/to/dependencies
@ -102,7 +168,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,84 +1,65 @@
 import * as core from "@actions/core";
-import * as os from "os";
-import * as path from "path";

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

 jest.mock("@actions/core");
-jest.mock("os");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    expect(setOutputMock).toHaveBeenCalledWith(Outputs.CacheHit, "false");
    expect(setOutputMock).toHaveBeenCalledTimes(1);
@ -88,43 +69,33 @@ 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 cacheEntry: ArtifactCacheEntry = {
-        cacheKey: "linux-rust"
-    };
+    const cacheKey = "linux-rust";

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

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

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

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

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

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

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

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

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

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

    expect(state).toBe(undefined);

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

 test("getCacheState with valid state", () => {
-    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 cacheKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+
    const getStateMock = jest.spyOn(core, "getState");
    getStateMock.mockImplementation(() => {
-        return JSON.stringify(cacheEntry);
+        return cacheKey;
    });

    const state = actionUtils.getCacheState();

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

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

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

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

@ -181,54 +148,10 @@ test("isValidEvent returns false for unknown event", () => {
    expect(isValidEvent).toBe(false);
 });

-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", () => {
+test("isValidEvent returns true for event that has a ref", () => {
    const event = Events.Push;
    process.env[Events.Key] = event;
-
-    const isValidEvent = actionUtils.isValidEvent();
-
-    expect(isValidEvent).toBe(true);
-});
-
-test("isValidEvent returns true for pull request event", () => {
-    const event = Events.PullRequest;
-    process.env[Events.Key] = event;
+    process.env[RefKey] = "ref/heads/feature";

    const isValidEvent = actionUtils.isValidEvent();

--- a/tests/create-cache-files.sh
+++ b/tests/create-cache-files.sh
@ -0,0 +1,17 @@
+#!/bin/sh
+
+# Validate args
+prefix="$1"
+if [ -z "$prefix" ]; then
+  echo "Must supply prefix argument"
+  exit 1
+fi
+
+path="$2"
+if [ -z "$path" ]; then
+  echo "Must supply path argument"
+  exit 1
+fi
+
+mkdir -p $path
+echo "$prefix $GITHUB_RUN_ID" > $path/test-file.txt
--- a/tests/restore.test.ts
+++ b/tests/restore.test.ts
@ -1,22 +1,14 @@
+import * as cache from "@actions/cache";
 import * as core from "@actions/core";
-import * as path from "path";
-import * as cacheHttpClient from "../src/cacheHttpClient";
-import { Events, Inputs } from "../src/constants";
-import { ArtifactCacheEntry } from "../src/contracts";
+
+import { Events, Inputs, RefKey } from "../src/constants";
 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");
@ -28,20 +20,17 @@ 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();
-    });
 });

 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 () => {
@ -49,17 +38,21 @@ 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. Only push, pull_request events are supported at this time.`
+        `Event Validation Error: The event type ${invalidEvent} is not supported because it's not tied to a branch or tag ref.`
    );
    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(failedMock).toHaveBeenCalledWith(
+    expect(restoreCacheMock).toHaveBeenCalledTimes(0);
+    // this input isn't necessary for restore b/c tarball contains entries relative to workspace
+    expect(failedMock).not.toHaveBeenCalledWith(
        "Input required and not supplied: path"
    );
 });
@ -67,99 +60,120 @@ 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: "node_modules",
+        path: path,
        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: "node_modules",
+        path: path,
        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: "node_modules",
+        path: path,
        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: "node_modules",
+        path: path,
        key
    });

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

    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: "node_modules",
+        path: path,
        key
    });

    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
    const failedMock = jest.spyOn(core, "setFailed");
    const stateMock = jest.spyOn(core, "saveState");
-
-    const clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    clientMock.mockImplementation(() => {
-        throw new Error("HTTP Error Occurred");
-    });
-
+    const restoreCacheMock = jest
+        .spyOn(cache, "restoreCache")
+        .mockImplementationOnce(() => {
+            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);
@ -172,10 +186,11 @@ 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: "node_modules",
+        path: path,
        key,
        restoreKeys: [restoreKey]
    });
@ -183,142 +198,49 @@ 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 clientMock = jest.spyOn(cacheHttpClient, "getCacheEntry");
-    clientMock.mockImplementation(() => {
-        return Promise.resolve(null);
-    });
+    const restoreCacheMock = jest
+        .spyOn(cache, "restoreCache")
+        .mockImplementationOnce(() => {
+            return Promise.resolve(undefined);
+        });

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

@ -327,11 +249,11 @@ test("restore with a pull request event and cache found", 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: "node_modules",
+        path: path,
        key,
        restoreKeys: [restoreKey]
    });
@ -339,51 +261,19 @@ 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, 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,16 +1,13 @@
+import * as cache from "@actions/cache";
 import * as core from "@actions/core";
-import * as path from "path";
-import * as cacheHttpClient from "../src/cacheHttpClient";
-import { Events, Inputs } from "../src/constants";
-import { ArtifactCacheEntry } from "../src/contracts";
+
+import { Events, Inputs, RefKey } from "../src/constants";
 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("../src/cacheHttpClient");
-jest.mock("../src/tar");
+jest.mock("@actions/cache");
 jest.mock("../src/utils/actionUtils");

 beforeAll(() => {
@ -34,28 +31,17 @@ 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 () => {
@ -63,9 +49,10 @@ 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. Only push, pull_request events are supported at this time.`
+        `Event Validation Error: The event type ${invalidEvent} is not supported because it's not tied to a branch or tag ref.`
    );
    expect(failedMock).toHaveBeenCalledTimes(0);
 });
@ -74,25 +61,21 @@ test("save with no primary key in state outputs warning", async () => {
    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
    const failedMock = jest.spyOn(core, "setFailed");

-    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 savedCacheKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
+            return savedCacheKey;
        })
        // 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.`
    );
@ -105,33 +88,25 @@ test("save with exact match returns early", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

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

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

    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);
 });

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

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

    jest.spyOn(core, "getState")
        // Cache Entry State
        .mockImplementationOnce(() => {
-            return JSON.stringify(cacheEntry);
+            return savedCacheKey;
        })
        // 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"
    );
@ -171,17 +143,12 @@ test("save with large cache outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

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

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

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

-    const createTarMock = jest.spyOn(tar, "createTar");
-
-    const cacheSize = 1024 * 1024 * 1024; //~1GB, over the 400MB limit
-    jest.spyOn(actionUtils, "getArchiveFileSize").mockImplementationOnce(() => {
-        return cacheSize;
-    });
+    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."
+            );
+        });

    await run();

-    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(logWarningMock).toHaveBeenCalledTimes(1);
    expect(logWarningMock).toHaveBeenCalledWith(
-        "Cache size of ~1024 MB (1073741824 B) is over the 400MB limit, not saving cache."
+        "Cache size of ~6144 MB (6442450944 B) is over the 5GB limit, not saving cache."
    );
+    expect(failedMock).toHaveBeenCalledTimes(0);
+});

+test("save with reserve cache failure outputs warning", async () => {
+    const infoMock = jest.spyOn(core, "info");
+    const logWarningMock = jest.spyOn(actionUtils, "logWarning");
+    const failedMock = jest.spyOn(core, "setFailed");
+
+    const primaryKey = "Linux-node-bb828da54c148048dd17899ba9fda624811cfb43";
+    const savedCacheKey = "Linux-node-";
+
+    jest.spyOn(core, "getState")
+        // Cache Entry State
+        .mockImplementationOnce(() => {
+            return savedCacheKey;
+        })
+        // Cache Key State
+        .mockImplementationOnce(() => {
+            return primaryKey;
+        });
+
+    const inputPath = "node_modules";
+    testUtils.setInput(Inputs.Path, inputPath);
+
+    const saveCacheMock = jest
+        .spyOn(cache, "saveCache")
+        .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;
+        });
+
+    await run();
+
+    expect(saveCacheMock).toHaveBeenCalledTimes(1);
+    expect(saveCacheMock).toHaveBeenCalledWith([inputPath], primaryKey);
+
+    expect(infoMock).toHaveBeenCalledWith(
+        `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
+    );
+    expect(logWarningMock).toHaveBeenCalledTimes(0);
    expect(failedMock).toHaveBeenCalledTimes(0);
 });

@ -219,17 +226,12 @@ test("save with server error outputs warning", async () => {
    const failedMock = jest.spyOn(core, "setFailed");

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

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

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

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

    await run();

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

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

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

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

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

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

    await run();

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

    expect(failedMock).toHaveBeenCalledTimes(0);
 });
--- a/tests/tar.test.ts
+++ b/tests/tar.test.ts
@ -1,58 +0,0 @@
-import * as exec from "@actions/exec";
-import * as io from "@actions/io";
-import * as tar from "../src/tar";
-
-jest.mock("@actions/exec");
-jest.mock("@actions/io");
-
-beforeAll(() => {
-    jest.spyOn(io, "which").mockImplementation(tool => {
-        return Promise.resolve(tool);
-    });
-});
-
-test("extract tar", async () => {
-    const mkdirMock = jest.spyOn(io, "mkdirP");
-    const execMock = jest.spyOn(exec, "exec");
-
-    const archivePath = "cache.tar";
-    const targetDirectory = "~/.npm/cache";
-    await tar.extractTar(archivePath, targetDirectory);
-
-    expect(mkdirMock).toHaveBeenCalledWith(targetDirectory);
-
-    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}"`, [
-        "-xz",
-        "-f",
-        archivePath,
-        "-C",
-        targetDirectory
-    ]);
-});
-
-test("create 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",
-        archivePath,
-        "-C",
-        sourceDirectory,
-        "."
-    ]);
-});
--- a/tests/verify-cache-files.sh
+++ b/tests/verify-cache-files.sh
@ -0,0 +1,36 @@
+#!/bin/sh
+
+# Validate args
+prefix="$1"
+if [ -z "$prefix" ]; then
+  echo "Must supply prefix argument"
+  exit 1
+fi
+
+path="$2"
+if [ -z "$path" ]; then
+  echo "Must specify path argument"
+  exit 1
+fi
+
+# Sanity check GITHUB_RUN_ID defined
+if [ -z "$GITHUB_RUN_ID" ]; then
+  echo "GITHUB_RUN_ID not defined"
+  exit 1
+fi
+
+# Verify file exists
+file="$path/test-file.txt"
+echo "Checking for $file"
+if [ ! -e $file ]; then
+  echo "File does not exist"
+  exit 1
+fi
+
+# Verify file content
+content="$(cat $file)"
+echo "File content:\n$content"
+if [ -z "$(echo $content | grep --fixed-strings "$prefix $GITHUB_RUN_ID")" ]; then
+  echo "Unexpected file content"
+  exit 1
+fi
--- a/action.yml
+++ b/action.yml
@ -1,9 +1,9 @@
 name: 'Cache'
-description: 'Cache dependencies and build outputs to improve workflow execution time'
+description: 'Cache artifacts like dependencies and build outputs to improve workflow execution time'
 author: 'GitHub'
 inputs:
  path:
-    description: 'A directory to store and save the cache'
+    description: 'A list of files, directories, and wildcard patterns to cache and restore'
    required: true
  key:
    description: 'An explicit key for restoring and saving the cache'
@ -21,4 +21,4 @@ runs:
  post-if: 'success()'
 branding:
  icon: 'archive'
-  color: 'gray-dark'
+  color: 'gray-dark'
--- 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,24 +1,41 @@
 # Examples

- [C# - NuGet](#c---nuget)
- [Elixir - Mix](#elixir---mix)
- [Go - Modules](#go---modules)
- [Java - Gradle](#java---gradle)
- [Java - Maven](#java---maven)
- [Node - npm](#node---npm)
- [Node - Yarn](#node---yarn)
- [PHP - Composer](#php---composer)
- [Python - pip](#python---pip)
- [Ruby - Gem](#ruby---gem)
- [Rust - Cargo](#rust---cargo)
- [Swift, Objective-C - Carthage](#swift-objective-c---carthage)
- [Swift, Objective-C - CocoaPods](#swift-objective-c---cocoapods)
+- [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)
+  - [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
 Using [NuGet lock files](https://docs.microsoft.com/nuget/consume-packages/package-references-in-project-files#locking-dependencies):

 ```yaml
- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: ~/.nuget/packages
    key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
@ -27,13 +44,25 @@ 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.
-If you do not want to include them, consider to move the cache folder like below.
+With `actions/cache@v2` you can now exclude unwanted packages with [exclude pattern](https://github.com/actions/toolkit/tree/master/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.
 >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@v1
+  - uses: actions/cache@v2
    with:
      path: ${{ github.workspace }}/.nuget/packages
      key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
@ -41,9 +70,33 @@ 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@v1
+- uses: actions/cache@v2
  with:
    path: deps
    key: ${{ runner.os }}-mix-${{ hashFiles(format('{0}{1}', github.workspace, '/mix.lock')) }}
@ -54,7 +107,7 @@ steps:
 ## Go - Modules

 ```yaml
- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: ~/go/pkg/mod
    key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
@ -62,13 +115,28 @@ steps:
      ${{ runner.os }}-go-
 ```

+## Haskell - Cabal
+
+We cache the elements of the Cabal store separately, as the entirety of `~/.cabal` can grow very large for projects with many dependencies.
+
+```yaml
+- uses: actions/cache@v2
+  name: Cache ~/.cabal/packages, ~/.cabal/store and dist-newstyle
+  with:
+    path: |
+      ~/.cabal/packages
+      ~/.cabal/store
+      dist-newstyle
+    key: ${{ runner.os }}-${{ matrix.ghc }}
+```
+
 ## Java - Gradle

 ```yaml
- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: ~/.gradle/caches
-    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+    key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
    restore-keys: |
      ${{ runner.os }}-gradle-
 ```
@ -76,7 +144,7 @@ steps:
 ## Java - Maven

 ```yaml
- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: ~/.m2/repository
    key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
@ -93,7 +161,7 @@ For npm, cache files are stored in `~/.npm` on Posix, or `%AppData%/npm-cache` o
 ### macOS and Ubuntu

 ```yaml
- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@ -104,22 +172,11 @@ For npm, cache files are stored in `~/.npm` on Posix, or `%AppData%/npm-cache` o
 ### Windows

 ```yaml
- uses: actions/cache@v1
-  with:
-    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  
 - name: Get npm cache directory
  id: npm-cache
  run: |
    echo "::set-output name=dir::$(npm config get cache)"
- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: ${{ steps.npm-cache.outputs.dir }}
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@ -127,30 +184,86 @@ For npm, cache files are stored in `~/.npm` on Posix, or `%AppData%/npm-cache` o
      ${{ runner.os }}-node-
 ```

+### Using multiple systems and `npm config`
+
+```yaml
+- name: Get npm cache directory
+  id: npm-cache
+  run: |
+    echo "::set-output name=dir::$(npm config get cache)"
+- uses: actions/cache@v2
+  with:
+    path: ${{ steps.npm-cache.outputs.dir }}
+    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+    restore-keys: |
+      ${{ 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
-  id: yarn-cache
+- name: Get yarn cache directory path
+  id: yarn-cache-dir-path
  run: echo "::set-output name=dir::$(yarn cache dir)"

- uses: actions/cache@v1
+- 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.outputs.dir }}
+    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@v1
+- uses: actions/cache@v2
  with:
    path: ${{ steps.composer-cache.outputs.dir }}
    key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.lock') }}
@ -169,7 +282,7 @@ Locations:

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

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

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

- uses: actions/cache@v1
+- uses: actions/cache@v2
  if: startsWith(runner.os, 'Windows')
  with:
    path: ~\AppData\Local\pip\Cache
@ -207,16 +320,34 @@ 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
-   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 dir
+ id: pip-cache
+ run: |
+   python -c "from pip._internal.locations import USER_CACHE_DIR; print('::set-output name=dir::' + USER_CACHE_DIR)"

- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: ${{ steps.pip-cache.outputs.dir }}
    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
@ -224,15 +355,64 @@ Replace `~/.cache/pip` with the correct `path` if not using Ubuntu.
      ${{ runner.os }}-pip-
 ```

-## Ruby - Gem
+## R - renv
+
+For renv, the cache directory will vary by OS. Look at https://rstudio.github.io/renv/articles/renv.html#cache
+
+Locations:
+ - Ubuntu: `~/.local/share/renv`
+ - macOS: `~/Library/Application Support/renv`
+ - Windows: `%LOCALAPPDATA%/renv`
+
+### Simple example
+```yaml
+- uses: actions/cache@v2
+  with:
+    path: ~/.local/share/renv
+    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
+    restore-keys: |
+      ${{ runner.os }}-renv-
+```
+
+Replace `~/.local/share/renv` with the correct `path` if not using Ubuntu.
+
+### Multiple OS's in a workflow

 ```yaml
- uses: actions/cache@v1
+- uses: actions/cache@v2
+  if: startsWith(runner.os, 'Linux')
+  with:
+    path: ~/.local/share/renv
+    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
+    restore-keys: |
+      ${{ runner.os }}-renv-
+
+- uses: actions/cache@v2
+  if: startsWith(runner.os, 'macOS')
+  with:
+    path: ~/Library/Application Support/renv
+    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
+    restore-keys: |
+      ${{ runner.os }}-renv-
+
+- uses: actions/cache@v2
+  if: startsWith(runner.os, 'Windows')
+  with:
+    path: ~\AppData\Local\renv
+    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
+    restore-keys: |
+      ${{ runner.os }}-renv-
+```
+
+## Ruby - Bundler
+
+```yaml
+- uses: actions/cache@v2
  with:
    path: vendor/bundle
-    key: ${{ runner.os }}-gem-${{ hashFiles('**/Gemfile.lock') }}
+    key: ${{ runner.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
    restore-keys: |
-      ${{ runner.os }}-gem-
+      ${{ runner.os }}-gems-
 ```
 When dependencies are installed later in the workflow, we must specify the same path for the bundler.

@ -246,27 +426,31 @@ When dependencies are installed later in the workflow, we must specify the same
 ## Rust - Cargo

 ```yaml
- name: Cache cargo registry
-  uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
-    path: ~/.cargo/registry
-    key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
- name: Cache cargo index
-  uses: actions/cache@v1
+    path: |
+      ~/.cargo/registry
+      ~/.cargo/git
+      target
+    key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+```
+
+## Scala - SBT
+
+```yaml
+- name: Cache SBT
+  uses: actions/cache@v2
  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') }}
+    path: | 
+      ~/.ivy2/cache
+      ~/.sbt
+    key: ${{ runner.os }}-sbt-${{ hashFiles('**/build.sbt') }}
 ```

 ## Swift, Objective-C - Carthage

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

 ```yaml
- uses: actions/cache@v1
+- uses: actions/cache@v2
  with:
    path: Pods
    key: ${{ runner.os }}-pods-${{ hashFiles('**/Podfile.lock') }}
    restore-keys: |
      ${{ runner.os }}-pods-
 ```
+
+## Swift - Swift Package Manager
+
+```yaml
+- uses: actions/cache@v2
+  with:
+    path: .build
+    key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
+    restore-keys: |
+      ${{ runner.os }}-spm-
+```
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,16 +1,15 @@
 {
  "name": "cache",
-  "version": "1.0.3",
+  "version": "1.1.2",
  "private": true,
  "description": "Cache dependencies and build outputs",
  "main": "dist/restore/index.js",
  "scripts": {
-    "build": "tsc",
+    "build": "tsc && ncc build -o dist/restore src/restore.ts && ncc build -o dist/save src/save.ts",
    "test": "tsc --noEmit && jest --coverage",
    "lint": "eslint **/*.ts --cache",
    "format": "prettier --write **/*.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/"
+    "format-check": "prettier --check **/*.ts"
  },
  "repository": {
    "type": "git",
@ -27,14 +26,12 @@
    "@actions/core": "^1.2.0",
    "@actions/exec": "^1.0.1",
    "@actions/io": "^1.0.1",
-    "typed-rest-client": "^1.5.0",
-    "uuid": "^3.3.3"
+    "@actions/cache": "^0.2.1"
  },
  "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",
@ -43,6 +40,7 @@
    "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
@ -1,129 +0,0 @@
-import * as core from "@actions/core";
-import * as fs from "fs";
-import { BearerCredentialHandler } from "typed-rest-client/Handlers";
-import { HttpClient } from "typed-rest-client/HttpClient";
-import { IHttpClientResponse } from "typed-rest-client/Interfaces";
-import { IRequestOptions, RestClient } from "typed-rest-client/RestClient";
-import { ArtifactCacheEntry } from "./contracts";
-
-function getCacheUrl(): string {
-    // Ideally we just use ACTIONS_CACHE_URL
-    const cacheUrl: string = (
-        process.env["ACTIONS_CACHE_URL"] ||
-        process.env["ACTIONS_RUNTIME_URL"] ||
-        ""
-    ).replace("pipelines", "artifactcache");
-    if (!cacheUrl) {
-        throw new Error(
-            "Cache Service Url not found, unable to restore cache."
-        );
-    }
-
-    core.debug(`Cache Url: ${cacheUrl}`);
-    return cacheUrl;
-}
-
-function createAcceptHeader(type: string, apiVersion: string): string {
-    return `${type};api-version=${apiVersion}`;
-}
-
-function getRequestOptions(): IRequestOptions {
-    const requestOptions: IRequestOptions = {
-        acceptHeader: createAcceptHeader("application/json", "5.2-preview.1")
-    };
-
-    return requestOptions;
-}
-
-export async function getCacheEntry(
-    keys: string[]
-): Promise<ArtifactCacheEntry | null> {
-    const cacheUrl = getCacheUrl();
-    const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
-    const bearerCredentialHandler = new BearerCredentialHandler(token);
-
-    const resource = `_apis/artifactcache/cache?keys=${encodeURIComponent(
-        keys.join(",")
-    )}`;
-
-    const restClient = new RestClient("actions/cache", cacheUrl, [
-        bearerCredentialHandler
-    ]);
-
-    const response = await restClient.get<ArtifactCacheEntry>(
-        resource,
-        getRequestOptions()
-    );
-    if (response.statusCode === 204) {
-        return null;
-    }
-    if (response.statusCode !== 200) {
-        throw new Error(`Cache service responded with ${response.statusCode}`);
-    }
-    const cacheResult = response.result;
-    if (!cacheResult || !cacheResult.archiveLocation) {
-        throw new Error("Cache not found.");
-    }
-    core.setSecret(cacheResult.archiveLocation);
-    core.debug(`Cache Result:`);
-    core.debug(JSON.stringify(cacheResult));
-
-    return cacheResult;
-}
-
-async function pipeResponseToStream(
-    response: IHttpClientResponse,
-    stream: NodeJS.WritableStream
-): Promise<void> {
-    return new Promise(resolve => {
-        response.message.pipe(stream).on("close", () => {
-            resolve();
-        });
-    });
-}
-
-export async function downloadCache(
-    cacheEntry: ArtifactCacheEntry,
-    archivePath: string
-): Promise<void> {
-    const stream = fs.createWriteStream(archivePath);
-    const httpClient = new HttpClient("actions/cache");
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const downloadResponse = await httpClient.get(cacheEntry.archiveLocation!);
-    await pipeResponseToStream(downloadResponse, stream);
-}
-
-export async function saveCache(
-    key: string,
-    archivePath: string
-): Promise<void> {
-    const stream = fs.createReadStream(archivePath);
-
-    const cacheUrl = getCacheUrl();
-    const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
-    const bearerCredentialHandler = new BearerCredentialHandler(token);
-
-    const resource = `_apis/artifactcache/cache/${encodeURIComponent(key)}`;
-    const postUrl = cacheUrl + resource;
-
-    const restClient = new RestClient("actions/cache", undefined, [
-        bearerCredentialHandler
-    ]);
-
-    const requestOptions = getRequestOptions();
-    requestOptions.additionalHeaders = {
-        "Content-Type": "application/octet-stream"
-    };
-
-    const response = await restClient.uploadStream<void>(
-        "POST",
-        postUrl,
-        stream,
-        requestOptions
-    );
-    if (response.statusCode !== 200) {
-        throw new Error(`Cache service responded with ${response.statusCode}`);
-    }
-
-    core.info("Cache saved successfully");
-}
--- a/src/constants.ts
+++ b/src/constants.ts
@ -9,8 +9,8 @@ export enum Outputs {
 }

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

 export enum Events {
@ -18,3 +18,5 @@ export enum Events {
    Push = "push",
    PullRequest = "pull_request"
 }
+
+export const RefKey = "GITHUB_REF";
--- a/src/contracts.d.ts
+++ b/src/contracts.d.ts
@ -1,6 +0,0 @@
-export interface ArtifactCacheEntry {
-    cacheKey?: string;
-    scope?: string;
-    creationTime?: string;
-    archiveLocation?: string;
-}
--- a/src/restore.ts
+++ b/src/restore.ts
@ -1,8 +1,7 @@
+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> {
@ -12,94 +11,54 @@ async function run(): Promise<void> {
            utils.logWarning(
                `Event Validation Error: The event type ${
                    process.env[Events.Key]
-                } is not supported. Only ${utils
-                    .getSupportedEvents()
-                    .join(", ")} events are supported at this time.`
+                } is not supported because it's not tied to a branch or tag ref.`
            );
            return;
        }

-        const cachePath = utils.resolvePath(
-            core.getInput(Inputs.Path, { required: true })
-        );
-        core.debug(`Cache Path: ${cachePath}`);
-
        const primaryKey = core.getInput(Inputs.Key, { required: true });
-        core.saveState(State.CacheKey, primaryKey);
+        core.saveState(State.CachePrimaryKey, 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;
-            }
-        }
+        const cachePaths = core
+            .getInput(Inputs.Path, { required: true })
+            .split("\n")
+            .filter(x => x !== "");

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

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

-            // Store the cache result
-            utils.setCacheState(cacheEntry);
-
-            // Download the cache from the cache entry
-            await cacheHttpClient.downloadCache(cacheEntry, 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
-            );
+            const isExactKeyMatch = utils.isExactKeyMatch(primaryKey, cacheKey);
            utils.setCacheHitOutput(isExactKeyMatch);

-            core.info(
-                `Cache restored from key: ${cacheEntry && cacheEntry.cacheKey}`
-            );
+            core.info(`Cache restored from key: ${cacheKey}`);
        } catch (error) {
-            utils.logWarning(error.message);
-            utils.setCacheHitOutput(false);
+            if (error.name === cache.ValidationError.name) {
+                throw error;
+            } else {
+                utils.logWarning(error.message);
+                utils.setCacheHitOutput(false);
+            }
        }
    } catch (error) {
        core.setFailed(error.message);
--- a/src/save.ts
+++ b/src/save.ts
@ -1,8 +1,7 @@
+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> {
@ -11,9 +10,7 @@ async function run(): Promise<void> {
            utils.logWarning(
                `Event Validation Error: The event type ${
                    process.env[Events.Key]
-                } is not supported. Only ${utils
-                    .getSupportedEvents()
-                    .join(", ")} events are supported at this time.`
+                } is not supported because it's not tied to a branch or tag ref.`
            );
            return;
        }
@ -21,7 +18,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.CacheKey);
+        const primaryKey = core.getState(State.CachePrimaryKey);
        if (!primaryKey) {
            utils.logWarning(`Error retrieving key from state.`);
            return;
@ -34,32 +31,22 @@ async function run(): Promise<void> {
            return;
        }

-        const cachePath = utils.resolvePath(
-            core.getInput(Inputs.Path, { required: true })
-        );
-        core.debug(`Cache Path: ${cachePath}`);
+        const cachePaths = core
+            .getInput(Inputs.Path, { required: true })
+            .split("\n")
+            .filter(x => x !== "");

-        const archivePath = path.join(
-            await utils.createTempDirectory(),
-            "cache.tgz"
-        );
-        core.debug(`Archive Path: ${archivePath}`);
-
-        await createTar(archivePath, cachePath);
-
-        const fileSizeLimit = 400 * 1024 * 1024; // 400MB
-        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 400MB limit, not saving cache.`
-            );
-            return;
+        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);
+            }
        }
-
-        await cacheHttpClient.saveCache(primaryKey, archivePath);
    } catch (error) {
        utils.logWarning(error.message);
    }
--- a/src/tar.ts
+++ b/src/tar.ts
@ -1,47 +0,0 @@
-import { exec } from "@actions/exec";
-import * as io from "@actions/io";
-import { existsSync } from "fs";
-
-async function getTarPath(): Promise<string> {
-    // Explicitly use BSD Tar on Windows
-    const IS_WINDOWS = process.platform === "win32";
-    if (IS_WINDOWS) {
-        const systemTar = `${process.env["windir"]}\\System32\\tar.exe`;
-        if (existsSync(systemTar)) {
-            return systemTar;
-        }
-    }
-    return await io.which("tar", true);
-}
-
-async function execTar(args: string[]): Promise<void> {
-    try {
-        await exec(`"${await getTarPath()}"`, args);
-    } catch (error) {
-        const IS_WINDOWS = process.platform === "win32";
-        if (IS_WINDOWS) {
-            throw new Error(
-                `Tar failed with error: ${error?.message}. Ensure BSD tar is installed and on the PATH.`
-            );
-        }
-        throw new Error(`Tar failed with error: ${error?.message}`);
-    }
-}
-
-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, "-C", targetDirectory];
-    await execTar(args);
-}
-
-export async function createTar(
-    archivePath: string,
-    sourceDirectory: string
-): Promise<void> {
-    const args = ["-cz", "-f", archivePath, "-C", sourceDirectory, "."];
-    await execTar(args);
-}
--- a/src/utils/actionUtils.ts
+++ b/src/utils/actionUtils.ts
@ -1,77 +1,35 @@
 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 { Events, Outputs, State } from "../constants";
-import { ArtifactCacheEntry } from "../contracts";
+import { Outputs, RefKey, State } from "../constants";

-// From https://github.com/actions/toolkit/blob/master/packages/tool-cache/src/tool-cache.ts#L23
-export async function createTempDirectory(): Promise<string> {
-    const IS_WINDOWS = process.platform === "win32";
-
-    let tempDirectory: string = process.env["RUNNER_TEMP"] || "";
-
-    if (!tempDirectory) {
-        let baseLocation: string;
-        if (IS_WINDOWS) {
-            // On Windows use the USERPROFILE env variable
-            baseLocation = process.env["USERPROFILE"] || "C:\\";
-        } else {
-            if (process.platform === "darwin") {
-                baseLocation = "/Users";
-            } else {
-                baseLocation = "/home";
-            }
-        }
-        tempDirectory = path.join(baseLocation, "actions", "temp");
-    }
-    const dest = path.join(tempDirectory, uuidV4.default());
-    await io.mkdirP(dest);
-    return dest;
-}
-
-export function getArchiveFileSize(path: string): number {
-    return fs.statSync(path).size;
-}
-
-export function isExactKeyMatch(
-    key: string,
-    cacheResult?: ArtifactCacheEntry
-): boolean {
+export function isExactKeyMatch(key: string, cacheKey?: string): boolean {
    return !!(
-        cacheResult &&
-        cacheResult.cacheKey &&
-        cacheResult.cacheKey.localeCompare(key, undefined, {
+        cacheKey &&
+        cacheKey.localeCompare(key, undefined, {
            sensitivity: "accent"
        }) === 0
    );
 }

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

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

-export function setOutputAndState(
-    key: string,
-    cacheResult?: ArtifactCacheEntry
-): void {
-    setCacheHitOutput(isExactKeyMatch(key, cacheResult));
-    // Store the cache result if it exists
-    cacheResult && setCacheState(cacheResult);
+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 getCacheState(): ArtifactCacheEntry | undefined {
-    const stateData = core.getState(State.CacheResult);
-    core.debug(`State: ${stateData}`);
-    if (stateData) {
-        return JSON.parse(stateData) as ArtifactCacheEntry;
+export function getCacheState(): string | undefined {
+    const cacheKey = core.getState(State.CacheMatchedKey);
+    if (cacheKey) {
+        core.debug(`Cache state/key: ${cacheKey}`);
+        return cacheKey;
    }

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

-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 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
+// 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 {
-    const githubEvent = process.env[Events.Key] || "";
-    return getSupportedEvents().includes(githubEvent);
+    return RefKey in process.env && Boolean(process.env[RefKey]);
 }
Author	SHA1	Message	Date
Aiqiao Yan	b8204782bb	Merge pull request #329 from actions/aiyan/v2-release-doc Update readme and examples to use v2	2020-05-26 15:35:50 -04:00
Aiqiao Yan	e6c708b5ce	React to feedback	2020-05-26 15:31:33 -04:00
Aiqiao Yan	581312be20	Update readme and examples to use v2	2020-05-26 12:48:39 -04:00
Aiqiao Yan	9ab95382c8	Merge pull request #313 from actions/aiyan/use-cache-package Switch cache action to use the cache node package	2020-05-20 15:26:12 -04:00
Aiqiao Yan	6c7d57dc97	Use 0.2.1 cache package	2020-05-20 15:20:07 -04:00
Josh Gross	2b83e91661	Add examples for creating a cache key (#312 )	2020-05-20 10:54:39 -04:00
Aiqiao Yan	1034aaeec8	Testing fix for a bug in the cache package	2020-05-19 16:02:31 -04:00
Aiqiao Yan	bcc23b930f	React to feeback and change to use 0.2.0 cache package	2020-05-19 15:53:25 -04:00
Aiqiao Yan	249a22026d	Update workflow.yml	2020-05-18 11:32:03 -04:00
Aiqiao Yan	7f9517a009	Switch cache action to use the cache node package	2020-05-15 15:07:37 -04:00
Aiqiao Yan	16a133d9a7	Merge pull request #263 from actions/users/aiyan/allow-all-events Allow all events to access cache	2020-05-15 14:13:16 -04:00
Justin Poehnelt	46fead7f5e	docs: add note about branch scope (#307 ) * docs: add note about branch scope * revert change	2020-05-15 13:28:56 -04:00
David Hadka	bac1a40c81	Merge pull request #306 from actions/with-retries Add retries to all API calls	2020-05-11 16:56:45 -05:00
Aiqiao Yan	916cc60b3c	Merge pull request #300 from actions/aiyan/listen-on-error error handling for stream	2020-05-11 16:00:51 -04:00
Aiqiao Yan	4967c8e6c5	error handling for stream	2020-05-11 15:21:21 -04:00
Dave Hadka	a0024e2bd0	Merge branch 'master' of http://github.com/actions/cache into with-retries	2020-05-11 12:55:11 -04:00
David Hadka	5ddc028cc8	Merge pull request #305 from actions/fix-upload-chunk Fix upload chunk retries	2020-05-11 11:51:23 -05:00
Dave Hadka	05b13411a0	Add retries to all API calls	2020-05-11 11:11:25 -04:00
Dave Hadka	e756b19f93	Merge branch 'master' of http://github.com/actions/cache into fix-upload-chunk	2020-05-11 10:57:11 -04:00
Dave Hadka	354f70a56c	Fix upload chunk retries	2020-05-11 10:49:48 -04:00
Shigeki Karita	ddc4681e8d	Add D example. (#303 )	2020-05-11 10:24:05 -04:00
Aiqiao Yan	29b4783cc7	Merge fixes	2020-05-11 10:18:19 -04:00
Aiqiao Yan	2403bbedac	Make sure ref is not null or empty	2020-05-11 10:16:07 -04:00
Aiqiao Yan	ccc66f769e	Allow all events to access cache	2020-05-11 10:16:07 -04:00
David Hadka	5d8c995f20	Detect uncommitted changes to the dist/ folder (#302 ) * Update workflow.yml * Update workflow.yml * Run build * Update workflow.yml * Update workflow.yml * Update workflow.yml	2020-05-11 09:53:08 -04:00
Justin Hutchings	ce9276c90e	Add CodeQL Analysis workflow (#283 ) * Add CodeQL Analysis workflow * Rename .github/workflows/workflows/codeql.yml to .github/workflows/codeql.yml * Clean up commented out stuff	2020-05-05 17:28:32 -04:00
Aiqiao Yan	9eb452c280	Merge pull request #270 from actions/users/aiyan/zstd Prefer zstd over gzip	2020-05-04 10:39:28 -04:00
Aiqiao Yan	75cd46ec0c	Use 30 as the long distance matching window to support both 32-bit and 64-bit OS	2020-05-01 14:25:15 -04:00
Aiqiao Yan	a5d9a3b1a6	Address PR feedback	2020-05-01 10:01:43 -04:00
Aiqiao Yan	97f7baa910	Use zstd instead of gzip if available Add zstd to cache versioning	2020-04-30 14:40:17 -04:00
dependabot[bot]	9ceee97d99	Bump @actions/http-client from 1.0.6 to 1.0.8 (#286 ) Bumps [@actions/http-client](https://github.com/actions/http-client) from 1.0.6 to 1.0.8. - [Release notes](https://github.com/actions/http-client/releases) - [Changelog](https://github.com/actions/http-client/blob/master/RELEASES.md) - [Commits](https://github.com/actions/http-client/commits) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-04-29 18:10:58 -04:00
Hugo van Kemenade	ccf9619480	Add Python example using 'pip cache dir' to get cache location (#285 ) * Fix existing example * Add Python example using 'pip cache dir' to get cache location * Let users decide how they install pip 20.1+	2020-04-29 14:58:19 -04:00
David Hadka	9f07ee13de	Merge pull request #284 from actions/promisify-pipeline Better error handling during download	2020-04-29 13:50:12 -05:00
Dave Hadka	1ed0c23029	Use promisify of stream.pipeline for downloading	2020-04-29 13:24:26 -04:00
David Hadka	54626c4a4f	Merge pull request #269 from actions/socket-timeout Adds socket timeout and validate file size	2020-04-29 12:21:27 -05:00
Dave Hadka	48b62c1c52	Add comment for SocketTimeout	2020-04-28 21:31:41 -04:00
Dave Hadka	9bb13c71ec	Fix lint issue, build .js files	2020-04-22 18:35:16 -04:00
Dave Hadka	8b2a57849f	Adds socket timeout and validate file size	2020-04-22 18:23:41 -04:00
Matija Čupić	f00dedfa6c	Use checkout@v2 in README example (#258 )	2020-04-16 11:50:47 -04:00
Aiqiao Yan	12b87469d4	Merge pull request #252 from actions/users/aiyan/fallback-to-gnu-tar Fallback to GNU tar if BSD tar is unavailable on windows machine	2020-04-13 13:32:01 -04:00
Aiqiao Yan	52046d1409	Use path.sep in path replace	2020-04-13 12:20:27 -04:00
Aiqiao Yan	08438313d5	Fix macOs-latest test	2020-04-10 15:50:35 -04:00
Aiqiao Yan	7ccdf5c70d	Rebase and rebuild	2020-04-10 15:34:34 -04:00
Aiqiao Yan	306f72536b	Fix test	2020-04-10 15:33:43 -04:00
Aiqiao Yan	4fa017f2b7	Fallback to GNU tar if BSD tar is unavailable	2020-04-10 15:33:43 -04:00
David Hadka	78809b91d7	Merge pull request #250 from actions/test-relative-path Fix caching directories outside of the working directory (relative paths)	2020-04-08 10:37:26 -05:00
Josh Gross	a4e3c3b64e	Add -P flag for tar creation	2020-04-08 10:58:38 -04:00
Josh Gross	e5370355e6	Combine relative jobs into main test jobs	2020-04-08 10:52:52 -04:00
David Hadka	0e86d5c038	Update workflow.yml	2020-04-07 23:41:38 -04:00
David Hadka	2ba9edf492	Fix job names v2	2020-04-07 23:37:50 -04:00
David Hadka	f15bc7a0d9	Fix job names	2020-04-07 23:33:13 -04:00
David Hadka	b6b8aa78d8	Update workflow.yml	2020-04-07 23:31:27 -04:00
David Hadka	272268544c	Add path argument to verify-cache-files.sh	2020-04-07 23:30:01 -04:00
David Hadka	64f8769515	Add path argument to create-cache-files.sh	2020-04-07 23:29:07 -04:00
David Hadka	4a724707e9	Add test for relative paths	2020-04-07 23:28:05 -04:00
Josh Gross	f60097cd16	Fix Lerna Example (#242 ) * Fix lerna example * Fix yaml spacing	2020-04-02 10:35:07 -04:00
Ethan Dennis	eb78578266	Cache multiple paths and add glob pattern support (#212 ) * Allow for multiple line-delimited paths to cache * Add initial minimatch support * Use @actions/glob for pattern matching * Cache multiple entries using --files-from tar input remove known failing test Quote tar paths Add salt to test cache Try reading input files from manifest bump salt Run test on macos more testing Run caching tests on 3 platforms Run tests on self-hosted Apparently cant reference hosted runners by name Bump salt wait for some time after save more timing out smarter waiting Cache in tmp dir that won't be deleted Use child_process instead of actions/exec Revert tempDir hack bump salt more logging More console logging Use filepath to with cacheHttpClient Test cache restoration Revert temp dir hack debug logging clean up cache.yml testing Bump salt change debug output build actions * unit test coverage for caching multiple dirs * Ensure there's a locateable test folder at homedir * Clean up code * Version cache with all inputs * Unit test getCacheVersion * Include keys in getCacheEntry request * Clean import orders * Use fs promises in actionUtils tests * Update import order for to fix linter errors * Fix remaining linter error * Remove platform-specific test code * Add lerna example for caching multiple dirs * Lerna example updated to v2 Co-Authored-By: Josh Gross <joshmgross@github.com> Co-authored-by: Josh Gross <joshmgross@github.com>	2020-03-20 16:02:11 -04:00
Dylan Musil	22d71e33ad	Update Node Windows example to find the npm cache (#223 )	2020-03-18 22:05:56 -04:00
BSKY	b13df3fa54	Update README.md (#213 )	2020-03-18 09:44:24 -04:00
Henry Mercer	cae64ca3cd	Attempt to delete the archive after extraction (#209 ) This reduces storage space used once the Action has finished executing.	2020-03-18 09:43:56 -04:00
Jeremy Loy	af8651e0c5	Include Kotlinscript Gradle files (#216 ) Tested this with my own repo which uses a mix of `build.gradle` and `build.gradle.kts` files and this glob seems to be working correctly. As an aside, please checkout #215 as it would make the process of verifying these globs easier!	2020-03-18 09:40:55 -04:00
BSKY	6c471ae9f6	Add eslint-plugin-simple-import-sort (#219 ) * Add eslint-plugin-simple-import-sort * Update .eslintrc.json * eslint --fix	2020-03-18 09:35:13 -04:00
Josh Gross	206172ea8e	npm audit fix (#221 )	2020-03-18 09:31:59 -04:00
dependabot[bot]	5833d5c131	Bump acorn from 5.7.3 to 5.7.4 (#214 ) Bumps [acorn](https://github.com/acornjs/acorn) from 5.7.3 to 5.7.4. - [Release notes](https://github.com/acornjs/acorn/releases) - [Commits](https://github.com/acornjs/acorn/compare/5.7.3...5.7.4) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-03-17 16:12:29 -04:00
Sacha Ayoun	826785142a	Adding examples for OCaml/esy (#199 ) * Adding examples for esy as a workflow for OCaml files * track v1 instead of v1.1.2 Co-Authored-By: Josh Gross <joshmgross@github.com> * add link in the readme for ocaml-esy * ocaml -> ocaml/reason * link in readme says ocaml/reason Co-authored-by: Josh Gross <joshmgross@github.com>	2020-02-26 17:43:11 -05:00
Carlos Guerrero	8e9c167fd7	Small message change (#195 ) * Small message change Remove dot that generates confusion in wether that's part of the key or not * Fix format-check * Update tests	2020-02-25 14:16:36 -05:00
Kipras Melnikovas	e8230b28a9	Use different IDs for 1) getting the directory of yarn cache 2) the cache itself (#178 ) * Use different IDs for 1) getting the directory of yarn cache 2) the cache itself Using the current example + https://github.com/actions/cache#skipping-steps-based-on-cache-hit, I came to a wrong conclusion that I could skip a step if the `cache-hit` was `true` - the ID I used was from the wrong step - the `get yarn cache directory` step, instead of the `get yarn cache itself` step. I've updated the example in hopes that it'll be clearer for others aswell! Signed-off-by: Kipras Melnikovas <kipras@kipras.org> * Explain which ID to use for `cache-hit` in yarn's example Signed-off-by: Kipras Melnikovas <kipras@kipras.org>	2020-02-14 09:50:11 -05:00
eric sciple	4944275b95	test e2e during workflow (#185 )	2020-02-13 12:38:56 -05:00
Josh Gross	78a4b2143b	Bump version to 1.1.2	2020-02-05 10:40:53 -05:00
Josh Gross	4dc4b4e758	Change name back to Cache	2020-02-05 10:39:52 -05:00
Josh Gross	85aee6a487	Update docs with 5GB limit	2020-02-05 10:33:21 -05:00
Josh Gross	fab26f3f4f	Bump version to 1.1.1	2020-02-05 09:55:35 -05:00
David Kale	4887979af8	proxy support (#166 ) * Replace typed rest client with new http-client * Send Content-Type: application/json and fix up some types * Lint * Consume @actions/http-client:1.0.5 * Consume @actions/http-client:1.0.6 * Dont send headers manually, http-client automatically will	2020-02-05 09:24:37 -05:00
David Hadka	f9c9166ecb	Increase cache limit to 5 GBs (#168 ) * Increase cache limit to 5 GBs * Fix test to use new size limit * Update src/save.ts Co-Authored-By: Josh Gross <joshmgross@github.com> Co-authored-by: Josh Gross <joshmgross@github.com>	2020-02-01 16:11:02 -05:00
Josh Gross	23e301d35c	Disable fail-fast to get full coverage of failures	2020-01-29 20:34:56 -05:00
Florian Kostenzer	e43776276f	Add Swift Package Manager (SPM) example (#159 ) * Add Swift - SPM to examples * Add link SPM example link to readme * remove extra newline * remove another extra newline	2020-01-29 11:13:59 -05:00
Shinya Uryu	b6d538e2aa	Add renv examples (#151 ) * Add renv examples * Add link in main readme.md	2020-01-21 19:22:40 -05:00
Edward Thomson	296374f6c9	Update action's description (#75 ) * README: clarify case on the action * Update description	2020-01-14 10:11:41 -05:00
Mike Coutermarsh	6c11532937	Update Ruby docs. "Gem" -> "Bundler" (#150 ) * Use "Bundler" which is the package manager "Gem" isn't wrong, but not typically what a Ruby developer would think of. * Update links * Update links	2020-01-12 18:48:43 -05:00
Daniel Shuy	c33bff8d72	Add Scala - SBT example (#134 ) * Add Scala - SBT example * Add Scala - SBT example to README	2020-01-10 17:09:06 -05:00
Flavio Corpa	d1991bb4c5	Add Haskell - Cabal example (#148 ) * Add Haskell - Cabal example * Add link in main readme.md	2020-01-10 17:07:52 -05:00
Josh Gross	60e292adf7	Update cache limits (#140 )	2020-01-07 15:01:47 -05:00
Josh Gross	c262ac0154	Fix number parsing issues	2020-01-06 14:06:24 -05:00
Josh Gross	1da52de10f	npm audit fix	2020-01-06 13:31:03 -05:00
Josh Gross	b45d91cc4b	Chunked Cache Upload APIs (#128 ) * Initial pass at chunked upload apis * Fix cacheEntry type * Linting * Fix download cache entry tests * Linting tests * Pull in fixes from testing branch * Fix typo in ReserveCacheResponse * Add test convering reserve cache failure * Add retries to upload chunk * PR feedback * Format default chunk size * Remove responses array	2020-01-06 13:05:50 -05:00