Merge pull request #192 from sylvestre/release

prepare release 0.0.9 + force github action 2

.github/dependabot.yml

@@ -4,3 +4,11 @@ updates:
     directory: "/"
     schedule:
       interval: "monthly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    groups:
+      github-actions:
+        patterns:
+          - "*"  # Group all Actions updates into a single larger pull request
+    schedule:
+      interval: "weekly"

.github/workflows/CI.yml

@@ -21,11 +21,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-      - name: Setup Node.js 16.x
-        uses: actions/setup-node@v3
+        uses: actions/checkout@v4
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
         with:
-          node-version: 16.x
+          node-version: 18.x
           cache: npm
 
       - name: npm install
@@ -52,12 +52,12 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - name: Set Node.js 16.x
-        uses: actions/setup-node@v3
+      - name: Set Node.js
+        uses: actions/setup-node@v4
         with:
-          node-version: 16.x
+          node-version: 18.x
           cache: npm
 
       - name: npm install
@@ -71,3 +71,28 @@ jobs:
       - name: Run sccache for check
         shell: bash
         run: ${SCCACHE_PATH} --start-server
+
+  test_disable_annotations:
+    name: Test disable_annotations version
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18.x
+          cache: npm
+
+      - name: npm install
+        run: npm install
+
+      - name: Run sccache-cache
+        uses: ./
+        with:
+          disable_annotations: true
+
+      - name: Run sccache for check
+        shell: bash
+        run: ${SCCACHE_PATH} --start-server

README.md

@@ -16,7 +16,7 @@ Just copy and paste the following in your GitHub action:
 
 ```
 - name: Run sccache-cache
-  uses: mozilla-actions/sccache-action@v0.0.3
+  uses: mozilla-actions/sccache-action@v0.0.9
 ```
 
 ### Conditionally run cache and enable it
@@ -24,7 +24,7 @@ Just copy and paste the following in your GitHub action:
 ```
 - name: Run sccache-cache only on non-release runs
   if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
-  uses: mozilla-actions/sccache-action@v0.0.3
+  uses: mozilla-actions/sccache-action@v0.0.9
 - name: Set Rust caching env vars only on non-release runs
   if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
   run: |
@@ -34,11 +34,13 @@ Just copy and paste the following in your GitHub action:
 
 ### Specify a given version of sccache
 
+Versions prior to sccache v0.10.0 probably will not work.
+
 ```
 - name: Run sccache-cache
-  uses: mozilla-actions/sccache-action@v0.0.3
+  uses: mozilla-actions/sccache-action@v0.0.9
   with:
-    version: "v0.7.4"
+    version: "v0.10.0"
 ```
 
 ### To get the execution stats
@@ -52,6 +54,15 @@ Note that using the previous declaration will automatically create a
   run: ${SCCACHE_PATH} --show-stats
 ```
 
+### disable stats report
+
+```
+- name: Run sccache-cache
+  uses: mozilla-actions/sccache-action
+  with:
+    disable_annotations: true
+```
+
 ### Rust code
 
 For Rust code, the following environment variables should be set:
@@ -81,17 +92,33 @@ With cmake, add the following argument:
 With configure, call it with:
 ```
 # With gcc
-./configure CC="sccache gcc" CXX=sccache gcc"
+./configure CC="sccache gcc" CXX="sccache gcc"
 # With clang
-./configure CC="sccache clang" CXX=sccache clang"
+./configure CC="sccache clang" CXX="sccache clang"
 ```
 
+## Using on GitHub Enterprise Server (GHES)
+
+When using the action on GitHub Enterprise Server installations a valid GitHub.com token must be provided.
+
+```
+- name: Run sccache-cache
+  uses: mozilla-actions/sccache-action@v0.0.9
+  with:
+    token: ${{ secrets.MY_GITHUB_TOKEN }}
+```
+
+Note that using https://github.com/actions/create-github-app-token is a better option than storing a fixed token in the repo secrets.
+
 ## Prepare a new release
 
 1. Update the example in README.md
 1. Update version in `package.json`
 1. Run `npm i --package-lock-only`
-1. Tag a new release
+1. Run `npm run build`
+1. Commit and push the local changes
+1. Tag a new release (vX.X.X)
+1. Create a new release in github
 
 ## License
 

