.github/workflows/workflow.yml

@@ -4,130 +4,50 @@ on:
   pull_request:
     branches:
       - master
-      - releases/**
     paths-ignore:
       - '**.md'
   push:
     branches:
       - master
-      - releases/**
     paths-ignore:
       - '**.md'
 
 jobs:
-  # Build and unit test
+  test:
-  build:
+    name: Test on ${{ matrix.os }}
+
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
+
     runs-on: ${{ matrix.os }}
+
     steps:
-    - name: Checkout
+    - uses: actions/checkout@v1
-      uses: actions/checkout@v2
+
-    - name: Setup Node.js
+    - uses: actions/setup-node@v1
-      uses: actions/setup-node@v1
       with:
         node-version: '12.x'
-    - name: Determine npm cache directory
+
+    - name: Get npm cache directory
       id: npm-cache
       run: |
         echo "::set-output name=dir::$(npm config get cache)"
-    - name: Restore npm cache
+
-      uses: actions/cache@v1
+    - uses: actions/cache@v1
       with:
         path: ${{ steps.npm-cache.outputs.dir }}
         key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
         restore-keys: |
           ${{ runner.os }}-node-
+
     - run: npm ci
+
     - name: Prettier Format Check
       run: npm run format-check
+
     - name: ESLint Check
       run: npm run lint
+
     - name: Build & Test
       run: npm run test
-
-  # End to end save and restore
-  test-save:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Generate files
-      shell: bash
-      run: __tests__/create-cache-files.sh ${{ runner.os }}
-    - name: Save cache
-      uses: ./
-      with:
-        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: test-cache
-  test-restore:
-    needs: test-save
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Restore cache
-      uses: ./
-      with:
-        key: test-${{ runner.os }}-${{ github.run_id }}
-        path: test-cache
-    - name: Verify cache
-      shell: bash
-      run: __tests__/verify-cache-files.sh ${{ runner.os }}
-
-  # 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: ubuntu/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
-    - 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: ubuntu/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

.gitignore

@@ -94,6 +94,3 @@ typings/
 
 # DynamoDB Local files
 .dynamodb/
-
-# Text editor files
-.vscode/

README.md

@@ -1,6 +1,6 @@
 # cache
 
-This action allows caching dependencies and build outputs to improve workflow execution time.
+This GitHub 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>
 
@@ -63,24 +63,21 @@ See [Examples](examples.md) for a list of `actions/cache` implementations for us
 - [C# - Nuget](./examples.md#c---nuget)
 - [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 - Yarn](./examples.md#node---yarn)
 - [PHP - Composer](./examples.md#php---composer)
 - [Python - pip](./examples.md#python---pip)
-- [R - renv](./examples.md#r---renv)
+- [Ruby - Gem](./examples.md#ruby---gem)
-- [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)
+
 
 ## Cache Limits
 
-A repository can have up to 5GB of caches. Once the 5GB limit is reached, older caches will be evicted based on when the cache was last accessed.  Caches that are not accessed within the last week will also be evicted.
+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.
 
 ## Skipping steps based on cache-hit
 

__tests__/cacheHttpsClient.test.ts

@@ -1,144 +0,0 @@
-import { retry } from "../src/cacheHttpClient";
-import * as testUtils from "../src/utils/testUtils";
-
-afterEach(() => {
-    testUtils.clearInputs();
-});
-
-interface TestResponse {
-    statusCode: number;
-    result: string | null;
-}
-
-function handleResponse(
-    response: TestResponse | undefined
-): Promise<TestResponse> {
-    if (!response) {
-        fail("Retry method called too many times");
-    }
-
-    if (response.statusCode === 999) {
-        throw Error("Test Error");
-    } else {
-        return Promise.resolve(response);
-    }
-}
-
-async function testRetryExpectingResult(
-    responses: Array<TestResponse>,
-    expectedResult: string | null
-): Promise<void> {
-    responses = responses.reverse(); // Reverse responses since we pop from end
-
-    const actualResult = await retry(
-        "test",
-        () => handleResponse(responses.pop()),
-        (response: TestResponse) => response.statusCode
-    );
-
-    expect(actualResult.result).toEqual(expectedResult);
-}
-
-async function testRetryExpectingError(
-    responses: Array<TestResponse>
-): Promise<void> {
-    responses = responses.reverse(); // Reverse responses since we pop from end
-
-    expect(
-        retry(
-            "test",
-            () => handleResponse(responses.pop()),
-            (response: TestResponse) => response.statusCode
-        )
-    ).rejects.toBeInstanceOf(Error);
-}
-
-test("retry works on successful response", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry works after retryable status code", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 503,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry fails after exhausting retries", async () => {
-    await testRetryExpectingError([
-        {
-            statusCode: 503,
-            result: null
-        },
-        {
-            statusCode: 503,
-            result: null
-        },
-        {
-            statusCode: 200,
-            result: "Ok"
-        }
-    ]);
-});
-
-test("retry fails after non-retryable status code", async () => {
-    await testRetryExpectingError([
-        {
-            statusCode: 500,
-            result: null
-        },
-        {
-            statusCode: 200,
-            result: "Ok"
-        }
-    ]);
-});
-
-test("retry works after error", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 999,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        "Ok"
-    );
-});
-
-test("retry returns after client error", async () => {
-    await testRetryExpectingResult(
-        [
-            {
-                statusCode: 400,
-                result: null
-            },
-            {
-                statusCode: 200,
-                result: "Ok"
-            }
-        ],
-        null
-    );
-});

__tests__/create-cache-files.sh

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

__tests__/save.test.ts

@@ -194,7 +194,7 @@ test("save with large cache outputs warning", async () => {
 
     const createTarMock = jest.spyOn(tar, "createTar");
 
-    const cacheSize = 6 * 1024 * 1024 * 1024; //~6GB, over the 5GB limit
+    const cacheSize = 4 * 1024 * 1024 * 1024; //~4GB, over the 2GB limit
     jest.spyOn(actionUtils, "getArchiveFileSize").mockImplementationOnce(() => {
         return cacheSize;
     });
@@ -208,7 +208,7 @@ test("save with large cache outputs warning", async () => {
 
     expect(logWarningMock).toHaveBeenCalledTimes(1);
     expect(logWarningMock).toHaveBeenCalledWith(
-        "Cache size of ~6144 MB (6442450944 B) is over the 5GB limit, not saving cache."
+        "Cache size of ~4096 MB (4294967296 B) is over the 2GB limit, not saving cache."
     );
 
     expect(failedMock).toHaveBeenCalledTimes(0);

__tests__/tar.test.ts

@@ -2,8 +2,6 @@ import * as exec from "@actions/exec";
 import * as io from "@actions/io";
 import * as tar from "../src/tar";
 
-import fs = require("fs");
-
 jest.mock("@actions/exec");
 jest.mock("@actions/io");
 
@@ -13,19 +11,17 @@ beforeAll(() => {
     });
 });
 
-test("extract BSD tar", async () => {
+test("extract tar", async () => {
     const mkdirMock = jest.spyOn(io, "mkdirP");
     const execMock = jest.spyOn(exec, "exec");
 
-    const IS_WINDOWS = process.platform === "win32";
+    const archivePath = "cache.tar";
-    const archivePath = IS_WINDOWS
-        ? `${process.env["windir"]}\\fakepath\\cache.tar`
-        : "cache.tar";
     const targetDirectory = "~/.npm/cache";
     await tar.extractTar(archivePath, targetDirectory);
 
     expect(mkdirMock).toHaveBeenCalledWith(targetDirectory);
 
+    const IS_WINDOWS = process.platform === "win32";
     const tarPath = IS_WINDOWS
         ? `${process.env["windir"]}\\System32\\tar.exe`
         : "tar";
@@ -33,37 +29,13 @@ test("extract BSD tar", async () => {
     expect(execMock).toHaveBeenCalledWith(`"${tarPath}"`, [
         "-xz",
         "-f",
-        IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
+        archivePath,
         "-C",
-        IS_WINDOWS ? targetDirectory?.replace(/\\/g, "/") : targetDirectory
+        targetDirectory
     ]);
 });
 
-test("extract GNU tar", async () => {
+test("create tar", async () => {
-    const IS_WINDOWS = process.platform === "win32";
-    if (IS_WINDOWS) {
-        jest.spyOn(fs, "existsSync").mockReturnValueOnce(false);
-        jest.spyOn(tar, "isGnuTar").mockReturnValue(Promise.resolve(true));
-
-        const execMock = jest.spyOn(exec, "exec");
-        const archivePath = `${process.env["windir"]}\\fakepath\\cache.tar`;
-        const targetDirectory = "~/.npm/cache";
-
-        await tar.extractTar(archivePath, targetDirectory);
-
-        expect(execMock).toHaveBeenCalledTimes(1);
-        expect(execMock).toHaveBeenLastCalledWith(`"tar"`, [
-            "-xz",
-            "-f",
-            archivePath.replace(/\\/g, "/"),
-            "-C",
-            targetDirectory?.replace(/\\/g, "/"),
-            "--force-local"
-        ]);
-    }
-});
-
-test("create BSD tar", async () => {
     const execMock = jest.spyOn(exec, "exec");
 
     const archivePath = "cache.tar";
@@ -78,9 +50,9 @@ test("create BSD tar", async () => {
     expect(execMock).toHaveBeenCalledWith(`"${tarPath}"`, [
         "-cz",
         "-f",
-        IS_WINDOWS ? archivePath.replace(/\\/g, "/") : archivePath,
+        archivePath,
         "-C",
-        IS_WINDOWS ? sourceDirectory?.replace(/\\/g, "/") : sourceDirectory,
+        sourceDirectory,
         "."
     ]);
 });

__tests__/verify-cache-files.sh

@@ -1,30 +0,0 @@
-#!/bin/sh
-
-# Validate args
-prefix="$1"
-if [ -z "$prefix" ]; then
-  echo "Must supply prefix 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="test-cache/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

action.yml

@@ -1,5 +1,5 @@
 name: 'Cache'
-description: 'Cache artifacts like dependencies and build outputs to improve workflow execution time'
+description: 'Cache dependencies and build outputs to improve workflow execution time'
 author: 'GitHub'
 inputs:
   path:
@@ -21,4 +21,4 @@ runs:
   post-if: 'success()'
 branding:
   icon: 'archive'
-  color: 'gray-dark'
+  color: 'gray-dark'

examples.md

@@ -3,20 +3,16 @@
 - [C# - NuGet](#c---nuget)
 - [Elixir - Mix](#elixir---mix)
 - [Go - Modules](#go---modules)
-- [Haskell - Cabal](#haskell---cabal)
 - [Java - Gradle](#java---gradle)
 - [Java - Maven](#java---maven)
 - [Node - npm](#node---npm)
 - [Node - Yarn](#node---yarn)
 - [PHP - Composer](#php---composer)
 - [Python - pip](#python---pip)
-- [R - renv](#r---renv)
+- [Ruby - Gem](#ruby---gem)
-- [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):
@@ -66,28 +62,6 @@ 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@v1
-  name: Cache ~/.cabal/packages
-  with:
-    path: ~/.cabal/packages
-    key: ${{ runner.os }}-${{ matrix.ghc }}-cabal-packages
-- uses: actions/cache@v1
-  name: Cache ~/.cabal/store
-  with:
-    path: ~/.cabal/store
-    key: ${{ runner.os }}-${{ matrix.ghc }}-cabal-store
-- uses: actions/cache@v1
-  name: Cache dist-newstyle
-  with:
-    path: dist-newstyle
-    key: ${{ runner.os }}-${{ matrix.ghc }}-dist-newstyle
-```
-
 ## Java - Gradle
 
 ```yaml
@@ -250,64 +224,15 @@ Replace `~/.cache/pip` with the correct `path` if not using Ubuntu.
       ${{ runner.os }}-pip-
 ```
 
-## R - renv
+## Ruby - Gem
-
-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@v1
-  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
-  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@v1
-  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@v1
-  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@v1
   with:
     path: vendor/bundle
-    key: ${{ runner.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
+    key: ${{ runner.os }}-gem-${{ hashFiles('**/Gemfile.lock') }}
     restore-keys: |
