Compare commits

..

3 Commits
v6.3.0 ... main

Author SHA1 Message Date
Bruno Borges
60d2c8e17e Compare JDK version reports across main, v6, and v5 (#1331)
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
2026-11-19 17:05:55 -08:00
Bruno Borges
3fc1c6e612 Add daily latest JDK versions report workflow (#1329)
* Add daily latest JDK versions report workflow

Add a scheduled workflow that resolves, without downloading, the exact
version each distribution currently provides for the LTS majors, the
newest feature release, and `latest` on Linux, macOS, and Windows for
x64 and aarch64. Resolution reuses each installer's metadata lookup, so
the report matches what setup-java installs on a tool-cache miss or with
`check-latest: true`. Results are combined into a job summary with a
per-platform breakdown and a section for distributions needing
attention. Link the report from the README.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

* Report every supported platform in latest JDK versions report

Resolve each distribution on every OS and architecture in the capability
map, including Alpine Linux, and render a full per-platform table for each
distribution instead of a merged overview. Platform differences are
expected and no longer flagged; only lookup errors and distributions that
resolve nothing are listed under "Needs attention".

Share HEAD responses per distribution so JetBrains lookups no longer
re-probe every release URL, cutting a Linux run from ~7 min to ~1 min.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

* Complete JDK report platform and major coverage

Resolve every major from Java 6 through the newest GA release, including non-LTS versions. Query Liberica Solaris metadata through its installer and include Solaris in the workflow matrix. Preserve exact per-platform versions without flagging normal differences.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
2026-11-18 15:44:10 -08:00
Bruno Borges
3c7a629527 Fix Oracle JDK 21 e2e and warn on archived GA fallback (#1327)
Oracle no longer serves JDK 21 under /java/21/latest/, so a major-only
request falls back to the archived 21 GA build and reports version 21.
The e2e check required a concrete version for floating Oracle requests,
so the oracle 21 jobs failed.

Move floating Oracle e2e coverage to JDK 25 and keep a single oracle 21
job that exercises the archive fallback without the concrete-version
requirement. Warn when a major-only request falls back from /latest/ to
the archived GA release, since that build may lack security updates.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
2026-11-14 00:10:04 -05:00
12 changed files with 2030 additions and 4 deletions

View File

@@ -80,10 +80,14 @@ jobs:
version: 25 version: 25
- distribution: oracle - distribution: oracle
os: macos-15-intel os: macos-15-intel
version: 21 version: 25
- distribution: oracle - distribution: oracle
os: windows-latest os: windows-latest
version: 21 version: 25
- distribution: oracle
os: ubuntu-latest
version: 25
# Oracle no longer publishes JDK 21 under /latest, so a major-only request resolves to the archived GA build.
- distribution: oracle - distribution: oracle
os: ubuntu-latest os: ubuntu-latest
version: 21 version: 21
@@ -127,7 +131,7 @@ jobs:
JAVA_VERSION: ${{ matrix.version }} JAVA_VERSION: ${{ matrix.version }}
JAVA_PATH: ${{ steps.setup-java.outputs.path }} JAVA_PATH: ${{ steps.setup-java.outputs.path }}
SETUP_JAVA_VERSION: ${{ steps.setup-java.outputs.version }} SETUP_JAVA_VERSION: ${{ steps.setup-java.outputs.version }}
REQUIRE_CONCRETE_VERSION: ${{ (matrix.distribution == 'oracle' || matrix.distribution == 'graalvm') && !contains(matrix.version, '.') && !contains(matrix.version, '-ea') }} REQUIRE_CONCRETE_VERSION: ${{ ((matrix.distribution == 'oracle' && matrix.version != 21) || matrix.distribution == 'graalvm') && !contains(matrix.version, '.') && !contains(matrix.version, '-ea') }}
run: bash __tests__/verify-java.sh "$JAVA_VERSION" "$JAVA_PATH" "$SETUP_JAVA_VERSION" "$REQUIRE_CONCRETE_VERSION" run: bash __tests__/verify-java.sh "$JAVA_VERSION" "$JAVA_PATH" "$SETUP_JAVA_VERSION" "$REQUIRE_CONCRETE_VERSION"
shell: bash shell: bash

View File

@@ -0,0 +1,225 @@
# Daily report of the exact JDK version each distribution currently resolves
# for every major from Java 6 through the newest GA release, and `latest`, on every operating
# system and architecture setup-java supports for it. Versions are resolved
# from vendor metadata only; no JDK is downloaded. Compare main and the latest
# v6/v5 tags using each revision's own installers and locked dependencies.
name: Latest JDK versions report
on:
schedule:
- cron: '30 6 * * *'
workflow_dispatch:
inputs:
java-versions:
description: 'Comma-separated java-version values (default: every major from Java 6 through the newest GA release, and latest)'
required: false
default: ''
pull_request:
paths:
- 'src/reports/**'
- 'scripts/build-report-resolver.mjs'
- '__tests__/latest-versions-report.test.ts'
- '.github/workflows/latest-jdk-versions.yml'
permissions:
contents: read
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
defaults:
run:
shell: bash
jobs:
build:
name: Build report tool
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v7
with:
persist-credentials: false
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: '24.x'
cache: npm
- name: Install dependencies
run: npm ci
- name: Bundle report tool
run: npm run build:latest-versions-report
- name: Upload report tool
uses: actions/upload-artifact@v7
with:
name: latest-versions-report-tool
path: lib/latest-versions-report/
retention-days: 1
build-resolvers:
name: Build resolver (${{ matrix.setup-java }})
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
setup-java: [main, v6, v5]
steps:
- name: Checkout report tooling
uses: actions/checkout@v7
with:
persist-credentials: false
- name: Checkout setup-java revision
uses: actions/checkout@v7
with:
repository: actions/setup-java
ref: ${{ matrix.setup-java }}
path: resolver-source
persist-credentials: false
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: '24.x'
cache: npm
cache-dependency-path: resolver-source/package-lock.json
- name: Install revision dependencies
working-directory: resolver-source
run: npm ci
- name: Bundle revision metadata resolver
run: node scripts/build-report-resolver.mjs resolver-source "$SETUP_JAVA_REF" resolver
env:
SETUP_JAVA_REF: ${{ matrix.setup-java }}
- name: Upload revision metadata resolver
uses: actions/upload-artifact@v7
with:
name: jdk-metadata-resolver-${{ matrix.setup-java }}
path: resolver/
retention-days: 1
resolve:
name: Resolve versions (${{ matrix.setup-java }}, ${{ matrix.platform }})
needs: [build, build-resolvers]
if: ${{ !cancelled() && needs.build.result == 'success' }}
runs-on: ${{ matrix.os }}
timeout-minutes: 30
strategy:
fail-fast: false
matrix:
setup-java: [main, v6, v5]
platform: [linux, macos, windows, solaris]
include:
- os: ubuntu-latest
platform: linux
- os: macos-latest
platform: macos
- os: windows-latest
platform: windows
# Liberica's Solaris metadata is queried without running a Solaris JDK.
- os: ubuntu-latest
platform: solaris
steps:
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: '24.x'
- name: Download report tool
uses: actions/download-artifact@v8
with:
name: latest-versions-report-tool
path: tool
- name: Download revision metadata resolver
uses: actions/download-artifact@v8
with:
name: jdk-metadata-resolver-${{ matrix.setup-java }}
path: resolver
- name: Resolve latest versions without downloading
run: node tool/index.js resolve "results/$SETUP_JAVA_REF-$REPORT_PLATFORM.json"
env:
GITHUB_TOKEN: ${{ github.token }}
REPORT_VERSIONS: ${{ inputs.java-versions }}
REPORT_PLATFORM: ${{ matrix.platform }}
REPORT_RESOLVER: resolver
SETUP_JAVA_REF: ${{ matrix.setup-java }}
- name: Upload resolved versions
uses: actions/upload-artifact@v7
with:
name: latest-jdk-versions-${{ matrix.setup-java }}-${{ matrix.platform }}
path: results/
retention-days: 1
# Installers pick musl builds on Alpine, which can resolve to other versions.
resolve-alpine:
name: Resolve versions (${{ matrix.setup-java }}, alpine)
needs: [build, build-resolvers]
if: ${{ !cancelled() && needs.build.result == 'success' }}
runs-on: ubuntu-latest
timeout-minutes: 30
container:
image: node:24-alpine
strategy:
fail-fast: false
matrix:
setup-java: [main, v6, v5]
defaults:
run:
shell: sh
steps:
- name: Download report tool
uses: actions/download-artifact@v8
with:
name: latest-versions-report-tool
path: tool
- name: Download revision metadata resolver
uses: actions/download-artifact@v8
with:
name: jdk-metadata-resolver-${{ matrix.setup-java }}
path: resolver
- name: Resolve latest versions without downloading
run: node tool/index.js resolve "results/$SETUP_JAVA_REF-alpine.json"
env:
GITHUB_TOKEN: ${{ github.token }}
REPORT_VERSIONS: ${{ inputs.java-versions }}
REPORT_RESOLVER: resolver
SETUP_JAVA_REF: ${{ matrix.setup-java }}
- name: Upload resolved versions
uses: actions/upload-artifact@v7
with:
name: latest-jdk-versions-${{ matrix.setup-java }}-alpine
path: results/
retention-days: 1
report:
name: Report
needs: [build, build-resolvers, resolve, resolve-alpine]
if: ${{ !cancelled() && needs.build.result == 'success' }}
runs-on: ubuntu-latest
steps:
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: '24.x'
- name: Download report tool
uses: actions/download-artifact@v8
with:
name: latest-versions-report-tool
path: tool
- name: Download resolved versions
uses: actions/download-artifact@v8
with:
pattern: latest-jdk-versions-*
path: results
merge-multiple: true
- name: Write report
if: ${{ !cancelled() }}
run: node tool/index.js summarize results latest-jdk-versions.md
env:
REPORT_REFS: main,v6,v5
- name: Upload report
if: ${{ !cancelled() }}
uses: actions/upload-artifact@v7
with:
name: latest-jdk-versions-report
path: |
latest-jdk-versions.md
results/
retention-days: 30

View File

@@ -3,6 +3,7 @@
[![Basic validation](https://github.com/actions/setup-java/actions/workflows/basic-validation.yml/badge.svg?branch=main)](https://github.com/actions/setup-java/actions/workflows/basic-validation.yml) [![Basic validation](https://github.com/actions/setup-java/actions/workflows/basic-validation.yml/badge.svg?branch=main)](https://github.com/actions/setup-java/actions/workflows/basic-validation.yml)
[![Validate Java e2e](https://github.com/actions/setup-java/actions/workflows/e2e-versions.yml/badge.svg?branch=main)](https://github.com/actions/setup-java/actions/workflows/e2e-versions.yml) [![Validate Java e2e](https://github.com/actions/setup-java/actions/workflows/e2e-versions.yml/badge.svg?branch=main)](https://github.com/actions/setup-java/actions/workflows/e2e-versions.yml)
[![Validate cache](https://github.com/actions/setup-java/actions/workflows/e2e-cache.yml/badge.svg?branch=main)](https://github.com/actions/setup-java/actions/workflows/e2e-cache.yml) [![Validate cache](https://github.com/actions/setup-java/actions/workflows/e2e-cache.yml/badge.svg?branch=main)](https://github.com/actions/setup-java/actions/workflows/e2e-cache.yml)
[![Latest JDK versions report](https://github.com/actions/setup-java/actions/workflows/latest-jdk-versions.yml/badge.svg?branch=main)](https://github.com/actions/setup-java/actions/workflows/latest-jdk-versions.yml)
Set up Java for GitHub Actions workflows. `setup-java` installs a requested Java distribution, adds it to `PATH`, configures `JAVA_HOME`, and can optionally cache build dependencies for Apache Maven, Gradle, and sbt; generate Maven publishing configuration, verify JDK package signatures, manage multiple JDKs, and manage Maven toolchains. Set up Java for GitHub Actions workflows. `setup-java` installs a requested Java distribution, adds it to `PATH`, configures `JAVA_HOME`, and can optionally cache build dependencies for Apache Maven, Gradle, and sbt; generate Maven publishing configuration, verify JDK package signatures, manage multiple JDKs, and manage Maven toolchains.
@@ -245,6 +246,10 @@ When `check-latest` is `false`, the action first tries the runner tool cache for
GitHub-hosted runners primarily pre-cache Eclipse Temurin JDKs. See the installed Java versions for [Ubuntu](https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2404-Readme.md#java), [Windows](https://github.com/actions/runner-images/blob/main/images/windows/Windows2025-Readme.md#java), and [macOS](https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md#java). On a fresh GitHub-hosted runner, requests for other distributions usually miss the tool cache and resolve from remote metadata. For broad version ranges such as a major version (`21`, `25`), this often behaves similarly to `check-latest: true` because the action downloads the latest available release that satisfies the range. GitHub-hosted runners primarily pre-cache Eclipse Temurin JDKs. See the installed Java versions for [Ubuntu](https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2404-Readme.md#java), [Windows](https://github.com/actions/runner-images/blob/main/images/windows/Windows2025-Readme.md#java), and [macOS](https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md#java). On a fresh GitHub-hosted runner, requests for other distributions usually miss the tool cache and resolve from remote metadata. For broad version ranges such as a major version (`21`, `25`), this often behaves similarly to `check-latest: true` because the action downloads the latest available release that satisfies the range.
To see which exact version a request resolves to today, open the summary of the latest run of the daily [Latest JDK versions report](https://github.com/actions/setup-java/actions/workflows/latest-jdk-versions.yml) workflow. It compares `setup-java@main`, the latest `setup-java@v6`, and the latest `setup-java@v5`, with separate sections and the exact commit checked for each. Each revision uses its own installers and locked dependencies to resolve vendor metadata for every major from Java 6 through the newest stable GA release (including non-LTS releases), plus `latest`, across its distributions, operating systems and architectures, including Alpine Linux and Solaris. Older revisions without capability maps probe all candidate architectures; unsupported combinations and version syntax (such as `latest` in v5) are marked `n/a`. Distribution support and resolved versions can differ between action revisions as well as platforms. Missing reports and lookup failures are shown explicitly. The report doesn't download any JDKs. Floating vendor URLs are marked when their exact version cannot be established from metadata alone. It shows what a job installs on a tool-cache miss or with `check-latest: true`.
The `latest-jdk-versions-report` artifact contains the full Markdown report and per-revision/platform JSON results. If the combined report exceeds GitHub's job-summary size limit, the summary shows an overview pointing to this artifact instead.
## Download integrity and signatures ## Download integrity and signatures
`setup-java` automatically verifies downloaded archive checksums when a selected distribution publishes an authoritative checksum. Automatic checksum verification currently applies to `temurin`, `semeru`, `corretto`, `dragonwell`, `kona`, `sapmachine`, `graalvm`, `graalvm-community`, `zulu`, `oracle`, `oracle-openjdk`, `microsoft`, and `jetbrains`. `setup-java` automatically verifies downloaded archive checksums when a selected distribution publishes an authoritative checksum. Automatic checksum verification currently applies to `temurin`, `semeru`, `corretto`, `dragonwell`, `kona`, `sapmachine`, `graalvm`, `graalvm-community`, `zulu`, `oracle`, `oracle-openjdk`, `microsoft`, and `jetbrains`.

View File

@@ -185,6 +185,19 @@ describe('findPackageForDownload', () => {
expect(spyHttpClientGet).toHaveBeenCalledTimes(1); expect(spyHttpClientGet).toHaveBeenCalledTimes(1);
}); });
it('warns when a major-only request falls back to the archived GA release', async () => {
spyHttpClient = jest.spyOn(HttpClient.prototype, 'head');
spyHttpClient
.mockResolvedValueOnce({message: {statusCode: 404}})
.mockResolvedValueOnce({message: {statusCode: 200}});
await distribution['findPackageForDownload']('21');
expect(core.warning).toHaveBeenCalledWith(
'Oracle JDK 21 is no longer available from the latest endpoint. Falling back to its archived GA release, which may not include security updates.'
);
});
it('always resolves major-only requests remotely', () => { it('always resolves major-only requests remotely', () => {
expect(distribution['requiresRemoteResolution']()).toBe(true); expect(distribution['requiresRemoteResolution']()).toBe(true);
const exactDistribution = new OracleDistribution({ const exactDistribution = new OracleDistribution({

View File

@@ -0,0 +1,658 @@
import {afterEach, describe, expect, it, jest} from '@jest/globals';
import {HttpClient, HttpClientResponse} from '@actions/http-client';
import fs from 'fs';
import os from 'os';
import path from 'path';
import {IncomingMessage} from 'http';
import {Socket} from 'net';
import {JavaBase} from '../src/distributions/base-installer.js';
import {
currentResolver,
loadMetadataResolver,
type MetadataResolver
} from '../src/reports/resolver.js';
import {
classifyResolutionError,
getDefaultVersions,
getSupportedArchitectures,
renderMarkdownReport,
ResolutionReport,
resolveLatestVersions,
VersionResolution
} from '../src/reports/latest-versions.js';
function result(
overrides: Partial<VersionResolution> &
Pick<VersionResolution, 'distribution' | 'versionSpec'>
): VersionResolution {
return {
platform: 'linux',
architecture: 'x64',
status: 'resolved',
...overrides
};
}
function report(
platform: string,
results: VersionResolution[]
): ResolutionReport {
return {
source: {ref: 'main'},
platform,
generatedAt: '2026-11-18T06:30:00.000Z',
results
};
}
function tableRows(markdown: string, distribution: string): string[] {
const section = markdown.split(`## \`${distribution}\``)[1].split('\n## ')[0];
return section.split('\n').filter(line => /^\| (?!Platform|---)/.test(line));
}
describe('latest versions report', () => {
afterEach(() => {
jest.restoreAllMocks();
jest.useRealTimers();
});
it('includes every major from Java 6 through GA, including non-LTS releases but not EA', async () => {
jest.spyOn(HttpClient.prototype, 'getJson').mockResolvedValue({
statusCode: 200,
headers: {},
result: {
most_recent_feature_release: 27,
most_recent_feature_version: 28,
most_recent_lts: 25
}
});
await expect(getDefaultVersions(new HttpClient())).resolves.toEqual([
'6',
'7',
'8',
'9',
'10',
'11',
'12',
'13',
'14',
'15',
'16',
'17',
'18',
'19',
'20',
'21',
'22',
'23',
'24',
'25',
'26',
'27',
'latest'
]);
});
it('fails rather than publishing incomplete defaults when discovery fails', async () => {
jest
.spyOn(HttpClient.prototype, 'getJson')
.mockRejectedValue(new Error('Java release metadata is unavailable'));
await expect(getDefaultVersions(new HttpClient())).rejects.toThrow(
'Java release metadata is unavailable'
);
});
it.each([5, 27.5, Infinity])(
'rejects invalid newest major %s',
async major => {
jest.spyOn(HttpClient.prototype, 'getJson').mockResolvedValue({
statusCode: 200,
headers: {},
result: {most_recent_feature_release: major}
});
await expect(getDefaultVersions(new HttpClient())).rejects.toThrow(
'Invalid newest Java feature release'
);
}
);
it('resolves Solaris metadata and combines its exact builds with every other platform', async () => {
const getJson = jest
.spyOn(HttpClient.prototype, 'getJson')
.mockResolvedValue({
statusCode: 200,
headers: {},
result: [
{
downloadUrl: 'https://example.com/solaris-jdk8-old.tar.gz',
version: '8.0.452+9',
featureVersion: 8,
interimVersion: 0,
updateVersion: 452,
buildVersion: 9
},
{
downloadUrl: 'https://example.com/solaris-jdk8.tar.gz',
version: '8.0.462+10',
featureVersion: 8,
interimVersion: 0,
updateVersion: 462,
buildVersion: 10
},
{
downloadUrl: 'https://example.com/solaris-jdk9.tar.gz',
version: '9.0.4+11',
featureVersion: 9,
interimVersion: 0,
updateVersion: 4,
buildVersion: 11
}
]
});
const install = jest
.spyOn(JavaBase.prototype, 'setupJava')
.mockRejectedValue(new Error('The report must not install a JDK'));
const network = jest
.spyOn(HttpClient.prototype, 'request')
.mockRejectedValue(
new Error('Only the mocked metadata request is permitted')
);
const hostPlatform = process.platform;
const solaris = await resolveLatestVersions({
distributions: ['liberica'],
versions: ['8', '9', '11', 'latest'],
platform: 'solaris'
});
expect(solaris.platform).toBe('solaris');
expect(solaris.results).toEqual([
result({
distribution: 'liberica',
platform: 'solaris',
versionSpec: '8',
version: '8.0.462+10'
}),
result({
distribution: 'liberica',
platform: 'solaris',
versionSpec: '9',
version: '9.0.4+11'
}),
expect.objectContaining({
platform: 'solaris',
versionSpec: '11',
status: 'unavailable'
}),
result({
distribution: 'liberica',
platform: 'solaris',
versionSpec: 'latest',
version: '9.0.4+11'
})
]);
expect(getJson).toHaveBeenCalledTimes(1);
const url = new URL(getJson.mock.calls[0][0]);
expect(url.origin).toBe('https://api.bell-sw.com');
expect(Object.fromEntries(url.searchParams)).toMatchObject({
os: 'solaris',
arch: 'x86',
bitness: '64',
'bundle-type': 'jdk',
'installation-type': 'archive'
});
expect(install).not.toHaveBeenCalled();
expect(network).not.toHaveBeenCalled();
expect(process.platform).toBe(hostPlatform);
const otherReports = ['linux', 'linux-musl', 'macos', 'windows'].map(
(platform, index) =>
report(
platform,
['8', '9', '11', 'latest'].map(versionSpec =>
result({
distribution: 'liberica',
platform,
versionSpec,
version: `${versionSpec === 'latest' ? '11' : versionSpec}.0.1+${index + 1}`
})
)
)
);
const markdown = renderMarkdownReport([solaris, ...otherReports]);
expect(tableRows(markdown, 'liberica')).toEqual([
'| Linux x64 | `8.0.1+1` | `9.0.1+1` | `11.0.1+1` | `11.0.1+1` |',
'| Alpine Linux x64 | `8.0.1+2` | `9.0.1+2` | `11.0.1+2` | `11.0.1+2` |',
'| macOS x64 | `8.0.1+3` | `9.0.1+3` | `11.0.1+3` | `11.0.1+3` |',
'| Windows x64 | `8.0.1+4` | `9.0.1+4` | `11.0.1+4` | `11.0.1+4` |',
'| Solaris x64 | `8.0.462+10` | `9.0.4+11` | — | `9.0.4+11` |'
]);
expect(markdown).not.toContain('Needs attention');
expect(markdown).not.toContain('Not checked');
});
it('classifies missing releases separately from lookup failures', () => {
const notFound = new Error("No matching version found for SemVer '8'.");
notFound.name = 'VersionNotFoundError';
expect(classifyResolutionError(notFound)).toBe('unavailable');
expect(
classifyResolutionError(
new Error('Oracle JDK is only supported for JDK 17 and later')
)
).toBe('unsupported');
expect(
classifyResolutionError(
new Error(
'No Kona release for the specified version "27" on OS "macos" and arch "aarch64".'
)
)
).toBe('unavailable');
expect(classifyResolutionError(new Error('socket hang up'))).toBe('error');
});
it('resolves Alpine with the Linux architectures, including version-restricted ones', () => {
expect(getSupportedArchitectures('redhat', 'linux-musl')).toEqual([
'x64',
'aarch64',
'ppc64le'
]);
expect(getSupportedArchitectures('dragonwell', 'macos')).toEqual([]);
});
it('lists the exact version for every platform, ordered by operating system and architecture', () => {
const markdown = renderMarkdownReport([
report('macos', [
result({
distribution: 'temurin',
versionSpec: '21',
platform: 'macos',
architecture: 'aarch64',
version: '21.0.13+100000002.0.LTS'
})
]),
report('linux', [
result({
distribution: 'temurin',
versionSpec: '21',
architecture: 's390x',
version: '21.0.12+7'
}),
result({
distribution: 'temurin',
versionSpec: '21',
version: '21.0.13+9'
})
]),
report('linux-musl', [
result({
distribution: 'temurin',
versionSpec: '21',
platform: 'linux-musl',
version: '21.0.13+9'
})
])
]);
expect(tableRows(markdown, 'temurin')).toEqual([
'| Linux x64 | `21.0.13+9` |',
'| Linux s390x | `21.0.12+7` |',
'| Alpine Linux x64 | `21.0.13+9` |',
'| macOS aarch64 | `21.0.13+100000002.0.LTS` |'
]);
expect(markdown).not.toContain('Needs attention');
expect(markdown).toContain(
'Not checked, because no runner reported these platforms: Windows (x64, x86, aarch64).'
);
});
it('distinguishes unsupported, unpublished, and floating releases', () => {
const markdown = renderMarkdownReport([
report('linux', [
result({
distribution: 'redhat',
versionSpec: '11',
architecture: 'aarch64',
version: '11.0.29'
}),
result({
distribution: 'redhat',
versionSpec: '25',
architecture: 'aarch64',
status: 'unsupported'
}),
result({
distribution: 'oracle',
versionSpec: '11',
status: 'unavailable'
}),
result({
distribution: 'oracle',
versionSpec: '25',
version: '25',
floating: true,
advertisedVersion: '25.0.5.1',
publishedAt: '2026-10-27'
})
])
]);
expect(tableRows(markdown, 'redhat')).toEqual([
'| Linux aarch64 | `11.0.29` | n/a |'
]);
expect(tableRows(markdown, 'oracle')).toEqual([
'| Linux x64 | — | `25.0.5.1` ¹ (published 2026-10-27) |'
]);
expect(markdown).toContain('¹ Major-only requests download');
});
it('reports lookup errors and distributions that resolved nothing', () => {
const markdown = renderMarkdownReport([
report('linux', [
result({
distribution: 'oracle-openjdk',
versionSpec: '25',
status: 'unavailable'
}),
result({
distribution: 'zulu',
versionSpec: '25',
status: 'error',
message: 'socket hang up\nstack'
})
])
]);
expect(markdown).toContain('## `oracle-openjdk` ❗');
expect(tableRows(markdown, 'zulu')).toEqual(['| Linux x64 | ❗ error |']);
expect(markdown).toContain(
'| `oracle-openjdk` | all | all | No release matched any requested version'
);
expect(markdown).toContain(
'| `zulu` | `25` | Linux x64 | socket hang up |'
);
});
it('uses the selected revision without substituting main for unsupported version syntax', async () => {
const mainFactory = jest.spyOn(currentResolver, 'getJavaDistribution');
const lookup = jest.fn(async () => ({
version: '21.0.8+9',
url: 'https://example.com/jdk.tar.gz'
}));
const legacy: MetadataResolver = {
source: {ref: 'v5', sha: 'a'.repeat(40), version: '5.6.0'},
distributions: ['adopt'],
getJavaDistribution: (_distribution, options) => {
if (options.version === 'latest') {
throw new Error("The string 'latest' is not valid SemVer notation");
}
return {
version: options.version,
http: new HttpClient(),
findPackageForDownload: lookup
};
},
createSolarisInstaller: () => {
throw new Error('Unexpected Solaris lookup');
}
};
const resolved = await resolveLatestVersions({
resolver: legacy,
distributions: legacy.distributions,
versions: ['21', 'latest'],
architectures: ['x64']
});
expect(resolved.source).toEqual(legacy.source);
expect(resolved.results).toEqual([
expect.objectContaining({
distribution: 'adopt',
versionSpec: '21',
version: '21.0.8+9'
}),
expect.objectContaining({
distribution: 'adopt',
versionSpec: 'latest',
status: 'unsupported'
})
]);
expect(lookup).toHaveBeenCalledTimes(1);
expect(lookup).toHaveBeenCalledWith('21');
expect(mainFactory).not.toHaveBeenCalled();
expect(getSupportedArchitectures('adopt', 'linux', legacy)).toContain(
's390x'
);
expect(getSupportedArchitectures('redhat', 'linux', legacy)).toEqual([]);
});
it('marks legacy mutable Oracle URLs as floating instead of reporting a major as exact', async () => {
const response = new IncomingMessage(new Socket());
response.headers['last-modified'] = 'Tue, 27 Oct 2026 00:00:00 GMT';
jest
.spyOn(HttpClient.prototype, 'head')
.mockResolvedValue(new HttpClientResponse(response));
jest.spyOn(HttpClient.prototype, 'getJson').mockResolvedValue({
statusCode: 200,
headers: {},
result: {releaseVersion: '25.0.1', licenseDetails: {licenseType: 'NFTC'}}
});
const resolved = await resolveLatestVersions({
resolver: {
...currentResolver,
source: {ref: 'v5'},
getJavaDistribution: () => ({
version: '25',
http: new HttpClient(),
findPackageForDownload: async () => ({
version: '25',
url: 'https://download.oracle.com/java/25/latest/jdk-25_linux-x64_bin.tar.gz'
})
})
},
distributions: ['oracle'],
versions: ['25'],
architectures: ['x64']
});
expect(resolved.results[0]).toMatchObject({
status: 'resolved',
floating: true,
advertisedVersion: '25.0.1',
publishedAt: '2026-10-27'
});
});
it('refuses to install if a revision crosses the metadata boundary', async () => {
const download = jest.fn();
const installer = {
version: '21',
http: new HttpClient(),
downloadTool: download,
async findPackageForDownload() {
this.downloadTool();
return {version: '21', url: 'https://example.com/jdk.tar.gz'};
}
};
const resolved = await resolveLatestVersions({
resolver: {...currentResolver, getJavaDistribution: () => installer},
distributions: ['temurin'],
versions: ['21'],
architectures: ['x64']
});
expect(resolved.results[0]).toMatchObject({
status: 'error',
message: 'JDK download/install is forbidden in the versions report.'
});
expect(download).not.toHaveBeenCalled();
});
it('records stalled legacy endpoints as errors and does not retry them for every major', async () => {
jest.useFakeTimers();
const request = jest
.spyOn(HttpClient.prototype, 'getJson')
.mockImplementation(() => new Promise(() => {}));
const dispose = jest.spyOn(HttpClient.prototype, 'dispose');
const pending = resolveLatestVersions({
resolver: {
...currentResolver,
getJavaDistribution: (_distribution, options) => ({
version: options.version,
http: new HttpClient(),
async findPackageForDownload() {
await this.http.getJson('https://example.com/retired-api');
throw new Error('Unreachable');
}
})
},
distributions: ['temurin'],
versions: ['17', '21'],
architectures: ['x64']
});
await jest.advanceTimersByTimeAsync(60_000);
const resolved = await pending;
expect(resolved.results).toEqual([
expect.objectContaining({
versionSpec: '17',
status: 'error',
message: expect.stringContaining('Metadata request timed out')
}),
expect.objectContaining({
versionSpec: '21',
status: 'error',
message: expect.stringContaining('Metadata request timed out')
})
]);
expect(request).toHaveBeenCalledTimes(1);
expect(dispose).toHaveBeenCalledTimes(1);
});
it('keeps different revision results and failures separate, including missing runners', () => {
const main = report('linux', [
result({distribution: 'temurin', versionSpec: '21', version: '21.0.13+9'})
]);
const v6 = {
...report('linux', [
result({
distribution: 'temurin',
versionSpec: '21',
version: '21.0.12+7'
})
]),
source: {ref: 'v6', sha: 'b'.repeat(40), version: '6.0.0'}
};
const v5 = {
...report('linux', [
result({
distribution: 'adopt',
versionSpec: '21',
status: 'unavailable'
}),
result({
distribution: 'temurin',
versionSpec: '21',
status: 'error',
message: 'metadata failed'
})
]),
source: {ref: 'v5', sha: 'a'.repeat(40), version: '5.6.0'},
targets: {adopt: {linux: ['x64'], windows: ['x64']}}
};
const markdown = renderMarkdownReport([main, v6, v5]);
const mainSection = markdown
.split('<summary>setup-java@main</summary>')[1]
.split('</details>')[0];
const v6Section = markdown
.split('<summary>setup-java@v6</summary>')[1]
.split('</details>')[0];
const v5Section = markdown
.split('<summary>setup-java@v5</summary>')[1]
.split('</details>')[0];
expect(mainSection).toContain('`21.0.13+9`');
expect(mainSection).not.toContain('Needs attention');
expect(v6Section).toContain('`21.0.12+7`');
expect(v6Section).not.toContain('`21.0.13+9`');
expect(v5Section).toContain('metadata failed');
expect(v5Section).toContain('## `adopt` ❗');
expect(v5Section).toContain(
'Not checked, because no runner reported these platforms: Windows (x64).'
);
expect(markdown).toContain(
`https://github.com/actions/setup-java/commit/${'a'.repeat(40)}`
);
});
it('shows missing revisions and rejects mixed commits within one revision', () => {
const main = report('linux', []);
expect(
renderMarkdownReport([main], {expectedRefs: ['main', 'v6', 'v5']})
).toContain('| `v5` | - | - | Not checked: no reports received |');
expect(() =>
renderMarkdownReport([
{...main, source: {ref: 'v6', sha: 'a'.repeat(40)}},
{...main, source: {ref: 'v6', sha: 'b'.repeat(40)}}
])
).toThrow("Reports for 'v6' were produced from different revisions.");
});
it.each(['module', 'commonjs'])(
'loads a separate %s resolver with its provenance',
async type => {
const directory = fs.mkdtempSync(
path.join(os.tmpdir(), 'setup-java resolver-')
);
try {
fs.writeFileSync(
path.join(directory, 'package.json'),
JSON.stringify({type})
);
const source = {ref: 'v5', sha: 'a'.repeat(40), version: '5.6.0'};
fs.writeFileSync(
path.join(directory, 'index.js'),
`
const source = ${JSON.stringify(source)};
const distributions = ['adopt'];
const getJavaDistribution = () => 'selected checkout';
const createSolarisInstaller = () => null;
${type === 'module' ? 'export' : 'module.exports ='}
{source, distributions, getJavaDistribution, createSolarisInstaller};
`
);
const loaded = await loadMetadataResolver(directory);
expect(loaded.source).toEqual(source);
expect(
loaded.getJavaDistribution('adopt', {
version: '21',
architecture: 'x64',
packageType: 'jdk',
checkLatest: true
})
).toBe('selected checkout');
} finally {
fs.rmSync(directory, {recursive: true, force: true});
}
}
);
it('fails explicitly instead of falling back to main when the resolver bundle is invalid', async () => {
const directory = fs.mkdtempSync(
path.join(os.tmpdir(), 'setup-java resolver-')
);
try {
fs.writeFileSync(
path.join(directory, 'package.json'),
'{"type":"module"}'
);
fs.writeFileSync(
path.join(directory, 'index.js'),
'export const source = {ref: "v5"};'
);
await expect(loadMetadataResolver(directory)).rejects.toThrow(
'Invalid metadata resolver bundle'
);
} finally {
fs.rmSync(directory, {recursive: true, force: true});
}
});
});

View File

@@ -82,6 +82,7 @@ class OracleDistribution extends _base_installer_js__WEBPACK_IMPORTED_MODULE_3__
possibleUrls.push(`${ORACLE_DL_BASE}/${major}/latest/jdk-${major}_${platform}-${arch}_bin.${extension}`); possibleUrls.push(`${ORACLE_DL_BASE}/${major}/latest/jdk-${major}_${platform}-${arch}_bin.${extension}`);
} }
const floatingUrl = isOnlyMajorProvided ? possibleUrls[0] : undefined; const floatingUrl = isOnlyMajorProvided ? possibleUrls[0] : undefined;
let latestUrlNotFound = false;
possibleUrls.push(`${ORACLE_DL_BASE}/${major}/archive/jdk-${range}_${platform}-${arch}_bin.${extension}`); possibleUrls.push(`${ORACLE_DL_BASE}/${major}/archive/jdk-${range}_${platform}-${arch}_bin.${extension}`);
if (parseInt(major) < 17) { if (parseInt(major) < 17) {
throw new Error('Oracle JDK is only supported for JDK 17 and later'); throw new Error('Oracle JDK is only supported for JDK 17 and later');
@@ -90,6 +91,9 @@ class OracleDistribution extends _base_installer_js__WEBPACK_IMPORTED_MODULE_3__
const response = await this.http.head(url); const response = await this.http.head(url);
if (response.message.statusCode === _actions_http_client__WEBPACK_IMPORTED_MODULE_5__/* .HttpCodes */ .Hv.OK) { if (response.message.statusCode === _actions_http_client__WEBPACK_IMPORTED_MODULE_5__/* .HttpCodes */ .Hv.OK) {
const floating = url === floatingUrl; const floating = url === floatingUrl;
if (latestUrlNotFound) {
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .warning */ .$e(`Oracle JDK ${major} is no longer available from the latest endpoint. Falling back to its archived GA release, which may not include security updates.`);
}
return { return {
url, url,
version: range, version: range,
@@ -100,6 +104,9 @@ class OracleDistribution extends _base_installer_js__WEBPACK_IMPORTED_MODULE_3__
: undefined : undefined
}; };
} }
if (url === floatingUrl) {
latestUrlNotFound = true;
}
if (response.message.statusCode !== _actions_http_client__WEBPACK_IMPORTED_MODULE_5__/* .HttpCodes */ .Hv.NotFound) { if (response.message.statusCode !== _actions_http_client__WEBPACK_IMPORTED_MODULE_5__/* .HttpCodes */ .Hv.NotFound) {
throw new Error(`Http request for Oracle JDK failed with status code: ${response.message.statusCode}`); throw new Error(`Http request for Oracle JDK failed with status code: ${response.message.statusCode}`);
} }

View File

@@ -14,6 +14,7 @@
"format-check": "prettier --no-error-on-unmatched-pattern --check \"**/*.{ts,yml,yaml}\"", "format-check": "prettier --no-error-on-unmatched-pattern --check \"**/*.{ts,yml,yaml}\"",
"lint": "eslint \"**/*.ts\"", "lint": "eslint \"**/*.ts\"",
"lint:fix": "eslint \"**/*.ts\" --fix", "lint:fix": "eslint \"**/*.ts\" --fix",
"build:latest-versions-report": "ncc build -o lib/latest-versions-report src/reports/latest-versions.ts",
"check": "npm run format-check && npm run lint && npm run build && npm test", "check": "npm run format-check && npm run lint && npm run build && npm test",
"fix": "npm run format && npm run lint:fix && npm run build", "fix": "npm run format && npm run lint:fix && npm run build",
"prepare": "husky install", "prepare": "husky install",

View File

@@ -0,0 +1,96 @@
import fs from 'node:fs';
import path from 'node:path';
import {execFileSync} from 'node:child_process';
import {createRequire} from 'node:module';
const [checkout, ref, destination] = process.argv.slice(2);
if (!checkout || !ref || !destination) {
throw new Error(
'Usage: node scripts/build-report-resolver.mjs <checkout> <ref> <output-dir>'
);
}
const root = path.resolve(checkout);
const output = path.resolve(destination);
const ts = createRequire(path.join(root, 'package.json'))('typescript');
const packageJson = JSON.parse(
fs.readFileSync(path.join(root, 'package.json'), 'utf8')
);
const source = {
ref,
sha: execFileSync('git', ['rev-parse', 'HEAD'], {
cwd: root,
encoding: 'utf8'
}).trim(),
version: packageJson.version
};
const capabilityFile = path.join(root, 'src/distributions/platform-types.ts');
const packageFile = path.join(root, 'src/distributions/package-types.ts');
const enumFile = fs.existsSync(packageFile)
? packageFile
: path.join(root, 'src/distributions/distribution-factory.ts');
const syntax = ts.createSourceFile(
enumFile,
fs.readFileSync(enumFile, 'utf8'),
ts.ScriptTarget.Latest,
true
);
const declaration = syntax.statements.find(
statement =>
ts.isEnumDeclaration(statement) &&
statement.name.text === 'JavaDistribution'
);
if (!declaration) {
throw new Error(`Cannot find the distribution enum in ${enumFile}`);
}
const distributions = declaration.members
.map(member => {
if (!member.initializer || !ts.isStringLiteral(member.initializer)) {
throw new Error(`Expected a string-valued distribution in ${enumFile}`);
}
return member.initializer.text;
})
.filter(value => value !== 'jdkfile');
// Keep source and dependencies from the selected checkout. Only this small
// reporting entrypoint is injected; no installer or version matcher is replaced.
const entrypoint = path.join(root, 'report-resolver-entry.js');
fs.writeFileSync(
entrypoint,
`
export {getJavaDistribution} from './src/distributions/distribution-factory.ts';
import {LibericaDistributions} from './src/distributions/liberica/installer.ts';
${fs.existsSync(capabilityFile) ? "export {JAVA_PLATFORM_CAPABILITIES as capabilities} from './src/distributions/platform-types.ts';" : ''}
export const source = ${JSON.stringify(source)};
export const distributions = ${JSON.stringify(distributions)};
export function createSolarisInstaller(options) {
const installer = new LibericaDistributions(options);
const getPlatformOption = installer.getPlatformOption.bind(installer);
installer.getPlatformOption = () => getPlatformOption('sunos');
return installer;
}
`,
{flag: 'wx'}
);
try {
execFileSync(
process.execPath,
[
path.join(root, 'node_modules/@vercel/ncc/dist/ncc/cli.js'),
'build',
entrypoint,
'-o',
output
],
{cwd: root, stdio: 'inherit'}
);
// v5 is CommonJS even when the artifact is loaded from an ESM workspace.
fs.writeFileSync(
path.join(output, 'package.json'),
JSON.stringify({
type: packageJson.type ?? 'commonjs'
})
);
} finally {
fs.rmSync(entrypoint, {force: true});
}

View File

@@ -203,7 +203,7 @@ export class LibericaDistributions extends JavaBase {
} }
} }
private getPlatformOption( protected getPlatformOption(
platform: NodeJS.Platform = process.platform platform: NodeJS.Platform = process.platform
): OsVersions { ): OsVersions {
switch (platform) { switch (platform) {

View File

@@ -109,6 +109,7 @@ export class OracleDistribution extends JavaBase {
); );
} }
const floatingUrl = isOnlyMajorProvided ? possibleUrls[0] : undefined; const floatingUrl = isOnlyMajorProvided ? possibleUrls[0] : undefined;
let latestUrlNotFound = false;
possibleUrls.push( possibleUrls.push(
`${ORACLE_DL_BASE}/${major}/archive/jdk-${range}_${platform}-${arch}_bin.${extension}` `${ORACLE_DL_BASE}/${major}/archive/jdk-${range}_${platform}-${arch}_bin.${extension}`
@@ -123,6 +124,11 @@ export class OracleDistribution extends JavaBase {
if (response.message.statusCode === HttpCodes.OK) { if (response.message.statusCode === HttpCodes.OK) {
const floating = url === floatingUrl; const floating = url === floatingUrl;
if (latestUrlNotFound) {
core.warning(
`Oracle JDK ${major} is no longer available from the latest endpoint. Falling back to its archived GA release, which may not include security updates.`
);
}
return { return {
url, url,
version: range, version: range,
@@ -134,6 +140,10 @@ export class OracleDistribution extends JavaBase {
}; };
} }
if (url === floatingUrl) {
latestUrlNotFound = true;
}
if (response.message.statusCode !== HttpCodes.NotFound) { if (response.message.statusCode !== HttpCodes.NotFound) {
throw new Error( throw new Error(
`Http request for Oracle JDK failed with status code: ${response.message.statusCode}` `Http request for Oracle JDK failed with status code: ${response.message.statusCode}`

View File

@@ -0,0 +1,882 @@
import * as core from '@actions/core';
import * as httpm from '@actions/http-client';
import fs from 'fs';
import path from 'path';
import type {JavaDownloadRelease} from '../distributions/base-models.js';
import {JavaDistribution} from '../distributions/package-types.js';
import {
isAlpineLinux,
normalizePlatform
} from '../distributions/platform-types.js';
import {isMainModule} from '../is-main-module.js';
import {RetryingHttpClient} from '../retrying-http-client.js';
import {getLatestMajorVersion} from '../util.js';
import {
type ActionSource,
type MetadataResolver,
currentResolver,
getResolverArchitectures,
loadMetadataResolver
} from './resolver.js';
/**
* Reports the exact JDK version each distribution currently resolves for a set
* of version specs, using the installers' own metadata resolution. Nothing is
* downloaded: resolution stops where `setup-java` would start the download.
*/
// Zulu's supported JDK catalog starts at Java 6, including non-LTS releases.
const FIRST_MAJOR_VERSION = 6;
export const REPORTED_DISTRIBUTIONS = currentResolver.distributions;
const PACKAGE_TYPE = 'jdk';
const CONCURRENCY = 6;
const METADATA_TIMEOUT_MS = 60_000;
const ORACLE_RELEASES_URL = 'https://java.oraclecloud.com/currentJavaReleases';
const MUSL_PLATFORM = 'linux-musl';
const PLATFORM_LABELS: Record<string, string> = {
linux: 'Linux',
[MUSL_PLATFORM]: 'Alpine Linux',
macos: 'macOS',
windows: 'Windows',
solaris: 'Solaris'
};
const PLATFORM_ORDER = Object.keys(PLATFORM_LABELS);
const ARCHITECTURE_ORDER = [
'x64',
'aarch64',
'x86',
'armv7',
'ppc64le',
'ppc64',
'riscv64',
's390x'
];
/**
* - `unsupported`: excluded by the action's package/platform capability maps.
* - `unavailable`: the vendor's metadata has no matching release.
* - `error`: the metadata lookup failed.
*/
export type ResolutionStatus =
'resolved' | 'unsupported' | 'unavailable' | 'error';
export interface VersionResolution {
distribution: string;
versionSpec: string;
platform: string;
architecture: string;
status: ResolutionStatus;
version?: string;
/** The release URL serves whatever build the vendor last published. */
floating?: boolean;
/** `Last-Modified` date of a floating artifact, from a HEAD request. */
publishedAt?: string;
/** Version the vendor currently advertises for a floating artifact. */
advertisedVersion?: string;
message?: string;
}
export interface ResolutionReport {
source: ActionSource;
platform: string;
generatedAt: string;
/** Expected platform/architecture probes, from this revision rather than main. */
targets?: Record<string, Record<string, string[]>>;
results: VersionResolution[];
}
interface ReleaseResolver {
version: string;
http: httpm.HttpClient;
findPackageForDownload(range: string): Promise<JavaDownloadRelease>;
}
/** Alpine is reported separately because installers pick musl builds there. */
export function getReportPlatform(
platform: NodeJS.Platform = process.platform,
alpine = isAlpineLinux(platform)
): string {
if (alpine) {
return MUSL_PLATFORM;
}
return normalizePlatform(platform) ?? platform;
}
/**
* Architectures `setup-java` supports for a distribution on a report
* platform, including ones restricted to some Java versions.
*/
export function getSupportedArchitectures(
distribution: string,
platform: string,
resolver: MetadataResolver = currentResolver
): string[] {
return getResolverArchitectures(resolver, distribution, platform);
}
export function classifyResolutionError(error: unknown): ResolutionStatus {
const message = error instanceof Error ? error.message : String(error);
if (
/not supported|only supported|does not support|unsupported|not valid SemVer/i.test(
message
)
) {
return 'unsupported';
}
if (
(error instanceof Error && error.name === 'VersionNotFoundError') ||
/no matching version|no \w+ release for|could not determine the latest available|not supported|only supported|does not support|not available|could not find|unsupported/i.test(
message
)
) {
return 'unavailable';
}
return 'error';
}
/**
* Shares metadata responses between installer instances. Most installers
* fetch a vendor's whole release list for every request, and JetBrains probes
* each release URL with HEAD, so resolving many version/architecture
* combinations would otherwise repeat identical requests and exhaust API rate
* limits. Failed requests are also retained for this snapshot so an obsolete
* endpoint does not stall every major-version probe. Installers only read the
* status and headers of HEAD responses.
*/
function shareMetadataResponses(
http: httpm.HttpClient,
cache: Map<string, Promise<unknown>>
): void {
const share = <T>(key: string, request: () => Promise<T>): Promise<T> => {
let response = cache.get(key) as Promise<T> | undefined;
if (!response) {
response = new Promise<T>((resolve, reject) => {
const timer = setTimeout(() => {
http.dispose();
reject(
new Error(
`Metadata request timed out after ${METADATA_TIMEOUT_MS} ms: ${key.split('\n')[0]}`
)
);
}, METADATA_TIMEOUT_MS);
Promise.resolve()
.then(request)
.then(
value => {
clearTimeout(timer);
resolve(value);
},
error => {
clearTimeout(timer);
reject(error);
}
);
});
cache.set(key, response);
}
return response;
};
const getJson = http.getJson.bind(http);
http.getJson = (async (requestUrl: string, additionalHeaders?: object) =>
structuredClone(
await share(
`GET ${requestUrl}\n${JSON.stringify(additionalHeaders ?? {})}`,
() => getJson(requestUrl, additionalHeaders as never)
)
)) as typeof http.getJson;
const head = http.head.bind(http);
http.head = (requestUrl, additionalHeaders) =>
share(
`HEAD ${requestUrl}\n${JSON.stringify(additionalHeaders ?? {})}`,
() => head(requestUrl, additionalHeaders)
);
}
async function describeFloatingRelease(
http: httpm.HttpClient,
distribution: string,
release: JavaDownloadRelease
): Promise<Pick<VersionResolution, 'publishedAt' | 'advertisedVersion'>> {
const details: Pick<VersionResolution, 'publishedAt' | 'advertisedVersion'> =
{};
try {
const response = await http.head(release.url);
const lastModified = response.message.headers['last-modified'];
if (lastModified && !Number.isNaN(Date.parse(lastModified))) {
details.publishedAt = new Date(lastModified).toISOString().slice(0, 10);
}
} catch (error) {
core.debug(`HEAD ${release.url} failed: ${error}`);
}
// Oracle's `/latest/` artifacts carry the NFTC license; only then is the
// release advertised by the Java Releases API the one being served.
if (distribution === JavaDistribution.Oracle) {
try {
const response = await http.getJson<{
releaseVersion?: string;
licenseDetails?: {licenseType?: string};
}>(`${ORACLE_RELEASES_URL}/${release.version.split('.')[0]}`);
if (
response.result?.releaseVersion &&
response.result.licenseDetails?.licenseType === 'NFTC'
) {
details.advertisedVersion = response.result.releaseVersion;
}
} catch (error) {
core.debug(`Oracle Java Releases API lookup failed: ${error}`);
}
}
return details;
}
async function resolveOne(
distributionName: string,
versionSpec: string,
platform: string,
architecture: string,
cache: Map<string, Promise<unknown>>,
http: httpm.HttpClient,
metadataResolver: MetadataResolver
): Promise<VersionResolution> {
const base = {
distribution: distributionName,
versionSpec,
platform,
architecture
};
let installer: unknown;
try {
const installerOptions = {
version: versionSpec,
architecture,
packageType: PACKAGE_TYPE,
checkLatest: true
};
if (platform === 'solaris') {
if (distributionName !== JavaDistribution.Liberica) {
return {
...base,
status: 'error',
message: `No Solaris metadata resolver for '${distributionName}'.`
};
}
installer =
await metadataResolver.createSolarisInstaller(installerOptions);
} else {
installer = await metadataResolver.getJavaDistribution(
distributionName,
installerOptions
);
}
} catch (error) {
return {
...base,
status: classifyResolutionError(error),
message: error instanceof Error ? error.message : String(error)
};
}
if (!installer) {
return {...base, status: 'error', message: 'Unknown distribution'};
}
// `findPackageForDownload` is the metadata step `setupJava` runs right
// before downloading; it is protected because the action never needs it on
// its own.
if (!isReleaseResolver(installer)) {
throw new Error(`Invalid metadata resolver for '${distributionName}'.`);
}
const resolver = installer;
// Fail closed if a resolver ever crosses the metadata/download boundary.
const forbidInstall = () => {
throw new Error(
'JDK download/install is forbidden in the versions report.'
);
};
Object.defineProperties(installer, {
setupJava: {value: forbidInstall},
downloadTool: {value: forbidInstall}
});
shareMetadataResponses(resolver.http, cache);
try {
const release = await resolver.findPackageForDownload(resolver.version);
// Older releases returned the requested major without a floating marker.
const floating =
release.floating || new URL(release.url).pathname.includes('/latest/');
return {
...base,
status: 'resolved',
version: release.version,
...(floating
? {
floating: true,
...(await describeFloatingRelease(http, distributionName, release))
}
: {})
};
} catch (error) {
return {
...base,
status: classifyResolutionError(error),
message: error instanceof Error ? error.message : String(error)
};
}
}
function isReleaseResolver(value: unknown): value is ReleaseResolver {
return (
typeof value === 'object' &&
value !== null &&
'version' in value &&
typeof value.version === 'string' &&
'http' in value &&
typeof value.http === 'object' &&
value.http !== null &&
'getJson' in value.http &&
typeof value.http.getJson === 'function' &&
'head' in value.http &&
typeof value.http.head === 'function' &&
'findPackageForDownload' in value &&
typeof value.findPackageForDownload === 'function'
);
}
async function runWithConcurrency<T>(
tasks: (() => Promise<T>)[],
limit: number
): Promise<T[]> {
const results: T[] = new Array(tasks.length);
let next = 0;
const worker = async () => {
while (next < tasks.length) {
const index = next++;
results[index] = await tasks[index]();
}
};
await Promise.all(
Array.from({length: Math.min(limit, tasks.length)}, worker)
);
return results;
}
/** Every supported stable major through the newest GA release, plus `latest`. */
export async function getDefaultVersions(
http: httpm.HttpClient
): Promise<string[]> {
shareMetadataResponses(http, new Map());
const latestMajor = await getLatestMajorVersion(http);
if (!Number.isSafeInteger(latestMajor) || latestMajor < FIRST_MAJOR_VERSION) {
throw new Error(
`Invalid newest Java feature release in vendor metadata: ${latestMajor}`
);
}
const versions = Array.from(
{length: latestMajor - FIRST_MAJOR_VERSION + 1},
(_, index) => String(FIRST_MAJOR_VERSION + index)
);
return [...versions, 'latest'];
}
/**
* Distributions for which vendor metadata matched nothing at all. Missing
* every requested version on every platform signals an unreachable or changed
* metadata source rather than genuinely unavailable releases.
*/
export function findSilentDistributions(
results: VersionResolution[]
): string[] {
const distributions = [...new Set(results.map(r => r.distribution))];
return distributions.filter(distribution => {
const distributionResults = results.filter(
r => r.distribution === distribution
);
return (
!distributionResults.some(r => r.status === 'resolved') &&
distributionResults.some(r => r.status === 'unavailable')
);
});
}
export async function resolveLatestVersions(options: {
distributions: string[];
versions: string[];
/** Restricts the architectures; defaults to all supported ones. */
architectures?: string[];
/** Solaris metadata can be resolved on any host; other targets use the host. */
platform?: string;
resolver?: MetadataResolver;
}): Promise<ResolutionReport> {
const resolver = options.resolver ?? currentResolver;
const http = new RetryingHttpClient('actions/setup-java');
shareMetadataResponses(http, new Map());
const hostPlatform = getReportPlatform();
const platform = options.platform || hostPlatform;
if (platform !== hostPlatform && platform !== 'solaris') {
throw new Error(
`Cannot resolve '${platform}' metadata on '${hostPlatform}'; use a matching runner.`
);
}
const tasks = options.distributions.map(distribution => async () => {
const architectures = getSupportedArchitectures(
distribution,
platform,
resolver
).filter(
architecture =>
!options.architectures?.length ||
options.architectures.includes(architecture)
);
// Each distribution resolves sequentially so its shared metadata is
// fetched once and requests to a single vendor API are not bursty.
const cache = new Map<string, Promise<unknown>>();
const results: VersionResolution[] = [];
const startedAt = Date.now();
for (const versionSpec of options.versions) {
for (const architecture of architectures) {
const result = await resolveOne(
distribution,
versionSpec,
platform,
architecture,
cache,
http,
resolver
);
core.info(
`${distribution} ${versionSpec} (${formatPlatform(result)}): ${
result.status === 'resolved'
? `${result.version}${result.floating ? ' (floating)' : ''}`
: `${result.status} - ${result.message?.split('\n')[0]}`
}`
);
results.push(result);
}
}
core.info(
`${distribution}: ${results.length} lookups in ${Math.round((Date.now() - startedAt) / 1000)}s`
);
return results;
});
const results = (await runWithConcurrency(tasks, CONCURRENCY)).flat();
return {
source: resolver.source,
platform,
generatedAt: new Date().toISOString(),
targets: Object.fromEntries(
options.distributions.map(distribution => [
distribution,
Object.fromEntries(
PLATFORM_ORDER.map(target => [
target,
getSupportedArchitectures(distribution, target, resolver)
]).filter(([, architectures]) => architectures.length > 0)
)
])
),
results
};
}
function formatPlatform(
result: Pick<VersionResolution, 'platform' | 'architecture'>
): string {
return `${PLATFORM_LABELS[result.platform] ?? result.platform} ${result.architecture}`;
}
function comparePlatforms(
a: Pick<VersionResolution, 'platform' | 'architecture'>,
b: Pick<VersionResolution, 'platform' | 'architecture'>
): number {
const rank = (order: string[], value: string) => {
const index = order.indexOf(value);
return index === -1 ? order.length : index;
};
return (
rank(PLATFORM_ORDER, a.platform) - rank(PLATFORM_ORDER, b.platform) ||
a.platform.localeCompare(b.platform) ||
rank(ARCHITECTURE_ORDER, a.architecture) -
rank(ARCHITECTURE_ORDER, b.architecture) ||
a.architecture.localeCompare(b.architecture)
);
}
function formatCell(result: VersionResolution | undefined): string {
switch (result?.status) {
case undefined:
return '';
case 'resolved':
if (!result.floating) {
return `\`${result.version}\``;
}
return (
`\`${result.advertisedVersion ?? result.version}\` ¹` +
(result.publishedAt ? ` (published ${result.publishedAt})` : '')
);
case 'unavailable':
return '—';
case 'unsupported':
return 'n/a';
case 'error':
return '❗ error';
}
}
interface Problem {
distribution: string;
versionSpec?: string;
platform?: string;
message: string;
}
function getProblems(results: VersionResolution[]): Problem[] {
return [
...findSilentDistributions(results).map(distribution => ({
distribution,
message:
'No release matched any requested version on any platform. The vendor metadata may be unreachable or its format may have changed.'
})),
...results
.filter(r => r.status === 'error')
.map(r => ({
distribution: r.distribution,
versionSpec: r.versionSpec,
platform: formatPlatform(r),
message: r.message?.split('\n')[0] ?? 'Unknown error'
}))
];
}
/** Supported operating systems for which no runner produced a report. */
function getUncheckedPlatforms(
distribution: string,
reportedPlatforms: Set<string>,
targets?: Record<string, Record<string, string[]>>
): string[] {
const platforms =
targets?.[distribution] ??
Object.fromEntries(
PLATFORM_ORDER.map(platform => [
platform,
getSupportedArchitectures(distribution, platform)
])
);
return Object.entries(platforms)
.filter(
([platform, architectures]) =>
architectures.length > 0 && !reportedPlatforms.has(platform)
)
.map(
([platform, architectures]) =>
`${PLATFORM_LABELS[platform] ?? platform} (${architectures.join(', ')})`
);
}
function escapeTableText(text: string): string {
return text.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
}
function renderSourceReport(
reports: ResolutionReport[],
options: {runUrl?: string} = {}
): string {
const results = reports.flatMap(report => report.results);
const distributions = [...new Set(results.map(r => r.distribution))].sort();
const versionSpecs = [...new Set(results.map(r => r.versionSpec))];
const reportedPlatforms = new Set(reports.map(report => report.platform));
const generatedAt = reports
.map(report => report.generatedAt)
.sort()
.at(-1);
const silentDistributions = findSilentDistributions(results);
const lines: string[] = [`## setup-java@${reports[0].source.ref}`, ''];
lines.push(
`Generated ${generatedAt ? `${generatedAt.replace('T', ' ').slice(0, 16)} UTC` : 'now'} for package type \`${PACKAGE_TYPE}\` on ${PLATFORM_ORDER.filter(
p => reportedPlatforms.has(p)
)
.map(p => PLATFORM_LABELS[p])
.join(', ')}.` +
(options.runUrl ? ` [Workflow run](${options.runUrl}).` : ''),
'',
'For each distribution, the table lists platform/architecture probes and the exact version this revision resolves from the distribution’s metadata today for each `java-version`. That is what a job installs on a tool-cache miss or with `check-latest: true`. Vendors publish builds per platform, so the same request can resolve to different versions on different platforms. No JDK was downloaded to produce this report.',
'',
'`—` no matching release is published for this platform · `n/a` `setup-java` does not support this version on this platform · ❗ the lookup failed',
''
);
const problems = getProblems(results);
if (problems.length > 0) {
lines.push(
'## Needs attention',
'',
'| Distribution | Version | Platform | Problem |',
'| --- | --- | --- | --- |'
);
for (const problem of problems) {
lines.push(
`| \`${problem.distribution}\` | ${problem.versionSpec ? `\`${problem.versionSpec}\`` : 'all'} | ${problem.platform ?? 'all'} | ${escapeTableText(problem.message)} |`
);
}
lines.push('');
}
for (const distribution of distributions) {
const distributionResults = results.filter(
r => r.distribution === distribution
);
const platforms = distributionResults
.filter(
(result, index) =>
distributionResults.findIndex(
other =>
other.platform === result.platform &&
other.architecture === result.architecture
) === index
)
.sort(comparePlatforms);
lines.push(
`## \`${distribution}\`${silentDistributions.includes(distribution) ? ' ❗' : ''}`,
'',
`| Platform | ${versionSpecs.map(v => `\`${v}\``).join(' | ')} |`,
`| --- | ${versionSpecs.map(() => '---').join(' | ')} |`
);
for (const platform of platforms) {
const cells = versionSpecs.map(versionSpec =>
formatCell(
distributionResults.find(
r =>
r.versionSpec === versionSpec &&
r.platform === platform.platform &&
r.architecture === platform.architecture
)
)
);
lines.push(`| ${formatPlatform(platform)} | ${cells.join(' | ')} |`);
}
lines.push('');
const unchecked = getUncheckedPlatforms(
distribution,
reportedPlatforms,
reports[0]?.targets
);
if (unchecked.length > 0) {
lines.push(
`Not checked, because no runner reported these platforms: ${unchecked.join(', ')}.`,
''
);
}
}
if (results.some(r => r.status === 'resolved' && r.floating)) {
lines.push(
'---',
'',
'¹ Major-only requests download the vendor’s mutable `/latest/` artifact, so the exact version is only known after download. The version the vendor advertises is shown when available.',
''
);
}
return lines.join('\n');
}
export function renderMarkdownReport(
reports: ResolutionReport[],
options: {
runUrl?: string;
expectedRefs?: string[];
overviewOnly?: boolean;
} = {}
): string {
const refs = [
...new Set([
...(options.expectedRefs ?? []),
...reports.map(report => report.source.ref)
])
];
const lines = [
'# Latest JDK versions by setup-java revision',
'',
"Each section uses that revision's own installers and dependencies. `v6` and `v5` track the latest major tags, pinned to the commits below for this run. No JDKs are downloaded.",
'',
"Older revisions may support different distributions, platforms or version syntax. In particular, `latest` is reported as `n/a` when that revision rejects it; it is not substituted with main's behavior. Revisions without capability maps probe all candidate architectures, leaving unsupported or unpublished combinations visible.",
'',
'| setup-java | Package version | Commit | Result |',
'| --- | --- | --- | --- |'
];
for (const ref of refs) {
const group = reports.filter(report => report.source.ref === ref);
if (!group.length) {
lines.push(`| \`${ref}\` | - | - | Not checked: no reports received |`);
continue;
}
const source = group[0].source;
if (
group.some(
report =>
report.source.sha !== source.sha ||
report.source.version !== source.version
)
) {
throw new Error(
`Reports for '${ref}' were produced from different revisions.`
);
}
const problems = getProblems(group.flatMap(report => report.results));
const platforms = new Set(group.map(report => report.platform));
const missing = PLATFORM_ORDER.filter(platform => !platforms.has(platform));
lines.push(
`| \`${ref}\` | ${source.version ?? 'local'} | ${source.sha ? `[\`${source.sha.slice(0, 12)}\`](https://github.com/actions/setup-java/commit/${source.sha})` : 'local checkout'} | ${platforms.size}/${PLATFORM_ORDER.length} platforms${missing.length ? `; not checked: ${missing.map(platform => PLATFORM_LABELS[platform]).join(', ')}` : ''}${problems.length ? `; ${problems.length} lookup problems` : ''} |`
);
}
if (options.overviewOnly) {
return lines.join('\n');
}
for (const ref of refs) {
const group = reports.filter(report => report.source.ref === ref);
if (!group.length) {
continue;
}
lines.push(
'',
'<details>',
`<summary>setup-java@${ref}</summary>`,
'',
renderSourceReport(group, options),
'</details>',
''
);
}
return lines.join('\n');
}
function parseList(value: string | undefined, fallback: string[]): string[] {
const items = (value ?? '')
.split(/[,\s]+/)
.map(item => item.trim())
.filter(Boolean);
return items.length > 0 ? items : fallback;
}
function readReports(inputDir: string): ResolutionReport[] {
return fs
.readdirSync(inputDir, {recursive: true, encoding: 'utf8'})
.filter(file => file.endsWith('.json'))
.sort()
.map(
file =>
JSON.parse(
fs.readFileSync(path.join(inputDir, file), 'utf8')
) as ResolutionReport
);
}
export async function run(args: string[]): Promise<void> {
const [command, target, markdownOutput] = args;
if (command === 'resolve' && target) {
const resolver = process.env.REPORT_RESOLVER
? await loadMetadataResolver(process.env.REPORT_RESOLVER)
: currentResolver;
const versions = parseList(process.env.REPORT_VERSIONS, []);
const report = await resolveLatestVersions({
distributions: parseList(
process.env.REPORT_DISTRIBUTIONS,
resolver.distributions
),
versions:
versions.length > 0
? versions
: await getDefaultVersions(
new RetryingHttpClient('actions/setup-java')
),
architectures: parseList(process.env.REPORT_ARCHITECTURES, []),
platform: process.env.REPORT_PLATFORM,
resolver
});
fs.mkdirSync(path.dirname(path.resolve(target)), {recursive: true});
fs.writeFileSync(target, JSON.stringify(report, null, 2));
return;
}
if (command === 'summarize' && target) {
const expectedRefs = parseList(process.env.REPORT_REFS, []);
const reports = fs.existsSync(target) ? readReports(target) : [];
if (reports.length === 0 && expectedRefs.length === 0) {
throw new Error(`No resolution reports found in '${target}'.`);
}
const {GITHUB_SERVER_URL, GITHUB_REPOSITORY, GITHUB_RUN_ID} = process.env;
const runUrl =
GITHUB_SERVER_URL && GITHUB_REPOSITORY && GITHUB_RUN_ID
? `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`
: undefined;
const markdown = renderMarkdownReport(reports, {
runUrl,
expectedRefs
});
if (markdownOutput) {
fs.writeFileSync(markdownOutput, markdown);
}
if (process.env.GITHUB_STEP_SUMMARY) {
// GitHub limits a step summary to 1 MiB. Keep the complete report in the
// artifact even when many legacy lookup errors make it too large.
if (Buffer.byteLength(markdown, 'utf8') > 1_000_000) {
core.warning(
'The full report exceeds the job summary size limit; showing its overview.'
);
const overview = renderMarkdownReport(reports, {
runUrl,
expectedRefs,
overviewOnly: true
});
await core.summary
.addRaw(
`${overview}\n\nFull per-platform tables are in the \`latest-jdk-versions-report\` artifact${runUrl ? ` on the [workflow run](${runUrl})` : ''}. The full report exceeded GitHub's summary size limit.\n`
)
.write();
} else {
await core.summary.addRaw(markdown).write();
}
} else {
core.info(markdown);
}
for (const ref of expectedRefs) {
if (!reports.some(report => report.source.ref === ref)) {
core.warning(
`${ref}: not checked because no resolution reports were received.`
);
}
}
for (const ref of new Set(reports.map(report => report.source.ref))) {
for (const problem of getProblems(
reports
.filter(report => report.source.ref === ref)
.flatMap(report => report.results)
)) {
const scope = [problem.versionSpec, problem.platform]
.filter(Boolean)
.join(', ');
core.warning(
`${ref}: ${problem.distribution}${scope ? ` (${scope})` : ''}: ${problem.message}`
);
}
}
return;
}
throw new Error(
'Usage: resolve <output.json> | summarize <input-dir> [output.md]'
);
}
if (isMainModule(import.meta.url)) {
run(process.argv.slice(2)).catch(error => {
core.setFailed(error instanceof Error ? error.message : String(error));
});
}

125
src/reports/resolver.ts Normal file
View File

@@ -0,0 +1,125 @@
import {pathToFileURL} from 'url';
import path from 'path';
import {getJavaDistribution} from '../distributions/distribution-factory.js';
import type {JavaInstallerOptions} from '../distributions/base-models.js';
import {LibericaDistributions} from '../distributions/liberica/installer.js';
import {JavaDistribution} from '../distributions/package-types.js';
import {
JAVA_PLATFORM_CAPABILITIES,
type JavaPlatformCapability
} from '../distributions/platform-types.js';
export interface ActionSource {
ref: string;
sha?: string;
version?: string;
}
export interface MetadataResolver {
source: ActionSource;
distributions: string[];
capabilities?: Record<string, JavaPlatformCapability>;
getJavaDistribution(
distribution: string,
options: JavaInstallerOptions
): unknown;
createSolarisInstaller(options: JavaInstallerOptions): unknown;
}
class SolarisLibericaDistribution extends LibericaDistributions {
protected override getPlatformOption() {
return super.getPlatformOption('sunos');
}
}
export const currentResolver: MetadataResolver = {
source: {ref: 'main'},
distributions: Object.values(JavaDistribution).filter(
distribution => distribution !== JavaDistribution.JdkFile
),
capabilities: JAVA_PLATFORM_CAPABILITIES,
getJavaDistribution,
createSolarisInstaller: options => new SolarisLibericaDistribution(options)
};
const LEGACY_ARCHITECTURES = [
'x64',
'aarch64',
'x86',
'armv7',
'ppc64le',
'ppc64',
'riscv64',
's390x'
];
export function getResolverArchitectures(
resolver: MetadataResolver,
distribution: string,
platform: string
): string[] {
if (!resolver.distributions.includes(distribution)) {
return [];
}
// v5 has no centralized capability map. Probe candidates with its own
// installer instead of imposing main's newer support restrictions on it.
if (!resolver.capabilities) {
if (platform === 'solaris' && distribution !== 'liberica') {
return [];
}
return [...LEGACY_ARCHITECTURES];
}
const capability = resolver.capabilities[distribution];
if (!capability || capability.unrestricted) {
return [];
}
const os = platform === 'linux-musl' ? 'linux' : platform;
const architectures = Object.entries(capability.platforms).find(
([name]) => name === os
)?.[1];
return [
...new Set(
(architectures ?? []).map(item =>
typeof item === 'string' ? item : item.architecture
)
)
];
}
/** Load the separately bundled checkout, including that revision's dependencies. */
export async function loadMetadataResolver(
directory: string
): Promise<MetadataResolver> {
const module: unknown = await import(
/* webpackIgnore: true */ pathToFileURL(
path.join(path.resolve(directory), 'index.js')
).href
);
// NCC emits ESM for v6/main and CommonJS for v5.
const candidate =
isRecord(module) && isRecord(module.default) ? module.default : module;
if (!isMetadataResolver(candidate)) {
throw new Error(`Invalid metadata resolver bundle in '${directory}'.`);
}
return candidate;
}
function isMetadataResolver(value: unknown): value is MetadataResolver {
return (
isRecord(value) &&
isRecord(value.source) &&
typeof value.source.ref === 'string' &&
typeof value.source.sha === 'string' &&
/^[a-f0-9]{40}$/.test(value.source.sha) &&
typeof value.source.version === 'string' &&
Array.isArray(value.distributions) &&
value.distributions.every(item => typeof item === 'string') &&
(value.capabilities === undefined || isRecord(value.capabilities)) &&
typeof value.getJavaDistribution === 'function' &&
typeof value.createSolarisInstaller === 'function'
);
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null;
}