Add support for dependency caching.

- Fork relevant bits from https://github.com/actions/setup-java
- Use Node.js 16
- Adjust packaging
- Update uuid and other dependencies

Closes #11

.github/workflows/check-dist.yml

@@ -24,12 +24,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - name: Set Node.js 12.x
-        uses: actions/setup-node@v2.4.1
+      - name: Set Node.js 16.x
+        uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16.x
+          cache: npm
 
       - name: Install dependencies
         run: npm ci
@@ -47,7 +48,7 @@ jobs:
         id: diff
 
       # If index.js was different than expected, upload the expected version as an artifact
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
         if: ${{ failure() && steps.diff.conclusion == 'failure' }}
         with:
           name: dist

README.md

@@ -118,6 +118,7 @@ jobs:
 | `components`    | `''`     | Comma-spearated list of GraalVM components (e.g., `native-image` or `ruby,nodejs`) that will be installed by the [GraalVM Updater][gu]. |
 | `github-token`  | `''`     | Token for communication with the GitHub API. Please set to `${{ secrets.GITHUB_TOKEN }}` (see [templates](#templates)) to allow the action to authenticate with the GitHub API, which helps to reduce rate limiting issues. |
 | `set-java-home` | `'true'` | If set to `'true'`, instructs the action to set `$JAVA_HOME` to the path of the GraalVM installation. |
+| `cache`         | `''`     | Name of the build platform to cache dependencies. It can be `'maven'`, `'gradle'`, or `'sbt'` and works the same way it does in [actions/setup-java][setup-java-caching]. |
 | `native-image-musl` | `'false'` | If set to `'true'`, sets up [musl] for building [static images][native-image-static] with GraalVM Native Image *(Linux only)*. [Example usage][native-image-musl-build] (be sure to replace `uses: ./` with `uses: graalvm/setup-graalvm@v1`). |
 
 
@@ -144,6 +145,7 @@ Only pull requests from committers that can be verified as having signed the OCA
 [oca]: https://oca.opensource.oracle.com
 [releases]: https://github.com/graalvm/graalvm-ce-builds/releases
 [repo]: https://github.com/oracle/graal
+[setup-java-caching]: https://github.com/actions/setup-java/tree/5b36705a13905facb447b6812d613a06a07e371d#caching-packages-dependencies
 [stable]: https://github.com/graalvm/graalvm-ce-builds/releases/latest
 [truffle-languages]: https://www.graalvm.org/reference-manual/languages/
 [vcvarsall]: https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line

__tests__/cache.test.ts

@@ -0,0 +1,379 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 GitHub, Inc. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Forked from https://github.com/actions/setup-java/blob/5b36705a13905facb447b6812d613a06a07e371d/__tests__/cache.test.ts
+ */
+
+import {mkdtempSync} from 'fs'
+import {tmpdir} from 'os'
+import {join} from 'path'
+import {restore, save} from '../src/cache'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as core from '@actions/core'
+import * as cache from '@actions/cache'
+
+describe('dependency cache', () => {
+  const ORIGINAL_RUNNER_OS = process.env['RUNNER_OS']
+  const ORIGINAL_GITHUB_WORKSPACE = process.env['GITHUB_WORKSPACE']
+  const ORIGINAL_CWD = process.cwd()
+  let workspace: string
+  let spyInfo: jest.SpyInstance<void, Parameters<typeof core.info>>
+  let spyWarning: jest.SpyInstance<void, Parameters<typeof core.warning>>
+  let spyDebug: jest.SpyInstance<void, Parameters<typeof core.debug>>
+  let spySaveState: jest.SpyInstance<void, Parameters<typeof core.saveState>>
+
+  beforeEach(() => {
+    workspace = mkdtempSync(join(tmpdir(), 'setup-java-cache-'))
+    switch (os.platform()) {
+      case 'darwin':
+        process.env['RUNNER_OS'] = 'macOS'
+        break
+      case 'win32':
+        process.env['RUNNER_OS'] = 'Windows'
+        break
+      case 'linux':
+        process.env['RUNNER_OS'] = 'Linux'
+        break
+      default:
+        throw new Error(`unknown platform: ${os.platform()}`)
+    }
+    process.chdir(workspace)
+    // This hack is necessary because @actions/glob ignores files not in the GITHUB_WORKSPACE
+    // https://git.io/Jcxig
+    process.env['GITHUB_WORKSPACE'] = projectRoot(workspace)
+  })
+
+  beforeEach(() => {
+    spyInfo = jest.spyOn(core, 'info')
+    spyInfo.mockImplementation(() => null)
+
+    spyWarning = jest.spyOn(core, 'warning')
+    spyWarning.mockImplementation(() => null)
+
+    spyDebug = jest.spyOn(core, 'debug')
+    spyDebug.mockImplementation(() => null)
+
+    spySaveState = jest.spyOn(core, 'saveState')
+    spySaveState.mockImplementation(() => null)
+  })
+
+  afterEach(() => {
+    process.chdir(ORIGINAL_CWD)
+    process.env['GITHUB_WORKSPACE'] = ORIGINAL_GITHUB_WORKSPACE
+    process.env['RUNNER_OS'] = ORIGINAL_RUNNER_OS
+    resetState()
+  })
+
+  describe('restore', () => {
+    let spyCacheRestore: jest.SpyInstance<
+      ReturnType<typeof cache.restoreCache>,
+      Parameters<typeof cache.restoreCache>
+    >
+
+    beforeEach(() => {
+      spyCacheRestore = jest
+        .spyOn(cache, 'restoreCache')
+        .mockImplementation((paths: string[], primaryKey: string) =>
+          Promise.resolve(undefined)
+        )
+      spyWarning.mockImplementation(() => null)
+    })
+
+    it('throws error if unsupported package manager specified', () => {
+      return expect(restore('ant')).rejects.toThrowError(
+        'unknown package manager specified: ant'
+      )
+    })
+
+    describe('for maven', () => {
+      it('throws error if no pom.xml found', async () => {
+        await expect(restore('maven')).rejects.toThrowError(
+          `No file in ${projectRoot(
+            workspace
+          )} matched to [**/pom.xml], make sure you have checked out the target repository`
+        )
+      })
+      it('downloads cache', async () => {
+        createFile(join(workspace, 'pom.xml'))
+
+        await restore('maven')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('maven cache is not found')
+      })
+    })
+    describe('for gradle', () => {
+      it('throws error if no build.gradle found', async () => {
+        await expect(restore('gradle')).rejects.toThrowError(
+          `No file in ${projectRoot(
+            workspace
+          )} matched to [**/*.gradle*,**/gradle-wrapper.properties,buildSrc/**/Versions.kt,buildSrc/**/Dependencies.kt], make sure you have checked out the target repository`
+        )
+      })
+      it('downloads cache based on build.gradle', async () => {
+        createFile(join(workspace, 'build.gradle'))
+
+        await restore('gradle')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('gradle cache is not found')
+      })
+      it('downloads cache based on build.gradle.kts', async () => {
+        createFile(join(workspace, 'build.gradle.kts'))
+
+        await restore('gradle')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('gradle cache is not found')
+      })
+    })
+    it('downloads cache based on buildSrc/Versions.kt', async () => {
+      createDirectory(join(workspace, 'buildSrc'))
+      createFile(join(workspace, 'buildSrc', 'Versions.kt'))
+
+      await restore('gradle')
+      expect(spyCacheRestore).toBeCalled()
+      expect(spyWarning).not.toBeCalled()
+      expect(spyInfo).toBeCalledWith('gradle cache is not found')
+    })
+    describe('for sbt', () => {
+      it('throws error if no build.sbt found', async () => {
+        await expect(restore('sbt')).rejects.toThrowError(
+          `No file in ${projectRoot(
+            workspace
+          )} matched to [**/*.sbt,**/project/build.properties,**/project/**.{scala,sbt}], make sure you have checked out the target repository`
+        )
+      })
+      it('downloads cache', async () => {
+        createFile(join(workspace, 'build.sbt'))
+
+        await restore('sbt')
+        expect(spyCacheRestore).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith('sbt cache is not found')
+      })
+    })
+  })
+  describe('save', () => {
+    let spyCacheSave: jest.SpyInstance<
+      ReturnType<typeof cache.saveCache>,
+      Parameters<typeof cache.saveCache>
+    >
+
+    beforeEach(() => {
+      spyCacheSave = jest
+        .spyOn(cache, 'saveCache')
+        .mockImplementation((paths: string[], key: string) =>
+          Promise.resolve(0)
+        )
+      spyWarning.mockImplementation(() => null)
+    })
+
+    it('throws error if unsupported package manager specified', () => {
+      return expect(save('ant')).rejects.toThrowError(
+        'unknown package manager specified: ant'
+      )
+    })
+
+    it('save with -1 cacheId , should not fail workflow', async () => {
+      spyCacheSave.mockImplementation(() => Promise.resolve(-1))
+      createStateForMissingBuildFile()
+
+      await save('maven')
+      expect(spyCacheSave).toBeCalled()
+      expect(spyWarning).not.toBeCalled()
+      expect(spyInfo).toBeCalled()
+      expect(spyInfo).toBeCalledWith(
+        expect.stringMatching(/^Cache saved with the key:.*/)
+      )
+    })
+
+    it('saves with error from toolkit, should fail workflow', async () => {
+      spyCacheSave.mockImplementation(() =>
+        Promise.reject(new cache.ValidationError('Validation failed'))
+      )
+      createStateForMissingBuildFile()
+
+      expect.assertions(1)
+      await expect(save('maven')).rejects.toEqual(
+        new cache.ValidationError('Validation failed')
+      )
+    })
+
+    describe('for maven', () => {
+      it('uploads cache even if no pom.xml found', async () => {
+        createStateForMissingBuildFile()
+        await save('maven')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+      })
+      it('does not upload cache if no restore run before', async () => {
+        createFile(join(workspace, 'pom.xml'))
+
+        await save('maven')
+        expect(spyCacheSave).not.toBeCalled()
+        expect(spyWarning).toBeCalledWith('Error retrieving key from state.')
+      })
+      it('uploads cache', async () => {
+        createFile(join(workspace, 'pom.xml'))
+        createStateForSuccessfulRestore()
+
+        await save('maven')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
+      })
+    })
+    describe('for gradle', () => {
+      it('uploads cache even if no build.gradle found', async () => {
+        createStateForMissingBuildFile()
+
+        await save('gradle')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+      })
+      it('does not upload cache if no restore run before', async () => {
+        createFile(join(workspace, 'build.gradle'))
+
+        await save('gradle')
+        expect(spyCacheSave).not.toBeCalled()
+        expect(spyWarning).toBeCalledWith('Error retrieving key from state.')
+      })
+      it('uploads cache based on build.gradle', async () => {
+        createFile(join(workspace, 'build.gradle'))
+        createStateForSuccessfulRestore()
+
+        await save('gradle')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
+      })
+      it('uploads cache based on build.gradle.kts', async () => {
+        createFile(join(workspace, 'build.gradle.kts'))
+        createStateForSuccessfulRestore()
+
+        await save('gradle')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
+      })
+      it('uploads cache based on buildSrc/Versions.kt', async () => {
+        createDirectory(join(workspace, 'buildSrc'))
+        createFile(join(workspace, 'buildSrc', 'Versions.kt'))
+        createStateForSuccessfulRestore()
+
+        await save('gradle')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
+      })
+    })
+    describe('for sbt', () => {
+      it('uploads cache even if no build.sbt found', async () => {
+        createStateForMissingBuildFile()
+        await save('sbt')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+      })
+      it('does not upload cache if no restore run before', async () => {
+        createFile(join(workspace, 'build.sbt'))
+
+        await save('sbt')
+        expect(spyCacheSave).not.toBeCalled()
+        expect(spyWarning).toBeCalledWith('Error retrieving key from state.')
+      })
+      it('uploads cache', async () => {
+        createFile(join(workspace, 'build.sbt'))
+        createStateForSuccessfulRestore()
+
+        await save('sbt')
+        expect(spyCacheSave).toBeCalled()
+        expect(spyWarning).not.toBeCalled()
+        expect(spyInfo).toBeCalledWith(
+          expect.stringMatching(/^Cache saved with the key:.*/)
+        )
+      })
+    })
+  })
+})
+
+function resetState() {
+  jest.spyOn(core, 'getState').mockReset()
+}
+
+/**
+ * Create states to emulate a restore process without build file.
+ */
+function createStateForMissingBuildFile() {
+  jest.spyOn(core, 'getState').mockImplementation(name => {
+    switch (name) {
+      case 'cache-primary-key':
+        return 'setup-java-cache-'
+      default:
+        return ''
+    }
+  })
+}
+
+/**
+ * Create states to emulate a successful restore process.
+ */
+function createStateForSuccessfulRestore() {
+  jest.spyOn(core, 'getState').mockImplementation(name => {
+    switch (name) {
+      case 'cache-primary-key':
+        return 'setup-java-cache-primary-key'
+      case 'cache-matched-key':
+        return 'setup-java-cache-matched-key'
+      default:
+        return ''
+    }
+  })
+}
+
+function createFile(path: string) {
+  core.info(`created a file at ${path}`)
+  fs.writeFileSync(path, '')
+}
+
+function createDirectory(path: string) {
+  core.info(`created a directory at ${path}`)
+  fs.mkdirSync(path)
+}
+
+function projectRoot(workspace: string): string {
+  if (os.platform() === 'darwin') {
+    return `/private${workspace}`
+  } else {
+    return workspace
+  }
+}

__tests__/cache/gradle/.gitignore

@@ -0,0 +1,12 @@
+.gradle
+**/build/
+!src/**/build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Cache of project
+.gradletasknamecache

__tests__/cache/gradle/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id 'java'
+}
+repositories {
+    mavenCentral()
+}
+dependencies {
+    implementation 'org.codehaus.groovy:groovy:1.8.6'
+}
+tasks.register('downloadDependencies') {
+    doLast {
+        def total = configurations.compileClasspath.inject (0) { sum, file ->
+            sum + file.length()
+        }
+        println total
+    }
+}

__tests__/cache/maven/.gitignore

@@ -0,0 +1,11 @@
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+# https://github.com/takari/maven-wrapper#usage-without-binary-jar
+.mvn/wrapper/maven-wrapper.jar

__tests__/cache/maven/pom.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>io.github.actions</groupId>
+    <artifactId>setup-java-maven-example</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.7.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

__tests__/cache/sbt/.gitignore

@@ -0,0 +1 @@
+target/

__tests__/cache/sbt/build.sbt

@@ -0,0 +1,3 @@
+ThisBuild / scalaVersion := "2.12.15"
+
+libraryDependencies += "org.scala-lang.modules" %% "scala-parser-combinators" % "1.1.2"

__tests__/cache/sbt/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.6.2

__tests__/cleanup.test.ts

@@ -0,0 +1,101 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 GitHub, Inc. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Forked from https://github.com/actions/setup-java/blob/5b36705a13905facb447b6812d613a06a07e371d/__tests__/cleanup-java.test.ts
+ */
+
+import {run as cleanup} from '../src/cleanup'
+import * as core from '@actions/core'
+import * as cache from '@actions/cache'
+import * as util from '../src/utils'
+
+describe('cleanup', () => {
+  let spyWarning: jest.SpyInstance<void, Parameters<typeof core.warning>>
+  let spyInfo: jest.SpyInstance<void, Parameters<typeof core.info>>
+  let spyCacheSave: jest.SpyInstance<
+    ReturnType<typeof cache.saveCache>,
+    Parameters<typeof cache.saveCache>
+  >
+  let spyJobStatusSuccess: jest.SpyInstance
+
+  beforeEach(() => {
+    spyWarning = jest.spyOn(core, 'warning')
+    spyWarning.mockImplementation(() => null)
+    spyInfo = jest.spyOn(core, 'info')
+    spyInfo.mockImplementation(() => null)
+    spyCacheSave = jest.spyOn(cache, 'saveCache')
+    spyJobStatusSuccess = jest.spyOn(util, 'isJobStatusSuccess')
+    spyJobStatusSuccess.mockReturnValue(true)
+    createStateForSuccessfulRestore()
+  })
+  afterEach(() => {
+    resetState()
+  })
+
+  it('does not fail nor warn even when the save provess throws a ReserveCacheError', async () => {
+    spyCacheSave.mockImplementation((paths: string[], key: string) =>
+      Promise.reject(
+        new cache.ReserveCacheError(
+          'Unable to reserve cache with key, another job may be creating this cache.'
+        )
+      )
+    )
+    jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
+      return name === 'cache' ? 'gradle' : ''
+    })
+    await cleanup()
+    expect(spyCacheSave).toBeCalled()
+    expect(spyWarning).not.toBeCalled()
+  })
+
+  it('does not fail even though the save process throws error', async () => {
+    spyCacheSave.mockImplementation((paths: string[], key: string) =>
+      Promise.reject(new Error('Unexpected error'))
+    )
+    jest.spyOn(core, 'getInput').mockImplementation((name: string) => {
+      return name === 'cache' ? 'gradle' : ''
+    })
+    await cleanup()
+    expect(spyCacheSave).toBeCalled()
+  })
+})
+
+function resetState() {
+  jest.spyOn(core, 'getState').mockReset()
+}
+
+/**
+ * Create states to emulate a successful restore process.
+ */
+function createStateForSuccessfulRestore() {
+  jest.spyOn(core, 'getState').mockImplementation(name => {
+    switch (name) {
+      case 'cache-primary-key':
+        return 'setup-java-cache-primary-key'
+      case 'cache-matched-key':
+        return 'setup-java-cache-matched-key'
+      default:
+        return ''
+    }
+  })
+}