-      ${{ runner.os }}-gems-
+      ${{ runner.os }}-gem-
 ```
 When dependencies are installed later in the workflow, we must specify the same path for the bundler.
 
@@ -338,21 +263,6 @@ When dependencies are installed later in the workflow, we must specify the same
     key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
 ```
 
-## Scala - SBT
-
-```yaml
-- name: Cache SBT ivy cache
-  uses: actions/cache@v1
-  with:
-    path: ~/.ivy2/cache
-    key: ${{ runner.os }}-sbt-ivy-cache-${{ hashFiles('**/build.sbt') }}
-- name: Cache SBT
-  uses: actions/cache@v1
-  with:
-    path: ~/.sbt
-    key: ${{ runner.os }}-sbt-${{ hashFiles('**/build.sbt') }}
-```
-
 ## Swift, Objective-C - Carthage
 
 ```yaml
@@ -374,14 +284,3 @@ When dependencies are installed later in the workflow, we must specify the same
     restore-keys: |
       ${{ runner.os }}-pods-
 ```
-
-## Swift - Swift Package Manager
-
-```yaml
-- uses: actions/cache@v1
-  with:
-    path: .build
-    key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
-    restore-keys: |
-      ${{ runner.os }}-spm-
-```

package-lock.json

@@ -1,46 +1,19 @@
 {
   "name": "cache",
-  "version": "1.2.0",
+  "version": "1.1.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
     "@actions/core": {
-      "version": "1.10.0",
+      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz",
+      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.2.0.tgz",
-      "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==",
+      "integrity": "sha512-ZKdyhlSlyz38S6YFfPnyNgCDZuAF2T0Qv5eHflNWytPS8Qjvz39bZFMry9Bb/dpSnqWcNeav5yM2CTYpJeY+Dw=="
-      "requires": {
-        "@actions/http-client": "^2.0.1",
-        "uuid": "^8.3.2"
-      },
-      "dependencies": {
-        "@actions/http-client": {
-          "version": "2.1.0",
-          "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.1.0.tgz",
-          "integrity": "sha512-BonhODnXr3amchh4qkmjPMUO8mFi/zLaaCeCAJZqch8iQqyDnVIkySjB38VHAC8IJ+bnlgfOqlhpyCUZHlQsqw==",
-          "requires": {
-            "tunnel": "^0.0.6"
-          }
-        },
-        "uuid": {
-          "version": "8.3.2",
-          "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-          "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
-        }
-      }
     },
     "@actions/exec": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/@actions/exec/-/exec-1.0.1.tgz",
       "integrity": "sha512-nvFkxwiicvpzNiCBF4wFBDfnBvi7xp/as7LE1hBxBxKG2L29+gkIPBiLKMVORL+Hg3JNf07AKRfl0V5djoypjQ=="
     },
