Files
setup-java/src/reports/latest-versions.ts
T
Bruno BorgesandCopilot App 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

704 lines
22 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import * as core from '@actions/core';
import * as httpm from '@actions/http-client';
import fs from 'fs';
import path from 'path';
import {getJavaDistribution} from '../distributions/distribution-factory.js';
import type {JavaBase} from '../distributions/base-installer.js';
import type {JavaDownloadRelease} from '../distributions/base-models.js';
import {LibericaDistributions} from '../distributions/liberica/installer.js';
import {JavaDistribution} from '../distributions/package-types.js';
import {
isAlpineLinux,
JAVA_PLATFORM_CAPABILITIES,
JavaPlatform,
normalizePlatform,
validateJavaPlatform
} from '../distributions/platform-types.js';
import {isMainModule} from '../is-main-module.js';
import {RetryingHttpClient} from '../retrying-http-client.js';
import {getLatestMajorVersion} from '../util.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: string[] = Object.values(
JavaDistribution
).filter(distribution => distribution !== JavaDistribution.JdkFile);
const PACKAGE_TYPE = 'jdk';
const CONCURRENCY = 6;
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 {
platform: string;
generatedAt: string;
results: VersionResolution[];
}
interface ReleaseResolver {
version: string;
http: httpm.HttpClient;
findPackageForDownload(range: string): Promise<JavaDownloadRelease>;
}
// Metadata resolution does not require a Solaris runner or executing its JDK.
class SolarisLibericaDistribution extends LibericaDistributions {
protected override getPlatformOption() {
return super.getPlatformOption('sunos');
}
}
/** 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
): string[] {
const capability =
JAVA_PLATFORM_CAPABILITIES[distribution as JavaDistribution];
if (!capability || capability.unrestricted) {
return [];
}
const os = (platform === MUSL_PLATFORM ? 'linux' : platform) as JavaPlatform;
return [
...new Set(
(capability.platforms[os] ?? []).map(item =>
typeof item === 'string' ? item : item.architecture
)
)
];
}
export function classifyResolutionError(error: unknown): ResolutionStatus {
const message = error instanceof Error ? error.message : String(error);
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. 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 = request();
cache.set(key, response);
response.catch(() => cache.delete(key));
}
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
): Promise<VersionResolution> {
const base = {
distribution: distributionName,
versionSpec,
platform,
architecture
};
let installer: JavaBase | null;
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}'.`
};
}
validateJavaPlatform(
distributionName,
'sunos',
architecture,
versionSpec
);
installer = new SolarisLibericaDistribution(installerOptions);
} else {
installer = await getJavaDistribution(distributionName, installerOptions);
}
} catch (error) {
return {
...base,
status: 'unsupported',
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.
const resolver = installer as unknown as ReleaseResolver;
shareMetadataResponses(resolver.http, cache);
try {
const release = await resolver.findPackageForDownload(resolver.version);
return {
...base,
status: 'resolved',
version: release.version,
...(release.floating
? {
floating: true,
...(await describeFloatingRelease(http, distributionName, release))
}
: {})
};
} catch (error) {
return {
...base,
status: classifyResolutionError(error),
message: error instanceof Error ? error.message : String(error)
};
}
}
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[]> {
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;
}): Promise<ResolutionReport> {
const http = new RetryingHttpClient('actions/setup-java');
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
).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
);
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 {
platform,
generatedAt: new Date().toISOString(),
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>
): string[] {
const capability =
JAVA_PLATFORM_CAPABILITIES[distribution as JavaDistribution];
if (!capability || capability.unrestricted) {
return [];
}
const platforms = Object.keys(capability.platforms);
if (platforms.includes('linux')) {
platforms.push(MUSL_PLATFORM);
}
return platforms
.filter(platform => !reportedPlatforms.has(platform))
.map(
platform =>
`${PLATFORM_LABELS[platform] ?? platform} (${getSupportedArchitectures(distribution, platform).join(', ')})`
);
}
function escapeTableText(text: string): string {
return text.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
}
export function renderMarkdownReport(
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[] = ['# Latest JDK versions resolved by setup-java', ''];
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 every operating system and architecture `setup-java` supports and the exact version it 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);
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');
}
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 versions = parseList(process.env.REPORT_VERSIONS, []);
const report = await resolveLatestVersions({
distributions: parseList(
process.env.REPORT_DISTRIBUTIONS,
REPORTED_DISTRIBUTIONS
),
versions:
versions.length > 0
? versions
: await getDefaultVersions(
new RetryingHttpClient('actions/setup-java')
),
architectures: parseList(process.env.REPORT_ARCHITECTURES, []),
platform: process.env.REPORT_PLATFORM
});
fs.mkdirSync(path.dirname(path.resolve(target)), {recursive: true});
fs.writeFileSync(target, JSON.stringify(report, null, 2));
return;
}
if (command === 'summarize' && target) {
const reports = readReports(target);
if (reports.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});
if (markdownOutput) {
fs.writeFileSync(markdownOutput, markdown);
}
if (process.env.GITHUB_STEP_SUMMARY) {
await core.summary.addRaw(markdown).write();
} else {
core.info(markdown);
}
for (const problem of getProblems(
reports.flatMap(report => report.results)
)) {
const scope = [problem.versionSpec, problem.platform]
.filter(Boolean)
.join(', ');
core.warning(
`${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));
});
}