action.yml

@@ -1,6 +1,6 @@
 name: 'GitHub Action for GraalVM'
 description: 'Set up a specific version of GraalVM Community Edition (CE) or Enterprise Edition (EE)'
-author: 'GraalVM Developers'
+author: 'GraalVM Community'
 branding:
   icon: 'terminal'  
   color: 'blue'
@@ -26,10 +26,14 @@ inputs:
     required: false
     description: 'Set $JAVA_HOME to the GraalVM installation. Default: true.'
     default: 'true'
+  cache:
+    description: 'Name of the build platform to cache dependencies. It can be "maven", "gradle", or "sbt".'
+    required: false
   native-image-musl:
     required: false
     description: 'Set up musl for static image building with GraalVM Native Image.'
     default: 'false'
 runs:
-  using: 'node12'
-  main: 'dist/index.js'
+  using: 'node16'
+  main: 'dist/main/index.js'
+  post: 'dist/cleanup/index.js'

package.json

@@ -1,6 +1,6 @@
 {
   "name": "setup-graalvm",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "private": true,
   "description": "GitHub Action for GraalVM",
   "main": "lib/main.js",
@@ -9,7 +9,7 @@
     "format": "prettier --write '**/*.ts'",
     "format-check": "prettier --check '**/*.ts'",
     "lint": "eslint src/**/*.ts",
-    "package": "ncc build --source-map --license licenses.txt",
+    "package": "ncc build -o dist/main src/main.ts && ncc build -o dist/cleanup src/cleanup.ts",
     "test": "jest",
     "all": "npm run build && npm run format && npm run lint && npm run package && npm test"
   },