-    "@actions/http-client": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-1.0.6.tgz",
-      "integrity": "sha512-LGmio4w98UyGX33b/W6V6Nx/sQHRXZ859YlMkn36wPsXPB82u8xTVlA/Dq2DXrm6lEq9RVmisRJa1c+HETAIJA==",
-      "requires": {
-        "tunnel": "0.0.6"
-      }
-    },
     "@actions/io": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/@actions/io/-/io-1.0.1.tgz",
@@ -5960,9 +5933,9 @@
       }
     },
     "tunnel": {
-      "version": "0.0.6",
+      "version": "0.0.4",
-      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
+      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.4.tgz",
-      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="
+      "integrity": "sha1-LTeFoVjBdMmhbcLARuxfxfF0IhM="
     },
     "tunnel-agent": {
       "version": "0.6.0",
@@ -6000,6 +5973,15 @@
       "integrity": "sha512-DWkS49EQKVX//Tbupb9TFa19c7+MK1XmzkrZUR8TAktmE/DizXoaoJV6TZ/tSIPXipqNiRI6CyAe7x69Jb6RSw==",
       "dev": true
     },
+    "typed-rest-client": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/typed-rest-client/-/typed-rest-client-1.5.0.tgz",
+      "integrity": "sha512-DVZRlmsfnTjp6ZJaatcdyvvwYwbWvR4YDNFDqb+qdTxpvaVP99YCpBkA8rxsLtAPjBVoDe4fNsnMIdZTiPuKWg==",
+      "requires": {
+        "tunnel": "0.0.4",
+        "underscore": "1.8.3"
+      }
+    },
     "typescript": {
       "version": "3.7.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.3.tgz",
@@ -6017,6 +5999,11 @@
         "source-map": "~0.6.1"
       }
     },