action.yml

@@ -8,6 +8,9 @@ inputs:
   token:
     description: "Used to pull the latest release from sccache. When running this action outside of github.com, you have to pass a personal access token for github.com."
     default: ${{ github.server_url == 'https://github.com' && github.token || '' }}
+  disable_annotations:
+    description: "Disable annotation generation in post-run."
+    default: 'false'
 runs:
   using: "node20"
   main: "dist/setup/index.js"

package.json

@@ -1,8 +1,11 @@
 {
   "name": "sccache-action",
-  "version": "0.0.3",
+  "version": "0.0.9",
   "description": "Github Action for Sccache",
   "main": "dist/setup/index.js",
+  "engines": {
+    "node": ">=16"
+  },
   "scripts": {
     "build-dist": "ncc build lib/setup.js -m -o dist/setup/ && ncc build lib/show_stats.js -m -o dist/show_stats",
     "build": "prettier --write **/*.ts && tsc && npm run build-dist",
@@ -25,25 +28,25 @@
   },
   "homepage": "https://github.com/mozilla-actions/sccache-action#readme",
   "dependencies": {
-    "@actions/core": "^1.10.0",
-    "@actions/github": "^5.1.1",
+    "@actions/core": "^1.11.1",
+    "@actions/github": "^6.0.0",
     "@actions/io": "^1.1.3",
-    "@actions/tool-cache": "^2.0.1"
+    "@actions/tool-cache": "^2.0.2"
   },
   "devDependencies": {
-    "@types/jest": "^27.4.1",
-    "@types/node": "^20.10.6",
-    "@typescript-eslint/eslint-plugin": "^5.59.9",
-    "@typescript-eslint/parser": "^5.59.9",
-    "@vercel/ncc": "^0.38.1",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jest": "^27.6.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "jest": "^27.5.1",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.0",
+    "@typescript-eslint/eslint-plugin": "^7.16.1",
+    "@typescript-eslint/parser": "^7.11.0",
+    "@vercel/ncc": "^0.38.3",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.11.0",
+    "eslint-plugin-prettier": "^5.2.3",
+    "jest": "^29.7.0",
     "jest-circus": "^29.7.0",
-    "prettier": "^2.8.8",
-    "ts-jest": "^27.1.4",
-    "typescript": "^4.9.5"
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.2.6",
+    "typescript": "^5.7.2"
   }
 }

src/setup.ts

@@ -17,7 +17,8 @@ import {
   downloadTool,
   extractTar,
   extractZip,
-  cacheDir
+  cacheDir,
+  find
 } from '@actions/tool-cache';
 import {getOctokit} from '@actions/github';
 