@@ -23,23 +23,26 @@
     "actions",
     "setup"
   ],
-  "author": "GraalVM Developers",
+  "author": "GraalVM Community",
   "license": "UPL",
   "dependencies": {
+    "@actions/cache": "^3.0.4",
     "@actions/core": "^1.6.0",
     "@actions/exec": "^1.1.0",
+    "@actions/glob": "^0.3.0",
     "@actions/http-client": "^1.0.11",
     "@actions/io": "^1.1.1",
     "@actions/tool-cache": "^1.7.1",
     "@octokit/core": "^3.5.1",
     "@octokit/types": "^6.34.0",
-    "uuid": "^3.3.2"
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
+    "@types/jest": "^27.5.2",
     "@types/node": "^17.0.6",
-    "@types/uuid": "^3.4.10",
+    "@types/uuid": "^8.3.4",
     "@typescript-eslint/parser": "^5.8.1",
-    "@vercel/ncc": "^0.33.1",
+    "@vercel/ncc": "^0.33.4",
     "eslint": "^8.6.0",
     "eslint-plugin-github": "^4.3.5",
     "eslint-plugin-jest": "^25.3.4",
@@ -47,6 +50,6 @@
     "js-yaml": "^4.1.0",
     "prettier": "2.5.1",
     "ts-jest": "^27.1.2",
-    "typescript": "^4.5.4"
+    "typescript": "^4.2.3"
   }
 }