+    "underscore": {
+      "version": "1.8.3",
+      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz",
+      "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI="
+    },
     "union-value": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cache",
-  "version": "1.2.0",
+  "version": "1.1.0",
   "private": true,
   "description": "Cache dependencies and build outputs",
   "main": "dist/restore/index.js",
@@ -24,10 +24,10 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@actions/core": "^1.10.0",
+    "@actions/core": "^1.2.0",
     "@actions/exec": "^1.0.1",
-    "@actions/http-client": "^1.0.6",
     "@actions/io": "^1.0.1",
+    "typed-rest-client": "^1.5.0",
     "uuid": "^3.3.3"
   },
   "devDependencies": {

src/cacheHttpClient.ts

@@ -1,16 +1,13 @@
 import * as core from "@actions/core";
-import { HttpClient, HttpCodes } from "@actions/http-client";
-import { BearerCredentialHandler } from "@actions/http-client/auth";
-import {
-    IHttpClientResponse,
-    IRequestOptions,
-    ITypedResponse
-} from "@actions/http-client/interfaces";
 import * as fs from "fs";
-import * as stream from "stream";
+import { BearerCredentialHandler } from "typed-rest-client/Handlers";
-import * as util from "util";
+import { HttpClient, HttpCodes } from "typed-rest-client/HttpClient";
-
+import { IHttpClientResponse } from "typed-rest-client/Interfaces";
-import { SocketTimeout } from "./constants";
+import {
+    IRequestOptions,
+    RestClient,
+    IRestResponse
+} from "typed-rest-client/RestClient";
 import {
     ArtifactCacheEntry,
     CommitCacheRequest,
@@ -19,24 +16,11 @@ import {
 } from "./contracts";
 import * as utils from "./utils/actionUtils";
 
-function isSuccessStatusCode(statusCode?: number): boolean {
+function isSuccessStatusCode(statusCode: number): boolean {
-    if (!statusCode) {
-        return false;
-    }
     return statusCode >= 200 && statusCode < 300;
 }
 
-function isServerErrorStatusCode(statusCode?: number): boolean {
+function isRetryableStatusCode(statusCode: number): boolean {
-    if (!statusCode) {
-        return true;
-    }
-    return statusCode >= 500;
-}
-
-function isRetryableStatusCode(statusCode?: number): boolean {
-    if (!statusCode) {
-        return false;
-    }
     const retryableStatusCodes = [
         HttpCodes.BadGateway,
         HttpCodes.ServiceUnavailable,
@@ -45,7 +29,7 @@ function isRetryableStatusCode(statusCode?: number): boolean {
     return retryableStatusCodes.includes(statusCode);
 }
 
-function getCacheApiUrl(resource: string): string {
+function getCacheApiUrl(): string {
     // Ideally we just use ACTIONS_CACHE_URL
     const baseUrl: string = (
         process.env["ACTIONS_CACHE_URL"] ||
@@ -58,9 +42,8 @@ function getCacheApiUrl(resource: string): string {
         );
     }
 
-    const url = `${baseUrl}_apis/artifactcache/${resource}`;
+    core.debug(`Cache Url: ${baseUrl}`);
-    core.debug(`Resource Url: ${url}`);
+    return `${baseUrl}_apis/artifactcache/`;
-    return url;
 }
 
 function createAcceptHeader(type: string, apiVersion: string): string {
@@ -69,102 +52,30 @@ function createAcceptHeader(type: string, apiVersion: string): string {
 
 function getRequestOptions(): IRequestOptions {
     const requestOptions: IRequestOptions = {
-        headers: {
+        acceptHeader: createAcceptHeader("application/json", "6.0-preview.1")
-            Accept: createAcceptHeader("application/json", "6.0-preview.1")
-        }
     };
 
     return requestOptions;
 }
 
-function createHttpClient(): HttpClient {
+function createRestClient(): RestClient {
     const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
     const bearerCredentialHandler = new BearerCredentialHandler(token);
 
-    return new HttpClient(
+    return new RestClient("actions/cache", getCacheApiUrl(), [
-        "actions/cache",
+        bearerCredentialHandler
-        [bearerCredentialHandler],
+    ]);
-        getRequestOptions()
-    );
-}
-
-export async function retry<T>(
-    name: string,
-    method: () => Promise<T>,
-    getStatusCode: (T) => number | undefined,
-    maxAttempts = 2
-): Promise<T> {
-    let response: T | undefined = undefined;
-    let statusCode: number | undefined = undefined;
-    let isRetryable = false;
-    let errorMessage = "";
-    let attempt = 1;
-
-    while (attempt <= maxAttempts) {
-        try {
-            response = await method();
-            statusCode = getStatusCode(response);
-
-            if (!isServerErrorStatusCode(statusCode)) {
-                return response;
-            }
-
-            isRetryable = isRetryableStatusCode(statusCode);
-            errorMessage = `Cache service responded with ${statusCode}`;
-        } catch (error) {
-            isRetryable = true;
-            errorMessage = error.message;
-        }
-
-        core.debug(
-            `${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`
-        );
-
-        if (!isRetryable) {
-            core.debug(`${name} - Error is not retryable`);
-            break;
-        }
-
-        attempt++;
-    }
-
-    throw Error(`${name} failed: ${errorMessage}`);
-}
-
-export async function retryTypedResponse<T>(
-    name: string,
-    method: () => Promise<ITypedResponse<T>>,
-    maxAttempts = 2
-): Promise<ITypedResponse<T>> {
-    return await retry(
-        name,
-        method,
-        (response: ITypedResponse<T>) => response.statusCode,
-        maxAttempts
-    );
-}
-
-export async function retryHttpClientResponse<T>(
-    name: string,
-    method: () => Promise<IHttpClientResponse>,
-    maxAttempts = 2
-): Promise<IHttpClientResponse> {
-    return await retry(
-        name,
-        method,
-        (response: IHttpClientResponse) => response.message.statusCode,
-        maxAttempts
-    );
 }
 
 export async function getCacheEntry(
     keys: string[]
 ): Promise<ArtifactCacheEntry | null> {
-    const httpClient = createHttpClient();
+    const restClient = createRestClient();
     const resource = `cache?keys=${encodeURIComponent(keys.join(","))}`;
 
-    const response = await retryTypedResponse("getCacheEntry", () =>
+    const response = await restClient.get<ArtifactCacheEntry>(
-        httpClient.getJson<ArtifactCacheEntry>(getCacheApiUrl(resource))
+        resource,
+        getRequestOptions()
     );
     if (response.statusCode === 204) {
         return null;
@@ -172,7 +83,6 @@ export async function getCacheEntry(
     if (!isSuccessStatusCode(response.statusCode)) {
         throw new Error(`Cache service responded with ${response.statusCode}`);
     }
-
     const cacheResult = response.result;
     const cacheDownloadUrl = cacheResult?.archiveLocation;
     if (!cacheDownloadUrl) {
@@ -187,10 +97,13 @@ export async function getCacheEntry(
 
 async function pipeResponseToStream(
     response: IHttpClientResponse,
-    output: NodeJS.WritableStream
+    stream: NodeJS.WritableStream
 ): Promise<void> {
-    const pipeline = util.promisify(stream.pipeline);
+    return new Promise(resolve => {
-    await pipeline(response.message, output);
+        response.message.pipe(stream).on("close", () => {
+            resolve();
+        });
+    });
 }
 
 export async function downloadCache(
@@ -199,52 +112,23 @@ export async function downloadCache(
 ): Promise<void> {
     const stream = fs.createWriteStream(archivePath);
     const httpClient = new HttpClient("actions/cache");
-    const downloadResponse = await retryHttpClientResponse(
+    const downloadResponse = await httpClient.get(archiveLocation);
-        "downloadCache",
-        () => httpClient.get(archiveLocation)
-    );
-
-    // Abort download if no traffic received over the socket.
-    downloadResponse.message.socket.setTimeout(SocketTimeout, () => {
-        downloadResponse.message.destroy();
-        core.debug(
-            `Aborting download, socket timed out after ${SocketTimeout} ms`
-        );
-    });
-
     await pipeResponseToStream(downloadResponse, stream);
-
-    // Validate download size.
-    const contentLengthHeader =
-        downloadResponse.message.headers["content-length"];
-
-    if (contentLengthHeader) {
-        const expectedLength = parseInt(contentLengthHeader);
-        const actualLength = utils.getArchiveFileSize(archivePath);
-
-        if (actualLength != expectedLength) {
-            throw new Error(
-                `Incomplete download. Expected file size: ${expectedLength}, actual file size: ${actualLength}`
-            );
-        }
-    } else {
-        core.debug("Unable to validate download, no Content-Length header");
-    }
 }
 
 // Reserve Cache
 export async function reserveCache(key: string): Promise<number> {
-    const httpClient = createHttpClient();
+    const restClient = createRestClient();
 
     const reserveCacheRequest: ReserveCacheRequest = {
         key
     };
-    const response = await retryTypedResponse("reserveCache", () =>
+    const response = await restClient.create<ReserveCacheResponse>(
-        httpClient.postJson<ReserveCacheResponse>(
+        "caches",
-            getCacheApiUrl("caches"),
+        reserveCacheRequest,
-            reserveCacheRequest
+        getRequestOptions()
-        )
     );
+
     return response?.result?.cacheId ?? -1;
 }
 
@@ -258,9 +142,9 @@ function getContentRange(start: number, end: number): string {
 }
 
 async function uploadChunk(
-    httpClient: HttpClient,
+    restClient: RestClient,
     resourceUrl: string,
-    openStream: () => NodeJS.ReadableStream,
+    data: NodeJS.ReadableStream,
     start: number,
     end: number
 ): Promise<void> {
@@ -272,20 +156,38 @@ async function uploadChunk(
             end
         )}`
     );
-    const additionalHeaders = {
+    const requestOptions = getRequestOptions();
+    requestOptions.additionalHeaders = {
         "Content-Type": "application/octet-stream",
         "Content-Range": getContentRange(start, end)
     };
 
-    await retryHttpClientResponse(
+    const uploadChunkRequest = async (): Promise<IRestResponse<void>> => {
-        `uploadChunk (start: ${start}, end: ${end})`,
+        return await restClient.uploadStream<void>(
-        () =>
+            "PATCH",
-            httpClient.sendStream(
+            resourceUrl,
-                "PATCH",
+            data,
-                resourceUrl,
+            requestOptions
-                openStream(),
+        );
-                additionalHeaders
+    };
-            )
+
+    const response = await uploadChunkRequest();
+    if (isSuccessStatusCode(response.statusCode)) {
+        return;
+    }
+
+    if (isRetryableStatusCode(response.statusCode)) {
+        core.debug(
+            `Received ${response.statusCode}, retrying chunk at offset ${start}.`
+        );
+        const retryResponse = await uploadChunkRequest();
+        if (isSuccessStatusCode(retryResponse.statusCode)) {
+            return;
+        }
+    }
+
+    throw new Error(
+        `Cache service responded with ${response.statusCode} during chunk upload.`
     );
 }
 
@@ -298,13 +200,13 @@ function parseEnvNumber(key: string): number | undefined {
 }
 
 async function uploadFile(
-    httpClient: HttpClient,
+    restClient: RestClient,
     cacheId: number,
     archivePath: string
 ): Promise<void> {
     // Upload Chunks
     const fileSize = fs.statSync(archivePath).size;
-    const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`);
+    const resourceUrl = getCacheApiUrl() + "caches/" + cacheId.toString();
     const fd = fs.openSync(archivePath, "r");
 
     const concurrency = parseEnvNumber("CACHE_UPLOAD_CONCURRENCY") ?? 4; // # of HTTP requests in parallel
@@ -327,23 +229,17 @@ async function uploadFile(
                     const start = offset;
                     const end = offset + chunkSize - 1;
                     offset += MAX_CHUNK_SIZE;
+                    const chunk = fs.createReadStream(archivePath, {
+                        fd,
+                        start,
+                        end,
+                        autoClose: false
+                    });
 
                     await uploadChunk(
-                        httpClient,
+                        restClient,
                         resourceUrl,
-                        () =>
+                        chunk,
-                            fs
-                                .createReadStream(archivePath, {
-                                    fd,
-                                    start,
-                                    end,
-                                    autoClose: false
-                                })
-                                .on("error", error => {
-                                    throw new Error(
-                                        `Cache upload failed because file read failed with ${error.Message}`
-                                    );
-                                }),
                         start,
                         end
                     );
@@ -357,16 +253,16 @@ async function uploadFile(
 }
 
 async function commitCache(
-    httpClient: HttpClient,
+    restClient: RestClient,
     cacheId: number,
     filesize: number
-): Promise<ITypedResponse<null>> {
+): Promise<IRestResponse<void>> {
+    const requestOptions = getRequestOptions();
     const commitCacheRequest: CommitCacheRequest = { size: filesize };
-    return await retryTypedResponse("commitCache", () =>
+    return await restClient.create(
-        httpClient.postJson<null>(
+        `caches/${cacheId.toString()}`,
-            getCacheApiUrl(`caches/${cacheId.toString()}`),
+        commitCacheRequest,
-            commitCacheRequest
+        requestOptions
-        )
     );
 }
 
@@ -374,16 +270,16 @@ export async function saveCache(
     cacheId: number,
     archivePath: string
 ): Promise<void> {
-    const httpClient = createHttpClient();
+    const restClient = createRestClient();
 
     core.debug("Upload cache");
-    await uploadFile(httpClient, cacheId, archivePath);
+    await uploadFile(restClient, cacheId, archivePath);
 
     // Commit Cache
     core.debug("Commiting cache");
     const cacheSize = utils.getArchiveFileSize(archivePath);
     const commitCacheResponse = await commitCache(
-        httpClient,
+        restClient,
         cacheId,
         cacheSize
     );

src/constants.ts

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

src/save.ts

@@ -56,14 +56,14 @@ async function run(): Promise<void> {
 
         await createTar(archivePath, cachePath);
 
-        const fileSizeLimit = 5 * 1024 * 1024 * 1024; // 5GB per repo limit
+        const fileSizeLimit = 2 * 1024 * 1024 * 1024; // 2GB per repo limit
         const archiveFileSize = utils.getArchiveFileSize(archivePath);
         core.debug(`File Size: ${archiveFileSize}`);
         if (archiveFileSize > fileSizeLimit) {
             utils.logWarning(
                 `Cache size of ~${Math.round(
                     archiveFileSize / (1024 * 1024)
-                )} MB (${archiveFileSize} B) is over the 5GB limit, not saving cache.`
+                )} MB (${archiveFileSize} B) is over the 2GB limit, not saving cache.`
             );
             return;
         }

src/tar.ts

@@ -1,36 +1,14 @@
-import * as core from "@actions/core";
 import { exec } from "@actions/exec";
 import * as io from "@actions/io";
 import { existsSync } from "fs";
-import * as path from "path";
-import * as tar from "./tar";
 
-export async function isGnuTar(): Promise<boolean> {
+async function getTarPath(): Promise<string> {
-    core.debug("Checking tar --version");
-    let versionOutput = "";
-    await exec("tar --version", [], {
-        ignoreReturnCode: true,
-        silent: true,
-        listeners: {
-            stdout: (data: Buffer): string =>
-                (versionOutput += data.toString()),
-            stderr: (data: Buffer): string => (versionOutput += data.toString())
-        }
-    });
-
-    core.debug(versionOutput.trim());
-    return versionOutput.toUpperCase().includes("GNU TAR");
-}
-
-async function getTarPath(args: string[]): Promise<string> {
     // Explicitly use BSD Tar on Windows
     const IS_WINDOWS = process.platform === "win32";
     if (IS_WINDOWS) {
         const systemTar = `${process.env["windir"]}\\System32\\tar.exe`;
         if (existsSync(systemTar)) {
             return systemTar;
-        } else if (await tar.isGnuTar()) {
-            args.push("--force-local");
         }
     }
     return await io.which("tar", true);
@@ -38,8 +16,14 @@ async function getTarPath(args: string[]): Promise<string> {
 
 async function execTar(args: string[]): Promise<void> {
     try {
-        await exec(`"${await getTarPath(args)}"`, args);
+        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}`);
     }
 }
@@ -50,13 +34,7 @@ export async function extractTar(
 ): Promise<void> {
     // Create directory to extract tar into
     await io.mkdirP(targetDirectory);
-    const args = [
+    const args = ["-xz", "-f", archivePath, "-C", targetDirectory];
-        "-xz",
-        "-f",
-        archivePath.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "-C",
-        targetDirectory.replace(new RegExp("\\" + path.sep, "g"), "/")
-    ];
     await execTar(args);
 }
 
@@ -64,13 +42,6 @@ export async function createTar(
     archivePath: string,
     sourceDirectory: string
 ): Promise<void> {
-    const args = [
+    const args = ["-cz", "-f", archivePath, "-C", sourceDirectory, "."];
-        "-cz",
-        "-f",
-        archivePath.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "-C",
-        sourceDirectory.replace(new RegExp("\\" + path.sep, "g"), "/"),
-        "."
-    ];
     await execTar(args);
 }