@@ -30,7 +31,7 @@ async function setup() {
   if (version.length === 0) {
     // If no version is specified, the latest version is used by default.
     const token = core.getInput('token', {required: true});
-    const octokit = getOctokit(token);
+    const octokit = getOctokit(token, {baseUrl: 'https://api.github.com'});
     const release = await octokit.rest.repos.getLatestRelease({
       owner: 'mozilla',
       repo: 'sccache'
@@ -39,8 +40,51 @@ async function setup() {
   }
   core.info(`try to setup sccache version: ${version}`);
 
+  // Search local file system cache for sccache.
+  // This is useful when actions run on a self-hosted runner.
+  let sccacheHome = find('sccache', version);
+  if (sccacheHome === '') {
+    const sccachePath = await downloadSCCache(version);
+    if (sccachePath instanceof Error) {
+      core.setFailed(sccachePath.message);
+      return;
+    } else {
+      const dirname = getDirname(version);
+      // Cache sccache.
+      sccacheHome = await cacheDir(
+        `${sccachePath}/${dirname}`,
+        'sccache',
+        version
+      );
+      core.info(`sccache cached to: ${sccacheHome}`);
+    }
+  } else {
+    core.info(`find sccache at: ${sccacheHome}`);
+  }
+  // Add sccache into path.
+  core.addPath(`${sccacheHome}`);
+  // Expose the sccache path as env.
+  core.exportVariable('SCCACHE_PATH', `${sccacheHome}/sccache`);
+
+  // Force the github action v2
+  core.exportVariable('ACTIONS_CACHE_SERVICE_V2', `on`);
+
+  // Expose the gha cache related variable to make it easier for users to
+  // integrate with gha support.
+  core.exportVariable(
+    'ACTIONS_RESULTS_URL',
+    process.env.ACTIONS_RESULTS_URL || ''
+  );
+  core.exportVariable(
+    'ACTIONS_RUNTIME_TOKEN',
+    process.env.ACTIONS_RUNTIME_TOKEN || ''
+  );
+}
+/**
+ * @param version sccache version
+ * @returns Path to sccache on success. Error on checksum verification failure. */
+async function downloadSCCache(version: string): Promise<Error | string> {
   const filename = getFilename(version);
-  const dirname = getDirname(version);
 
   const downloadUrl = `https://github.com/mozilla/sccache/releases/download/${version}/${filename}`;
   const sha256Url = `${downloadUrl}.sha256`;
@@ -63,8 +107,7 @@ async function setup() {
 
   // Compare the checksums.
   if (calculatedChecksum !== providedChecksum) {
-    core.setFailed('Checksum verification failed');
-    return;
+    return Error('Checksum verification failed');
   }
   core.info(`Correct checksum: ${calculatedChecksum}`);
 
@@ -75,27 +118,7 @@ async function setup() {
     sccachePath = await extractTar(sccachePackage);
   }
   core.info(`sccache extracted to: ${sccachePath}`);
-
-  // Cache sccache.
-  const sccacheHome = await cacheDir(
-    `${sccachePath}/${dirname}`,
-    'sccache',
-    version
-  );
-  core.info(`sccache cached to: ${sccacheHome}`);
-
-  // Add cached sccache into path.
-  core.addPath(`${sccacheHome}`);
-  // Expose the sccache path as env.
-  core.exportVariable('SCCACHE_PATH', `${sccacheHome}/sccache`);
-
-  // Expose the gha cache related variable to make users easier to
-  // integrate with gha support.
-  core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
-  core.exportVariable(
-    'ACTIONS_RUNTIME_TOKEN',
-    process.env.ACTIONS_RUNTIME_TOKEN || ''
-  );
+  return sccachePath;
 }
 
 function getFilename(version: string): Error | string {
@@ -112,8 +135,10 @@ function getArch(): Error | string {
       return 'x86_64';
     case 'arm64':
       return 'aarch64';
+    case 'arm':
+      return 'armv7';
     default:
-      return Error('Unsupported arch "${process.arch}"');
+      return Error(`Unsupported arch "${process.arch}"`);
   }
 }
 
@@ -124,9 +149,13 @@ function getPlatform(): Error | string {
     case 'win32':
       return 'pc-windows-msvc';
     case 'linux':
-      return 'unknown-linux-musl';
+      if (process.arch == 'arm') {
+        return 'unknown-linux-musleabi';
+      } else {
+        return 'unknown-linux-musl';
+      }
     default:
-      return Error('Unsupported platform "${process.platform}"');
+      return Error(`Unsupported platform "${process.platform}"`);
   }
 }
 

src/show_stats.ts

@@ -14,24 +14,156 @@
 
 import * as core from '@actions/core';
 import * as exec from '@actions/exec';
+import {SummaryTableRow} from '@actions/core/lib/summary';
+
+async function get_output(command: string, args: string[]): Promise<string> {
+  core.debug(`get_output: ${command} ${args.join(' ')}`);
+
+  const output = await exec.getExecOutput(command, args);
+  // --stats-format=json does not emit a newline, which messes up group
+  // processing. Here we add a newline if it's missing.
+  if (!output.stdout.endsWith('\n')) {
+    process.stdout.write('\n');
+  }
+  return output.stdout.toString();
+}
 
 async function show_stats() {
+  const disable_annotations = core.getBooleanInput('disable_annotations');
+  if (disable_annotations) {
+    core.debug('annotations generation disabled');
+    return;
+  }
+
   core.debug('start sccache show starts');
-
-  const defaultListener = {
-    stdout: (data: Buffer) => {
-      stdout.push(data.toString());
-    }
-  };
-
-  const stdout: string[] = [];
-
-  await exec.getExecOutput(`${process.env.SCCACHE_PATH}`, ['--show-stats'], {
-    listeners: defaultListener
+  const human_stats = await core.group('Get human-readable stats', async () => {
+    return get_output(`${process.env.SCCACHE_PATH}`, ['--show-stats']);
   });
+  const json_stats = await core.group('Get JSON stats', async () => {
+    return get_output(`${process.env.SCCACHE_PATH}`, [
+      '--show-stats',
+      '--stats-format=json'
+    ]);
+  });
+
+  const stats: Stats = JSON.parse(json_stats);
+  const formatted_stats = format_json_stats(stats);
+
+  core.notice(formatted_stats.notice, {
+    title: 'sccache stats'
+  });
+  core.info('\nFull human-readable stats:');
+  core.info(human_stats);
+
+  core.summary.addHeading('sccache stats', 2);
+  core.summary.addTable(formatted_stats.table);
+  core.summary.addDetails(
+    'Full human-readable stats',
+    '\n\n```\n' + human_stats + '\n```\n\n'
+  );
+  core.summary.addDetails(
+    'Full JSON Stats',
+    '\n\n```json\n' + JSON.stringify(stats, null, 2) + '\n```\n\n'
+  );
+
+  await core.summary.write();
 }
 
 show_stats().catch(err => {
   core.error(err);
   core.setFailed(err.message);
 });
+
+interface Duration {
+  secs: number;
+  nanos: number;
+}
+
+interface Counter {
+  counts: {
+    [key: string]: number;
+  };
+  adv_counts: {
+    [key: string]: number;
+  };
+}
+
+interface Stats {
+  stats: {
+    compile_requests: number;
+    requests_executed: number;
+
+    cache_errors: Counter;
+    cache_hits: Counter;
+    cache_misses: Counter;
+
+    cache_write_errors: number;
+    cache_writes: number;
+
+    cache_write_duration: Duration;
+    cache_read_hit_duration: Duration;
+    compiler_write_duration: Duration;
+  };
+}
+
+function sum_stats(stats: Counter): number {
+  return Object.values(stats.counts).reduce((acc, val) => acc + val, 0);
+}
+
+function format_duration(duration: Duration): string {
+  const ms = duration.nanos / 1e6;
+  return `${duration.secs}s ${ms}ms`;
+}
+
+function format_json_stats(stats: Stats): {
+  table: SummaryTableRow[];
+  notice: string;
+} {
+  const cache_error_count = sum_stats(stats.stats.cache_errors);
+  const cache_hit_count = sum_stats(stats.stats.cache_hits);
+  const cache_miss_count = sum_stats(stats.stats.cache_misses);
+  const total_hits = cache_hit_count + cache_miss_count + cache_error_count;
+  const ratio = percentage(cache_hit_count, total_hits);
+
+  const write_duration = format_duration(stats.stats.cache_write_duration);
+  const read_duration = format_duration(stats.stats.cache_read_hit_duration);
+  const compiler_duration = format_duration(
+    stats.stats.compiler_write_duration
+  );
+
+  const notice = `${ratio}% - ${cache_hit_count} hits, ${cache_miss_count} misses, ${cache_error_count} errors`;
+
+  const table = [
+    [{data: 'Cache hit %', header: true}, {data: `${ratio}%`}],
+    [{data: 'Cache hits', header: true}, {data: cache_hit_count.toString()}],
+    [{data: 'Cache misses', header: true}, {data: cache_miss_count.toString()}],
+    [
+      {data: 'Cache errors', header: true},
+      {data: cache_error_count.toString()}
+    ],
+    [
+      {data: 'Compile requests', header: true},
+      {data: stats.stats.compile_requests.toString()}
+    ],
+    [
+      {data: 'Requests executed', header: true},
+      {data: stats.stats.requests_executed.toString()}
+    ],
+    [
+      {data: 'Cache writes', header: true},
+      {data: stats.stats.cache_writes.toString()}
+    ],
+    [
+      {data: 'Cache write errors', header: true},
+      {data: stats.stats.cache_write_errors.toString()}
+    ],
+    [{data: 'Cache write duration', header: true}, {data: write_duration}],
+    [{data: 'Cache read hit duration', header: true}, {data: read_duration}],
+    [{data: 'Compiler write duration', header: true}, {data: compiler_duration}]
+  ];
+  return {table, notice};
+}
+
+function percentage(x: number, y: number): number {
+  return Math.round((x / y) * 100 || 0);
+}