Compare commits

..
3 Commits
Author SHA1 Message Date
v-gowridurgadandgowridurgad 66f83c8206 fix: exclude prereleases when resolving latest/current/node aliases (#1668)
* exclude prereleases when resolving latest/current/node aliases

* test: verify stable install succeeds when skipping prereleases

---------

Co-authored-by: gowridurgad <gowridurgad@gmail.com>
2026-11-17 10:09:09 -06:00
dependabot[bot] 436c65619b Bump handlebars from 4.7.9 to 4.7.10 (#1648)
Bumps [handlebars](https://github.com/handlebars-lang/handlebars.js) from 4.7.9 to 4.7.10.
- [Release notes](https://github.com/handlebars-lang/handlebars.js/releases)
- [Changelog](https://github.com/handlebars-lang/handlebars.js/blob/v4.7.10/release-notes.md)
- [Commits](https://github.com/handlebars-lang/handlebars.js/compare/v4.7.9...v4.7.10)

---
updated-dependencies:
- dependency-name: handlebars
  dependency-version: 4.7.10
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2026-11-13 12:16:28 -06:00
Ruben Bridgewater 101b347414 fix: avoid GitHub API rate limits for the Node manifest (#1627)
* fix: avoid GitHub API rate limits for the Node manifest

Large job matrices exhaust the shared GITHUB_TOKEN rate limit because each cold manifest lookup resolves a repository tree and blob through the REST API.

Use the fixed raw manifest and reuse it within a job. check-latest always refreshes it, and the authenticated API remains a fallback.

* fix: preserve check-latest manifest freshness

Raw manifest responses can remain cached for five minutes, so check-latest keeps the GitHub API path while normal setup steps reuse the job manifest.

* fix(manifest): use authenticated API with raw fallback

LTS resolution with check-latest cannot recover from API failures because it
bypasses raw retrieval. The disk cache cannot reduce requests across matrix
jobs and introduces unneeded state.
2026-11-03 20:27:46 -06:00
6 changed files with 524 additions and 106 deletions

No files matched your search

+4 -1
View File
@@ -270,7 +270,10 @@ jobs:
steps: steps:
- name: Get node version - name: Get node version
run: | run: |
latestNodeVersion=$(curl https://nodejs.org/dist/index.json | jq -r '. [0].version') latestNodeVersion=$(
curl -fsSL https://nodejs.org/dist/index.json |
jq -r 'first(.[] | select(.version | test("-") | not) | .version)'
)
echo "LATEST_NODE_VERSION=$latestNodeVersion" >> $GITHUB_OUTPUT echo "LATEST_NODE_VERSION=$latestNodeVersion" >> $GITHUB_OUTPUT
id: version id: version
shell: bash shell: bash
+8 -3
View File
@@ -151,9 +151,10 @@ Examples:
**Note:** Like the other values, `*` will get the latest [locally-cached Node.js version](https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2204-Readme.md#nodejs), or the latest version from [actions/node-versions](https://github.com/actions/node-versions/blob/main/versions-manifest.json), depending on the [`check-latest`](docs/advanced-usage.md#check-latest-version) input. **Note:** Like the other values, `*` will get the latest [locally-cached Node.js version](https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2204-Readme.md#nodejs), or the latest version from [actions/node-versions](https://github.com/actions/node-versions/blob/main/versions-manifest.json), depending on the [`check-latest`](docs/advanced-usage.md#check-latest-version) input.
`current`/`latest`/`node` always resolve to the latest [dist version](https://nodejs.org/dist/index.json). `current`/`latest`/`node` always resolve to the latest stable version from [dist index](https://nodejs.org/dist/index.json) (prerelease entries are skipped).
That version is then downloaded from actions/node-versions if possible, or directly from Node.js if not. That version is then downloaded from actions/node-versions if possible, or directly from Node.js if not.
Since it will not be cached always, there is possibility of hitting rate limit when downloading from dist If no stable version is available in the dist index, setup fails with an explicit error.
Since it will not always be cached, there is a possibility of hitting rate limits when downloading from dist.
### Checking in lockfiles ### Checking in lockfiles
@@ -233,7 +234,11 @@ jobs:
## Using `setup-node` on GHES ## Using `setup-node` on GHES
`setup-node` comes pre-installed on the appliance with GHES if Actions is enabled. When dynamically downloading Nodejs distributions, `setup-node` downloads distributions from [`actions/node-versions`](https://github.com/actions/node-versions) on github.com (outside of the appliance). These calls to `actions/node-versions` are made via unauthenticated requests, which are limited to [60 requests per hour per IP](https://docs.github.com/en/rest/overview/resources-in-the-rest-api#rate-limiting). If more requests are made within the time frame, then you will start to see rate-limit errors during downloading that looks like: `##[error]API rate limit exceeded for...`. After that error the action will try to download versions directly from the official site, but it also can have rate limit so it's better to put token. `setup-node` comes pre-installed on the appliance with GHES if Actions is enabled. It downloads Node.js distributions from [`actions/node-versions`](https://github.com/actions/node-versions) on github.com, outside the appliance.
Manifest requests use the GitHub API first, with the `token` input for authentication when supplied. If API retrieval fails, the action tries the manifest on `raw.githubusercontent.com`. This fallback also applies when `check-latest` is enabled. If both manifest sources are unavailable, numeric versions can fall back to nodejs.org. LTS aliases require a manifest to resolve the requested version.
Unauthenticated API requests are limited to [60 requests per hour per IP](https://docs.github.com/en/rest/overview/resources-in-the-rest-api#rate-limiting). Supplying a token increases the API rate limit.
To get a higher rate limit, you can [generate a personal access token on github.com](https://github.com/settings/tokens/new) and pass it as the `token` input for the action: To get a higher rate limit, you can [generate a personal access token on github.com](https://github.com/settings/tokens/new) and pass it as the `token` input for the action:
+390 -39
View File
@@ -14,6 +14,8 @@ import osm from 'os';
import path from 'path'; import path from 'path';
const __dirname = path.dirname(fileURLToPath(import.meta.url)); const __dirname = path.dirname(fileURLToPath(import.meta.url));
const nodeVersionsManifestUrl =
'https://raw.githubusercontent.com/actions/node-versions/main/versions-manifest.json';
// Mock @actions modules before importing anything that depends on them // Mock @actions modules before importing anything that depends on them
jest.unstable_mockModule('@actions/core', () => ({ jest.unstable_mockModule('@actions/core', () => ({
@@ -129,6 +131,21 @@ const {default: nodeV8CanaryTestDist} = await import(
import type {INodeVersion} from '../src/distributions/base-models.js'; import type {INodeVersion} from '../src/distributions/base-models.js';
import type {IToolRelease} from '@actions/tool-cache'; import type {IToolRelease} from '@actions/tool-cache';
function useRetryTimers() {
beforeEach(() => {
jest.useFakeTimers();
});
afterEach(() => {
jest.useRealTimers();
});
}
async function runWithRetries() {
const setup = main.run();
await jest.runAllTimersAsync();
await setup;
}
describe('setup-node', () => { describe('setup-node', () => {
let build: InstanceType<typeof OfficialBuilds>; let build: InstanceType<typeof OfficialBuilds>;
let inputs = {} as any; let inputs = {} as any;
@@ -233,7 +250,9 @@ describe('setup-node', () => {
getJsonSpy.mockImplementation((url: any) => { getJsonSpy.mockImplementation((url: any) => {
let res: any; let res: any;
if (url.includes('/rc')) { if (url === nodeVersionsManifestUrl) {
throw new Error('Unable to download raw manifest');
} else if (url.includes('/rc')) {
res = <INodeVersion[]>nodeTestDistRc; res = <INodeVersion[]>nodeTestDistRc;
} else if (url.includes('/nightly')) { } else if (url.includes('/nightly')) {
res = <INodeVersion[]>nodeTestDistNightly; res = <INodeVersion[]>nodeTestDistNightly;
@@ -649,7 +668,7 @@ describe('setup-node', () => {
expect(logSpy).toHaveBeenCalledWith( expect(logSpy).toHaveBeenCalledWith(
'Attempt to resolve the latest version from manifest...' 'Attempt to resolve the latest version from manifest...'
); );
expect(dbgSpy).toHaveBeenCalledWith('No manifest cached'); expect(dbgSpy).not.toHaveBeenCalledWith('No manifest cached');
expect(dbgSpy).toHaveBeenCalledWith( expect(dbgSpy).toHaveBeenCalledWith(
'Getting manifest from actions/node-versions@main' 'Getting manifest from actions/node-versions@main'
); );
@@ -677,7 +696,7 @@ describe('setup-node', () => {
expect(logSpy).toHaveBeenCalledWith( expect(logSpy).toHaveBeenCalledWith(
'Attempt to resolve the latest version from manifest...' 'Attempt to resolve the latest version from manifest...'
); );
expect(dbgSpy).toHaveBeenCalledWith('No manifest cached'); expect(dbgSpy).not.toHaveBeenCalledWith('No manifest cached');
expect(dbgSpy).toHaveBeenCalledWith( expect(dbgSpy).toHaveBeenCalledWith(
'Getting manifest from actions/node-versions@main' 'Getting manifest from actions/node-versions@main'
); );
@@ -716,7 +735,7 @@ describe('setup-node', () => {
expect(logSpy).toHaveBeenCalledWith( expect(logSpy).toHaveBeenCalledWith(
'Attempt to resolve the latest version from manifest...' 'Attempt to resolve the latest version from manifest...'
); );
expect(dbgSpy).toHaveBeenCalledWith('No manifest cached'); expect(dbgSpy).not.toHaveBeenCalledWith('No manifest cached');
expect(dbgSpy).toHaveBeenCalledWith( expect(dbgSpy).toHaveBeenCalledWith(
'Getting manifest from actions/node-versions@main' 'Getting manifest from actions/node-versions@main'
); );
@@ -774,6 +793,8 @@ describe('setup-node', () => {
}); });
describe('LTS version', () => { describe('LTS version', () => {
useRetryTimers();
beforeEach(() => { beforeEach(() => {
os.platform = 'linux'; os.platform = 'linux';
os.arch = 'x64'; os.arch = 'x64';
@@ -929,7 +950,7 @@ describe('setup-node', () => {
}); });
// act // act
await main.run(); await runWithRetries();
// assert // assert
expect(logSpy).toHaveBeenCalledWith( expect(logSpy).toHaveBeenCalledWith(
@@ -939,12 +960,14 @@ describe('setup-node', () => {
'Getting manifest from actions/node-versions@main' 'Getting manifest from actions/node-versions@main'
); );
expect(setFailedSpy).toHaveBeenCalledWith( expect(setFailedSpy).toHaveBeenCalledWith(
`Failed to fetch a valid manifest after 3 attempts. Last error: Unable to download manifest` 'Failed to fetch a valid manifest from the GitHub API and raw URL. API: Unable to download manifest. Raw: Unable to download raw manifest'
); );
}, 10000); });
}); });
describe('latest alias syntax', () => { describe('latest alias syntax', () => {
useRetryTimers();
it.each(['latest', 'current', 'node'])( it.each(['latest', 'current', 'node'])(
'download the %s version if alias is provided', 'download the %s version if alias is provided',
async inputVersion => { async inputVersion => {
@@ -960,16 +983,120 @@ describe('setup-node', () => {
}); });
// Act // Act
await main.run(); await runWithRetries();
// assert // assert
expect(logSpy).toHaveBeenCalledWith( expect(logSpy).toHaveBeenCalledWith(
'Failed to fetch a valid manifest after 3 attempts. Last error: Unable to download manifest' 'Failed to fetch a valid manifest from the GitHub API and raw URL. API: Unable to download manifest. Raw: Unable to download raw manifest'
); );
expect(logSpy).toHaveBeenCalledWith('getting latest node version...'); expect(logSpy).toHaveBeenCalledWith('getting latest node version...');
}, }
10000 );
it.each(['latest', 'current', 'node'])(
'skips a newer prerelease and selects the latest stable version for %s',
async inputVersion => {
// Arrange
inputs['node-version'] = inputVersion;
const stableVersion = nodeTestDist[0];
const prereleaseVersion = {
...nodeTestDist[0],
version: 'v99.0.0-alpha.1'
};
os.platform = 'darwin';
os.arch = 'x64';
const cleanStableVersion = stableVersion.version.replace(/^v/, '');
const toolPath = path.normalize(
`/cache/node/${cleanStableVersion}/x64`
);
findSpy.mockImplementation(() => '');
getManifestSpy.mockImplementation(() => {
throw new Error('Unable to download manifest');
});
getJsonSpy.mockImplementation((url: any) => {
if (url === nodeVersionsManifestUrl) {
throw new Error('Unable to download raw manifest');
}
return {result: [prereleaseVersion, ...nodeTestDist]};
});
dlSpy.mockImplementation(async () => '/some/temp/path');
exSpy.mockImplementation(async () => '/some/other/temp/path');
cacheSpy.mockImplementation(async () => toolPath);
getExecOutputSpy.mockImplementation(async () => ({
stdout: `v${cleanStableVersion}\n`,
stderr: '',
exitCode: 0
}));
// Act
await runWithRetries();
// assert
expect(findSpy).toHaveBeenCalledWith(
'node',
stableVersion.version,
'x64'
);
expect(findSpy).not.toHaveBeenCalledWith(
'node',
prereleaseVersion.version,
'x64'
);
expect(dlSpy).toHaveBeenCalledWith(
`https://nodejs.org/dist/v${cleanStableVersion}/node-v${cleanStableVersion}-darwin-x64.tar.gz`,
undefined,
undefined
);
expect(setFailedSpy).not.toHaveBeenCalled();
expect(addPathSpy).toHaveBeenCalledWith(path.join(toolPath, 'bin'));
}
);
const prereleaseOnlyIndex = [
{...nodeTestDist[0], version: 'v99.0.0-alpha.1'}
];
it.each([
['latest', 'an empty index', []],
['current', 'an empty index', []],
['node', 'an empty index', []],
['latest', 'a prerelease-only index', prereleaseOnlyIndex],
['current', 'a prerelease-only index', prereleaseOnlyIndex],
['node', 'a prerelease-only index', prereleaseOnlyIndex]
])(
'fails with the stable-version error for %s with %s',
async (inputVersion, _description, index) => {
// Arrange
inputs['node-version'] = inputVersion;
os.platform = 'darwin';
os.arch = 'x64';
findSpy.mockImplementation(() => '');
getManifestSpy.mockImplementation(() => {
throw new Error('Unable to download manifest');
});
getJsonSpy.mockImplementation((url: any) => {
if (url === nodeVersionsManifestUrl) {
throw new Error('Unable to download raw manifest');
}
return {result: index};
});
// Act
await runWithRetries();
// assert
expect(setFailedSpy).toHaveBeenCalledWith(
`Unable to find a stable Node version for '${inputVersion}' on platform ${os.platform} and architecture ${os.arch}.`
);
}
); );
}); });
@@ -995,6 +1122,11 @@ describe('setup-node', () => {
// assert // assert
expect(logSpy).toHaveBeenCalledWith('getting latest node version...'); expect(logSpy).toHaveBeenCalledWith('getting latest node version...');
expect(findSpy).toHaveBeenCalledWith(
'node',
expectedVersion.version,
'x64'
);
expect(logSpy).toHaveBeenCalledWith(`Found in cache @ ${toolPath}`); expect(logSpy).toHaveBeenCalledWith(`Found in cache @ ${toolPath}`);
} }
); );
@@ -1040,53 +1172,272 @@ describe('setup-node', () => {
} }
}, 100000); }, 100000);
describe('manifest retry and validation', () => { describe('manifest retrieval', () => {
useRetryTimers();
let installedVersion: string;
beforeEach(() => { beforeEach(() => {
installedVersion = '12.16.2';
os.platform = 'linux'; os.platform = 'linux';
os.arch = 'x64'; os.arch = 'x64';
inputs['node-version'] = 'lts/erbium'; inputs['node-version'] = 'lts/erbium';
inputs['token'] = 'manifest-token';
whichSpy.mockImplementation(async (tool: string) => tool);
findSpy.mockImplementation(() => ''); findSpy.mockImplementation(() => '');
}); getJsonSpy.mockImplementation((url: string) => ({
result:
it('retries fetching the manifest and succeeds on a later attempt', async () => { url === nodeVersionsManifestUrl ? nodeTestManifest : nodeTestDist
let calls = 0; }));
getManifestSpy.mockImplementation(() => {
calls++;
if (calls < 2) {
throw new Error('transient network failure');
}
return <tc.IToolRelease[]>nodeTestManifest;
});
dlSpy.mockImplementation(async () => '/some/temp/path'); dlSpy.mockImplementation(async () => '/some/temp/path');
const toolPath = path.normalize('/cache/node/12.16.2/x64');
exSpy.mockImplementation(async () => '/some/other/temp/path'); exSpy.mockImplementation(async () => '/some/other/temp/path');
cacheSpy.mockImplementation(async () => toolPath); cacheSpy.mockImplementation(
async (
_sourceDirectory: string,
_tool: string,
version: string,
arch: string
) => {
installedVersion = version;
return path.normalize(`/cache/node/${version}/${arch}`);
}
);
getExecOutputSpy.mockImplementation(async () => ({ getExecOutputSpy.mockImplementation(async () => ({
stdout: `v${path.basename(path.dirname(toolPath))}\n`, stdout: `v${installedVersion}\n`,
stderr: '', stderr: '',
exitCode: 0 exitCode: 0
})); }));
});
await main.run(); describe.each([
{versionSpec: 'lts/erbium', checkLatest: 'false'},
{versionSpec: 'lts/erbium', checkLatest: 'true'},
{versionSpec: '12', checkLatest: 'false'},
{versionSpec: '12', checkLatest: 'true'}
])('$versionSpec, check-latest: $checkLatest', mode => {
beforeEach(() => {
inputs['node-version'] = mode.versionSpec;
inputs['check-latest'] = mode.checkLatest;
});
expect(calls).toBe(2); it('uses the authenticated API without requesting raw', async () => {
expect(logSpy).toHaveBeenCalledWith('Retrying to fetch the manifest...'); await runWithRetries();
expect(dbgSpy).toHaveBeenCalledWith(
`Found LTS release '12.16.2' for Node version 'lts/erbium'` expect(getJsonSpy).not.toHaveBeenCalled();
expect(getManifestSpy).toHaveBeenCalledTimes(1);
expect(getManifestSpy).toHaveBeenCalledWith(
'actions',
'node-versions',
'token manifest-token',
'main'
); );
}, 10000); expect(core.setOutput).toHaveBeenCalledWith('node-version', 'v12.16.2');
expect(setFailedSpy).not.toHaveBeenCalled();
});
it('rejects an empty manifest as invalid and retries', async () => { it.each([403, 429])(
getManifestSpy.mockImplementation(() => []); 'falls back to raw immediately after API HTTP %i',
async statusCode => {
getManifestSpy.mockImplementation(() => {
throw Object.assign(new Error('API unavailable'), {statusCode});
});
const startedAt = Date.now();
await main.run(); await runWithRetries();
expect(setFailedSpy).not.toHaveBeenCalled();
expect(getManifestSpy).toHaveBeenCalledTimes(1);
expect(getJsonSpy).toHaveBeenCalledTimes(1);
expect(getJsonSpy).toHaveBeenCalledWith(nodeVersionsManifestUrl);
expect(getManifestSpy.mock.invocationCallOrder[0]).toBeLessThan(
getJsonSpy.mock.invocationCallOrder[0]
);
expect(Date.now()).toBe(startedAt);
expect(core.setOutput).toHaveBeenCalledWith(
'node-version',
'v12.16.2'
);
}
);
});
it('refreshes the manifest for a later action invocation', async () => {
inputs['node-version'] = '12';
await runWithRetries();
getManifestSpy.mockClear();
const latestVersion = '12.17.0';
getManifestSpy.mockImplementation(() => [
{
version: latestVersion,
stable: true,
release_url: `https://github.com/actions/node-versions/releases/tag/${latestVersion}`,
files: [
{
filename: `node-${latestVersion}-linux-x64.tar.gz`,
arch: 'x64',
platform: 'linux',
download_url: `https://github.com/actions/node-versions/releases/download/${latestVersion}/node-${latestVersion}-linux-x64.tar.gz`
}
]
},
...nodeTestManifest
]);
inputs['check-latest'] = 'true';
await runWithRetries();
expect(logSpy).toHaveBeenCalledWith(`Resolved as '${latestVersion}'`);
expect(getJsonSpy).not.toHaveBeenCalled();
expect(getManifestSpy).toHaveBeenCalledTimes(1);
expect(core.setOutput).toHaveBeenCalledWith('node-version', 'v12.17.0');
expect(setFailedSpy).not.toHaveBeenCalled();
});
it('does not fetch a manifest for an installed numeric version', async () => {
inputs['node-version'] = '12';
findSpy.mockReturnValue(path.normalize('/cache/node/12.16.2/x64'));
await runWithRetries();
expect(getManifestSpy).not.toHaveBeenCalled();
expect(getJsonSpy).not.toHaveBeenCalled();
expect(setFailedSpy).not.toHaveBeenCalled();
expect(core.setOutput).toHaveBeenCalledWith('node-version', 'v12.16.2');
});
it('checks the manifest before using an installed version with check-latest', async () => {
inputs['node-version'] = '12';
inputs['check-latest'] = 'true';
findSpy.mockReturnValue(path.normalize('/cache/node/12.16.2/x64'));
await runWithRetries();
expect(getJsonSpy).not.toHaveBeenCalled();
expect(getManifestSpy).toHaveBeenCalledTimes(1);
expect(getManifestSpy.mock.invocationCallOrder[0]).toBeLessThan(
findSpy.mock.invocationCallOrder[0]
);
expect(setFailedSpy).not.toHaveBeenCalled();
});
it('uses an installed version when check-latest finds no matching release', async () => {
os.arch = 'arm64';
inputs['node-version'] = '12';
inputs['check-latest'] = 'true';
findSpy.mockReturnValue(path.normalize('/cache/node/12.16.2/arm64'));
await runWithRetries();
expect(getJsonSpy).not.toHaveBeenCalled();
expect(getManifestSpy).toHaveBeenCalledTimes(1);
expect(logSpy).toHaveBeenCalledWith(
'Failed to resolve version 12 from manifest'
);
expect(setFailedSpy).not.toHaveBeenCalled();
expect(core.setOutput).toHaveBeenCalledWith('node-version', 'v12.16.2');
});
it('retries a transient API failure before requesting raw', async () => {
getManifestSpy.mockImplementationOnce(() => {
throw new Error('transient network failure');
});
const startedAt = Date.now();
await runWithRetries();
expect(getJsonSpy).not.toHaveBeenCalled();
expect(getManifestSpy).toHaveBeenCalledTimes(2);
expect(Date.now() - startedAt).toBe(1000);
expect(setFailedSpy).not.toHaveBeenCalled();
});
it.each(['empty', 'unavailable'])(
'uses raw after retrying an %s API manifest',
async failure => {
getManifestSpy.mockImplementation(() => {
if (failure === 'unavailable') {
throw new Error('API unavailable');
}
return [];
});
const startedAt = Date.now();
await runWithRetries();
expect(getManifestSpy).toHaveBeenCalledTimes(3); expect(getManifestSpy).toHaveBeenCalledTimes(3);
expect(setFailedSpy).toHaveBeenCalledWith( expect(getJsonSpy).toHaveBeenCalledTimes(1);
`Failed to fetch a valid manifest after 3 attempts. Last error: The manifest fetched is empty, truncated, or does not contain any valid tool release entries.` expect(getJsonSpy).toHaveBeenCalledWith(nodeVersionsManifestUrl);
expect(Date.now() - startedAt).toBe(3000);
expect(setFailedSpy).not.toHaveBeenCalled();
expect(core.setOutput).toHaveBeenCalledWith('node-version', 'v12.16.2');
}
);
it.each([
['empty', []],
['malformed', null]
])(
'fails LTS setup when the API fails and raw is %s',
async (_, result) => {
getManifestSpy.mockImplementation(() => {
throw Object.assign(new Error('API unavailable'), {statusCode: 429});
});
getJsonSpy.mockImplementationOnce(() => ({result}));
await runWithRetries();
expect(getJsonSpy).toHaveBeenCalledWith(nodeVersionsManifestUrl);
expect(getManifestSpy).toHaveBeenCalledTimes(1);
expect(dlSpy).not.toHaveBeenCalled();
expect(setFailedSpy).toHaveBeenCalledWith(
expect.stringContaining('API: API unavailable. Raw: The manifest')
);
}
);
it('retains both source errors when LTS setup cannot fetch a manifest', async () => {
getManifestSpy.mockImplementation(() => {
throw Object.assign(new Error('API unavailable'), {statusCode: 403});
});
getJsonSpy.mockImplementationOnce(() => {
throw new Error('Raw unavailable');
});
await runWithRetries();
expect(dlSpy).not.toHaveBeenCalled();
expect(setFailedSpy).toHaveBeenCalledWith(
expect.stringContaining('API: API unavailable. Raw: Raw unavailable')
);
});
it.each(['false', 'true'])(
'uses Node dist when both sources fail with check-latest: %s',
async checkLatest => {
inputs['node-version'] = '12';
inputs['check-latest'] = checkLatest;
getManifestSpy.mockImplementation(() => {
throw Object.assign(new Error('API unavailable'), {statusCode: 403});
});
getJsonSpy.mockImplementation((url: string) => {
if (url === nodeVersionsManifestUrl) {
throw new Error('Raw unavailable');
}
return {result: nodeTestDist};
});
await runWithRetries();
expect(setFailedSpy).not.toHaveBeenCalled();
expect(getJsonSpy).toHaveBeenCalledWith(nodeVersionsManifestUrl);
expect(dlSpy).toHaveBeenCalledWith(
'https://nodejs.org/dist/v12.16.3/node-v12.16.3-linux-x64.tar.gz',
undefined,
undefined
);
expect(core.setOutput).toHaveBeenCalledWith('node-version', 'v12.16.3');
}
); );
}, 10000);
}); });
describe('node version verification', () => { describe('node version verification', () => {
+52 -23
View File
@@ -98982,12 +98982,21 @@ class NightlyNodejs extends BasePrereleaseNodejs {
} }
} }
;// CONCATENATED MODULE: external "node:path"
const external_node_path_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:path");
var external_node_path_default = /*#__PURE__*/__nccwpck_require__.n(external_node_path_namespaceObject);
;// CONCATENATED MODULE: ./src/distributions/official_builds/official_builds.ts ;// CONCATENATED MODULE: ./src/distributions/official_builds/official_builds.ts
const nodeVersionsManifestUrl = 'https://raw.githubusercontent.com/actions/node-versions/main/versions-manifest.json';
const invalidManifestMessage = 'The manifest fetched is empty, truncated, or does not contain any valid tool release entries.';
function isValidManifest(manifest) {
return Array.isArray(manifest) && manifest.length > 0;
}
class OfficialBuilds extends BaseDistribution { class OfficialBuilds extends BaseDistribution {
constructor(nodeInfo) { constructor(nodeInfo) {
super(nodeInfo); super(nodeInfo);
@@ -99010,7 +99019,16 @@ class OfficialBuilds extends BaseDistribution {
} }
if (this.nodeInfo.checkLatest) { if (this.nodeInfo.checkLatest) {
core_info('Attempt to resolve the latest version from manifest...'); core_info('Attempt to resolve the latest version from manifest...');
const resolvedVersion = await this.resolveVersionFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, osArch, manifest); let resolvedVersion;
try {
manifest ??= await this.getManifest();
const info = await this.getInfoFromManifest(this.nodeInfo.versionSpec, this.nodeInfo.stable, osArch, manifest);
resolvedVersion = info?.resolvedVersion;
}
catch (error) {
core_info('Unable to resolve version from manifest...');
core_debug(error.message);
}
if (resolvedVersion) { if (resolvedVersion) {
this.nodeInfo.versionSpec = resolvedVersion; this.nodeInfo.versionSpec = resolvedVersion;
core_info(`Resolved as '${resolvedVersion}'`); core_info(`Resolved as '${resolvedVersion}'`);
@@ -99061,14 +99079,14 @@ class OfficialBuilds extends BaseDistribution {
} }
const installedDir = toolPath; const installedDir = toolPath;
if (this.osPlat != 'win32') { if (this.osPlat != 'win32') {
toolPath = external_path_default().join(toolPath, 'bin'); toolPath = external_node_path_default().join(toolPath, 'bin');
} }
addPath(toolPath); addPath(toolPath);
await this.verifyNodeVersion(installedDir); await this.verifyNodeVersion(installedDir);
} }
addToolPath(toolPath) { addToolPath(toolPath) {
if (this.osPlat != 'win32') { if (this.osPlat != 'win32') {
toolPath = external_path_default().join(toolPath, 'bin'); toolPath = external_node_path_default().join(toolPath, 'bin');
} }
addPath(toolPath); addPath(toolPath);
} }
@@ -99097,7 +99115,11 @@ class OfficialBuilds extends BaseDistribution {
let version = ''; let version = '';
if (this.isLatestSyntax(this.nodeInfo.versionSpec)) { if (this.isLatestSyntax(this.nodeInfo.versionSpec)) {
core_info(`getting latest node version...`); core_info(`getting latest node version...`);
return versions[0]; const stableVersion = versions.find(potential => semver_default().prerelease(potential) === null);
if (!stableVersion) {
throw new Error(`Unable to find a stable Node version for '${this.nodeInfo.versionSpec}' on platform ${this.osPlat} and architecture ${this.nodeInfo.arch}.`);
}
return stableVersion;
} }
version = super.evaluateVersions(versions); version = super.evaluateVersions(versions);
return version; return version;
@@ -99109,27 +99131,44 @@ class OfficialBuilds extends BaseDistribution {
async getManifest() { async getManifest() {
let lastError; let lastError;
const maxAttempts = 3; const maxAttempts = 3;
core_debug(`Getting manifest from actions/node-versions@main`); core_debug('Getting manifest from actions/node-versions@main');
for (let attempt = 1; attempt <= maxAttempts; attempt++) { for (let attempt = 1; attempt <= maxAttempts; attempt++) {
try { try {
const manifest = await getManifestFromRepo('actions', 'node-versions', this.nodeInfo.mirror && this.nodeInfo.mirrorToken const manifest = await getManifestFromRepo('actions', 'node-versions', this.nodeInfo.mirror && this.nodeInfo.mirrorToken
? this.nodeInfo.mirrorToken ? this.nodeInfo.mirrorToken
: this.nodeInfo.auth, 'main'); : this.nodeInfo.auth, 'main');
if (Array.isArray(manifest) && manifest.length > 0) { if (isValidManifest(manifest)) {
return manifest; return manifest;
} }
lastError = new Error(`The manifest fetched is empty, truncated, or does not contain any valid tool release entries.`); lastError = new Error(invalidManifestMessage);
}
catch (error) {
lastError = error instanceof Error ? error : new Error(String(error));
const status = error?.statusCode;
if (status === 403 || status === 429) {
core_debug(`GitHub API returned HTTP ${status}; trying raw manifest.`);
break;
} }
catch (err) {
lastError = err instanceof Error ? err : new Error(String(err));
} }
core_debug(`Attempt ${attempt}/${maxAttempts} to fetch the manifest failed: ${lastError.message}`); core_debug(`Attempt ${attempt}/${maxAttempts} to fetch the manifest failed: ${lastError.message}`);
if (attempt < maxAttempts) { if (attempt < maxAttempts) {
core_info(`Retrying to fetch the manifest...`); core_info('Retrying to fetch the manifest...');
await new Promise(resolve => setTimeout(resolve, 1000 * 2 ** (attempt - 1))); // Retry after a delay await new Promise(resolve => setTimeout(resolve, 1000 * 2 ** (attempt - 1)));
} }
} }
throw new Error(`Failed to fetch a valid manifest after ${maxAttempts} attempts. Last error: ${lastError?.message}`); core_debug(`GitHub API manifest fetch failed: ${lastError?.message}`);
core_debug(`Getting manifest from ${nodeVersionsManifestUrl}`);
try {
const { result } = await this.httpClient.getJson(nodeVersionsManifestUrl);
if (!isValidManifest(result)) {
throw new Error(invalidManifestMessage);
}
return result;
}
catch (error) {
const message = error.message;
throw new Error(`Failed to fetch a valid manifest from the GitHub API and raw URL. API: ${lastError?.message}. Raw: ${message}`, { cause: error });
}
} }
resolveLtsAliasFromManifest(versionSpec, stable, manifest) { resolveLtsAliasFromManifest(versionSpec, stable, manifest) {
const alias = versionSpec.split('lts/')[1]?.toLowerCase(); const alias = versionSpec.split('lts/')[1]?.toLowerCase();
@@ -99155,16 +99194,6 @@ class OfficialBuilds extends BaseDistribution {
core_debug(`Found LTS release '${release.version}' for Node version '${versionSpec}'`); core_debug(`Found LTS release '${release.version}' for Node version '${versionSpec}'`);
return release.version.split('.')[0]; return release.version.split('.')[0];
} }
async resolveVersionFromManifest(versionSpec, stable, osArch, manifest) {
try {
const info = await this.getInfoFromManifest(versionSpec, stable, osArch, manifest);
return info?.resolvedVersion;
}
catch (err) {
core_info('Unable to resolve version from manifest...');
core_debug(err.message);
}
}
async getInfoFromManifest(versionSpec, stable, osArch, manifest) { async getInfoFromManifest(versionSpec, stable, osArch, manifest) {
let info = null; let info = null;
if (!manifest) { if (!manifest) {
@@ -99189,7 +99218,7 @@ class OfficialBuilds extends BaseDistribution {
} }
async verifyNodeVersion(installedDir) { async verifyNodeVersion(installedDir) {
// tool-cache layout: <root>/node/<version>/<arch> // tool-cache layout: <root>/node/<version>/<arch>
const expectedVersion = 'v' + external_path_default().basename(external_path_default().dirname(installedDir)); const expectedVersion = 'v' + external_node_path_default().basename(external_node_path_default().dirname(installedDir));
let actualVersion = ''; let actualVersion = '';
try { try {
const { stdout } = await getExecOutput('node', ['--version'], { const { stdout } = await getExecOutput('node', ['--version'], {
+4 -4
View File
@@ -4237,13 +4237,13 @@
"license": "ISC" "license": "ISC"
}, },
"node_modules/handlebars": { "node_modules/handlebars": {
"version": "4.7.9", "version": "4.7.10",
"resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.9.tgz", "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.10.tgz",
"integrity": "sha512-4E71E0rpOaQuJR2A3xDZ+GM1HyWYv1clR58tC8emQNeQe3RH7MAzSbat+V0wG78LQBo6m6bzSG/L4pBuCsgnUQ==", "integrity": "sha512-P5VJMVM7qgBn6vjXMw8WG9uVI+ncf2pi72j4de4yz5ZULLj2RGqLYaKOYGsgyrViQ0tePOVlN1tDCCXXtFqXKg==",
"dev": true, "dev": true,
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
"minimist": "^1.2.5", "minimist": "^1.2.8",
"neo-async": "^2.6.2", "neo-async": "^2.6.2",
"source-map": "^0.6.1", "source-map": "^0.6.1",
"wordwrap": "^1.0.0" "wordwrap": "^1.0.0"
@@ -1,7 +1,9 @@
import path from 'node:path';
import * as core from '@actions/core'; import * as core from '@actions/core';
import * as tc from '@actions/tool-cache';
import path from 'path';
import * as exec from '@actions/exec'; import * as exec from '@actions/exec';
import * as tc from '@actions/tool-cache';
import semver from 'semver';
import BaseDistribution from '../base-distribution.js'; import BaseDistribution from '../base-distribution.js';
import {NodeInputs, INodeVersion, INodeVersionInfo} from '../base-models.js'; import {NodeInputs, INodeVersion, INodeVersionInfo} from '../base-models.js';
@@ -10,6 +12,15 @@ interface INodeRelease extends tc.IToolRelease {
lts?: string; lts?: string;
} }
const nodeVersionsManifestUrl =
'https://raw.githubusercontent.com/actions/node-versions/main/versions-manifest.json';
const invalidManifestMessage =
'The manifest fetched is empty, truncated, or does not contain any valid tool release entries.';
function isValidManifest(manifest: unknown): manifest is tc.IToolRelease[] {
return Array.isArray(manifest) && manifest.length > 0;
}
export default class OfficialBuilds extends BaseDistribution { export default class OfficialBuilds extends BaseDistribution {
constructor(nodeInfo: NodeInputs) { constructor(nodeInfo: NodeInputs) {
super(nodeInfo); super(nodeInfo);
@@ -43,12 +54,20 @@ export default class OfficialBuilds extends BaseDistribution {
if (this.nodeInfo.checkLatest) { if (this.nodeInfo.checkLatest) {
core.info('Attempt to resolve the latest version from manifest...'); core.info('Attempt to resolve the latest version from manifest...');
const resolvedVersion = await this.resolveVersionFromManifest( let resolvedVersion: string | undefined;
try {
manifest ??= await this.getManifest();
const info = await this.getInfoFromManifest(
this.nodeInfo.versionSpec, this.nodeInfo.versionSpec,
this.nodeInfo.stable, this.nodeInfo.stable,
osArch, osArch,
manifest manifest
); );
resolvedVersion = info?.resolvedVersion;
} catch (error) {
core.info('Unable to resolve version from manifest...');
core.debug((error as Error).message);
}
if (resolvedVersion) { if (resolvedVersion) {
this.nodeInfo.versionSpec = resolvedVersion; this.nodeInfo.versionSpec = resolvedVersion;
core.info(`Resolved as '${resolvedVersion}'`); core.info(`Resolved as '${resolvedVersion}'`);
@@ -177,7 +196,18 @@ export default class OfficialBuilds extends BaseDistribution {
if (this.isLatestSyntax(this.nodeInfo.versionSpec)) { if (this.isLatestSyntax(this.nodeInfo.versionSpec)) {
core.info(`getting latest node version...`); core.info(`getting latest node version...`);
return versions[0];
const stableVersion = versions.find(
potential => semver.prerelease(potential) === null
);
if (!stableVersion) {
throw new Error(
`Unable to find a stable Node version for '${this.nodeInfo.versionSpec}' on platform ${this.osPlat} and architecture ${this.nodeInfo.arch}.`
);
}
return stableVersion;
} }
version = super.evaluateVersions(versions); version = super.evaluateVersions(versions);
@@ -193,7 +223,7 @@ export default class OfficialBuilds extends BaseDistribution {
private async getManifest(): Promise<tc.IToolRelease[]> { private async getManifest(): Promise<tc.IToolRelease[]> {
let lastError: Error | undefined; let lastError: Error | undefined;
const maxAttempts = 3; const maxAttempts = 3;
core.debug(`Getting manifest from actions/node-versions@main`); core.debug('Getting manifest from actions/node-versions@main');
for (let attempt = 1; attempt <= maxAttempts; attempt++) { for (let attempt = 1; attempt <= maxAttempts; attempt++) {
try { try {
const manifest = await tc.getManifestFromRepo( const manifest = await tc.getManifestFromRepo(
@@ -204,29 +234,49 @@ export default class OfficialBuilds extends BaseDistribution {
: this.nodeInfo.auth, : this.nodeInfo.auth,
'main' 'main'
); );
if (Array.isArray(manifest) && manifest.length > 0) { if (isValidManifest(manifest)) {
return manifest; return manifest;
} }
lastError = new Error( lastError = new Error(invalidManifestMessage);
`The manifest fetched is empty, truncated, or does not contain any valid tool release entries.` } catch (error) {
lastError = error instanceof Error ? error : new Error(String(error));
const status = (error as {statusCode?: number})?.statusCode;
if (status === 403 || status === 429) {
core.debug(
`GitHub API returned HTTP ${status}; trying raw manifest.`
); );
} catch (err) { break;
lastError = err instanceof Error ? err : new Error(String(err)); }
} }
core.debug( core.debug(
`Attempt ${attempt}/${maxAttempts} to fetch the manifest failed: ${lastError.message}` `Attempt ${attempt}/${maxAttempts} to fetch the manifest failed: ${lastError.message}`
); );
if (attempt < maxAttempts) { if (attempt < maxAttempts) {
core.info(`Retrying to fetch the manifest...`); core.info('Retrying to fetch the manifest...');
await new Promise(resolve => await new Promise(resolve =>
setTimeout(resolve, 1000 * 2 ** (attempt - 1)) setTimeout(resolve, 1000 * 2 ** (attempt - 1))
); // Retry after a delay
}
}
throw new Error(
`Failed to fetch a valid manifest after ${maxAttempts} attempts. Last error: ${lastError?.message}`
); );
} }
}
core.debug(`GitHub API manifest fetch failed: ${lastError?.message}`);
core.debug(`Getting manifest from ${nodeVersionsManifestUrl}`);
try {
const {result} = await this.httpClient.getJson<tc.IToolRelease[]>(
nodeVersionsManifestUrl
);
if (!isValidManifest(result)) {
throw new Error(invalidManifestMessage);
}
return result;
} catch (error) {
const message = (error as Error).message;
throw new Error(
`Failed to fetch a valid manifest from the GitHub API and raw URL. API: ${lastError?.message}. Raw: ${message}`,
{cause: error}
);
}
}
private resolveLtsAliasFromManifest( private resolveLtsAliasFromManifest(
versionSpec: string, versionSpec: string,
@@ -272,26 +322,6 @@ export default class OfficialBuilds extends BaseDistribution {
return release.version.split('.')[0]; return release.version.split('.')[0];
} }
private async resolveVersionFromManifest(
versionSpec: string,
stable: boolean,
osArch: string,
manifest: tc.IToolRelease[] | undefined
): Promise<string | undefined> {
try {
const info = await this.getInfoFromManifest(
versionSpec,
stable,
osArch,
manifest
);
return info?.resolvedVersion;
} catch (err) {
core.info('Unable to resolve version from manifest...');
core.debug((err as Error).message);
}
}
private async getInfoFromManifest( private async getInfoFromManifest(
versionSpec: string, versionSpec: string,
stable: boolean, stable: boolean,