src/cache.ts

@@ -0,0 +1,201 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 GitHub, Inc. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Forked from https://github.com/actions/setup-java/blob/5b36705a13905facb447b6812d613a06a07e371d/src/cache.ts
+ *
+ * @fileoverview this file provides methods handling dependency cache
+ */
+
+import {join} from 'path'
+import os from 'os'
+import * as cache from '@actions/cache'
+import * as core from '@actions/core'
+import * as glob from '@actions/glob'
+
+const STATE_CACHE_PRIMARY_KEY = 'cache-primary-key'
+const CACHE_MATCHED_KEY = 'cache-matched-key'
+const CACHE_KEY_PREFIX = 'setup-java'
+
+interface PackageManager {
+  id: 'maven' | 'gradle' | 'sbt'
+  /**
+   * Paths of the file that specify the files to cache.
+   */
+  path: string[]
+  pattern: string[]
+}
+const supportedPackageManager: PackageManager[] = [
+  {
+    id: 'maven',
+    path: [join(os.homedir(), '.m2', 'repository')],
+    // https://github.com/actions/cache/blob/0638051e9af2c23d10bb70fa9beffcad6cff9ce3/examples.md#java---maven
+    pattern: ['**/pom.xml']
+  },
+  {
+    id: 'gradle',
+    path: [
+      join(os.homedir(), '.gradle', 'caches'),
+      join(os.homedir(), '.gradle', 'wrapper')
+    ],
+    // https://github.com/actions/cache/blob/0638051e9af2c23d10bb70fa9beffcad6cff9ce3/examples.md#java---gradle
+    pattern: [
+      '**/*.gradle*',
+      '**/gradle-wrapper.properties',
+      'buildSrc/**/Versions.kt',
+      'buildSrc/**/Dependencies.kt'
+    ]
+  },
+  {
+    id: 'sbt',
+    path: [
+      join(os.homedir(), '.ivy2', 'cache'),
+      join(os.homedir(), '.sbt'),
+      getCoursierCachePath(),
+      // Some files should not be cached to avoid resolution problems.
+      // In particular the resolution of snapshots (ideological gap between maven/ivy).
+      `!${join(os.homedir(), '.sbt', '*.lock')}`,
+      `!${join(os.homedir(), '**', 'ivydata-*.properties')}`
+    ],
+    pattern: [
+      '**/*.sbt',
+      '**/project/build.properties',
+      '**/project/**.{scala,sbt}'
+    ]
+  }
+]
+
+function getCoursierCachePath(): string {
+  if (os.type() === 'Linux') return join(os.homedir(), '.cache', 'coursier')
+  if (os.type() === 'Darwin')
+    return join(os.homedir(), 'Library', 'Caches', 'Coursier')
+  return join(os.homedir(), 'AppData', 'Local', 'Coursier', 'Cache')
+}
+
+function findPackageManager(id: string): PackageManager {
+  const packageManager = supportedPackageManager.find(pm => pm.id === id)
+  if (packageManager === undefined) {
+    throw new Error(`unknown package manager specified: ${id}`)
+  }
+  return packageManager
+}
+
+/**
+ * A function that generates a cache key to use.
+ * Format of the generated key will be "${{ platform }}-${{ id }}-${{ fileHash }}"".
+ * If there is no file matched to {@link PackageManager.path}, the generated key ends with a dash (-).
+ * @see {@link https://docs.github.com/en/actions/guides/caching-dependencies-to-speed-up-workflows#matching-a-cache-key|spec of cache key}
+ */
+async function computeCacheKey(
+  packageManager: PackageManager
+): Promise<string> {
+  const hash = await glob.hashFiles(packageManager.pattern.join('\n'))
+  return `${CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${packageManager.id}-${hash}`
+}
+
+/**
+ * Restore the dependency cache
+ * @param id ID of the package manager, should be "maven" or "gradle"
+ */
+export async function restore(id: string): Promise<void> {
+  const packageManager = findPackageManager(id)
+  const primaryKey = await computeCacheKey(packageManager)
+
+  core.debug(`primary key is ${primaryKey}`)
+  core.saveState(STATE_CACHE_PRIMARY_KEY, primaryKey)
+  if (primaryKey.endsWith('-')) {
+    throw new Error(
+      `No file in ${process.cwd()} matched to [${
+        packageManager.pattern
+      }], make sure you have checked out the target repository`
+    )
+  }
+
+  // No "restoreKeys" is set, to start with a clear cache after dependency update (see https://github.com/actions/setup-java/issues/269)
+  const matchedKey = await cache.restoreCache(packageManager.path, primaryKey)
+  if (matchedKey) {
+    core.saveState(CACHE_MATCHED_KEY, matchedKey)
+    core.setOutput('cache-hit', matchedKey === primaryKey)
+    core.info(`Cache restored from key: ${matchedKey}`)
+  } else {
+    core.setOutput('cache-hit', false)
+    core.info(`${packageManager.id} cache is not found`)
+  }
+}
+
+/**
+ * Save the dependency cache
+ * @param id ID of the package manager, should be "maven" or "gradle"
+ */
+export async function save(id: string): Promise<void> {
+  const packageManager = findPackageManager(id)
+  const matchedKey = core.getState(CACHE_MATCHED_KEY)
+
+  // Inputs are re-evaluted before the post action, so we want the original key used for restore
+  const primaryKey = core.getState(STATE_CACHE_PRIMARY_KEY)
+
+  if (!primaryKey) {
+    core.warning('Error retrieving key from state.')
+    return
+  } else if (matchedKey === primaryKey) {
+    // no change in target directories
+    core.info(
+      `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+    )
+    return
+  }
+  try {
+    await cache.saveCache(packageManager.path, primaryKey)
+    core.info(`Cache saved with the key: ${primaryKey}`)
+  } catch (error) {
+    if (error.name === cache.ReserveCacheError.name) {
+      core.info(error.message)
+    } else {
+      if (isProbablyGradleDaemonProblem(packageManager, error)) {
+        core.warning(
+          'Failed to save Gradle cache on Windows. If tar.exe reported "Permission denied", try to run Gradle with `--no-daemon` option. Refer to https://github.com/actions/cache/issues/454 for details.'
+        )
+      }
+      throw error
+    }
+  }
+}
+
+/**
+ * @param packageManager the specified package manager by user
+ * @param error the error thrown by the saveCache
+ * @returns true if the given error seems related to the {@link https://github.com/actions/cache/issues/454|running Gradle Daemon issue}.
+ * @see {@link https://github.com/actions/cache/issues/454#issuecomment-840493935|why --no-daemon is necessary}
+ */
+function isProbablyGradleDaemonProblem(
+  packageManager: PackageManager,
+  error: Error
+): boolean {
+  if (
+    packageManager.id !== 'gradle' ||
+    process.env['RUNNER_OS'] !== 'Windows'
+  ) {
+    return false
+  }
+  const message = error.message || ''
+  return message.startsWith('Tar failed with error: ')
+}

src/cleanup.ts

@@ -0,0 +1,65 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 GitHub, Inc. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Forked from https://github.com/actions/setup-java/blob/5b36705a13905facb447b6812d613a06a07e371d/src/cleanup-java.ts
+ */
+
+import * as core from '@actions/core'
+import * as constants from './constants'
+import {isJobStatusSuccess} from './utils'
+import {save} from './cache'
+
+/**
+ * Check given input and run a save process for the specified package manager
+ * @returns Promise that will be resolved when the save process finishes
+ */
+async function saveCache(): Promise<void> {
+  const jobStatus = isJobStatusSuccess()
+  const cache = core.getInput(constants.INPUT_CACHE)
+  return jobStatus && cache ? save(cache) : Promise.resolve()
+}
+
+/**
+ * The save process is best-effort, and it should not make the workflow fail
+ * even though this process throws an error.
+ * @param promise the promise to ignore error from
+ * @returns Promise that will ignore error reported by the given promise
+ */
+async function ignoreError(promise: Promise<void>): Promise<void> {
+  try {
+    await promise
+  } catch (error) {
+    core.warning(error)
+  }
+}
+
+export async function run(): Promise<void> {
+  await ignoreError(saveCache())
+}
+
+if (require.main === module) {
+  run()
+} else {
+  // https://nodejs.org/api/modules.html#modules_accessing_the_main_module
+  core.info('the script is loaded as a module, so skipping the execution')
+}

src/constants.ts

@@ -1,5 +1,15 @@
 import * as otypes from '@octokit/types'
 
+export const INPUT_VERSION = 'version'
+export const INPUT_GDS_TOKEN = 'gds-token'
+export const INPUT_JAVA_VERSION = 'java-version'
+export const INPUT_COMPONENTS = 'components'
+export const INPUT_GITHUB_TOKEN = 'github-token'
+export const INPUT_SET_JAVA_HOME = 'set-java-home'
+export const INPUT_CACHE = 'cache'
+export const INPUT_NI_MUSL = 'native-image-musl'
+export const INPUT_JOB_STATUS = 'job-status'
+
 export const IS_LINUX = process.platform === 'linux'
 export const IS_MACOS = process.platform === 'darwin'
 export const IS_WINDOWS = process.platform === 'win32'

src/gds.ts

@@ -11,7 +11,7 @@ import {IncomingHttpHeaders} from 'http'
 import {RetryHelper} from '@actions/tool-cache/lib/retry-helper'
 import {calculateSHA256} from './utils'
 import {ok} from 'assert'
-import uuidV4 from 'uuid/v4'
+import {v4 as uuidv4} from 'uuid'
 
 interface GDSArtifactsResponse {
   readonly items: GDSArtifact[]
@@ -130,7 +130,7 @@ async function downloadTool(
   userAgent: string,
   headers?: IHeaders
 ): Promise<string> {
-  const dest = path.join(getTempDirectory(), uuidV4())
+  const dest = path.join(getTempDirectory(), uuidv4())
   await io.mkdirP(path.dirname(dest))
   core.debug(`Downloading ${url}`)
   core.debug(`Destination ${dest}`)

src/main.ts

@@ -1,7 +1,9 @@
 import * as c from './constants'
 import * as core from '@actions/core'
 import * as graalvm from './graalvm'
+import {isFeatureAvailable as isCacheAvailable} from '@actions/cache'
 import {join} from 'path'
+import {restore} from './cache'
 import {setUpDependencies} from './dependencies'
 import {setUpGUComponents} from './gu'
 import {setUpMandrel} from './mandrel'
@@ -10,14 +12,15 @@ import {setUpWindowsEnvironment} from './msvc'
 
 async function run(): Promise<void> {
   try {
-    const graalvmVersion = core.getInput('version', {required: true})
-    const gdsToken = core.getInput('gds-token')
-    const javaVersion = core.getInput('java-version', {required: true})
-    const componentsString: string = core.getInput('components')
+    const graalvmVersion = core.getInput(c.INPUT_VERSION, {required: true})
+    const gdsToken = core.getInput(c.INPUT_GDS_TOKEN)
+    const javaVersion = core.getInput(c.INPUT_JAVA_VERSION, {required: true})
+    const componentsString: string = core.getInput(c.INPUT_COMPONENTS)
     const components: string[] =
       componentsString.length > 0 ? componentsString.split(',') : []
-    const setJavaHome = core.getInput('set-java-home') === 'true'
-    const enableNativeImageMusl = core.getInput('native-image-musl') === 'true'
+    const setJavaHome = core.getInput(c.INPUT_SET_JAVA_HOME) === 'true'
+    const cache = core.getInput(c.INPUT_CACHE)
+    const enableNativeImageMusl = core.getInput(c.INPUT_NI_MUSL) === 'true'
 
     if (c.IS_WINDOWS) {
       setUpWindowsEnvironment()
@@ -67,6 +70,10 @@ async function run(): Promise<void> {
         await setUpGUComponents(gdsToken, graalVMHome, components)
       }
     }
+
+    if (cache && isCacheAvailable()) {
+      await restore(cache)
+    }
   } catch (error) {
     if (error instanceof Error) core.setFailed(error.message)
   }

src/utils.ts

@@ -112,3 +112,7 @@ function toSemVer(version: string): string {
   const patch = parts.length > 2 ? parts.slice(2).join('-') : '0'
   return `${major}.${minor}.${patch}`
 }
+
+export function isJobStatusSuccess(): boolean {
+  return core.getInput(c.INPUT_JOB_STATUS) === 'success'
+}

tsconfig.json

@@ -5,7 +5,7 @@
     "outDir": "./lib",                        /* Redirect output structure to the directory. */
     "rootDir": "./src",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
     "strict": true,                           /* Enable all strict type-checking options. */
-    "noImplicitAny": true,                    /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "noImplicitAny": true,                    /* Raise error on expressions and declarations with an implied 'any' type. */
     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
   },
   "exclude": ["node_modules", "**/*.test.ts"]