mirror of
https://github.com/actions/setup-java.git
synced 2026-08-06 22:19:29 +08:00
Bruno Borges
4fbd0bd19d
On Alpine, `getPlatformOption()` returned the glibc platform key for Dragonwell, Corretto, Zulu, Liberica and Liberica NIK, so the action resolved and installed a glibc JDK that cannot run under musl. Add a shared `isAlpineLinux()` helper and use it to select each vendor's musl artifacts: | distribution | glibc | musl | | ------------ | ------------- | -------------- | | Dragonwell | `linux` | `alpine-linux` | | Corretto | `linux` | `alpine` | | Zulu | `linux_glibc` | `linux_musl` | | Liberica | `linux` | `linux-musl` | | Liberica NIK | `linux` | `linux-musl` | Each key was verified against the vendor's live metadata API or manifest. There is deliberately no silent fallback to glibc when a vendor has no musl build for the requested version or architecture: the existing "could not find a version that satisfies" error fires instead. This matches the behaviour Temurin and SapMachine already have, and a glibc JDK would not run on musl anyway. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 74248bb0-72af-41d8-b85d-b0f5836e68db
199 lines
10 KiB
JavaScript
199 lines
10 KiB
JavaScript
export const id = 978;
|
|
export const ids = [978];
|
|
export const modules = {
|
|
|
|
/***/ 9597:
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ ZuluDistribution: () => (/* binding */ ZuluDistribution)
|
|
/* harmony export */ });
|
|
/* harmony import */ var _actions_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3838);
|
|
/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6928);
|
|
/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
|
|
/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9896);
|
|
/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_2__);
|
|
/* harmony import */ var semver__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2088);
|
|
/* harmony import */ var semver__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(semver__WEBPACK_IMPORTED_MODULE_3__);
|
|
/* harmony import */ var _base_installer_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6242);
|
|
/* harmony import */ var _platform_types_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7444);
|
|
/* harmony import */ var _util_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(4527);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ZuluDistribution extends _base_installer_js__WEBPACK_IMPORTED_MODULE_4__/* .JavaBase */ .O {
|
|
constructor(installerOptions) {
|
|
super('Zulu', installerOptions);
|
|
}
|
|
async findPackageForDownload(version) {
|
|
const availableVersionsRaw = await this.getAvailableVersions();
|
|
const availableVersions = availableVersionsRaw.map(item => {
|
|
// The Azul Metadata API reports the JDK build number separately from
|
|
// java_version (e.g. java_version=[17,0,7], openjdk_build_number=7).
|
|
// Append it so the resulting semver retains the build (e.g. 17.0.7+7).
|
|
const javaVersion = item.openjdk_build_number != null
|
|
? [...item.java_version, item.openjdk_build_number]
|
|
: item.java_version;
|
|
return {
|
|
version: (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .convertVersionToSemver */ .ZY)(javaVersion),
|
|
url: item.download_url,
|
|
zuluVersion: (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .convertVersionToSemver */ .ZY)(item.distro_version),
|
|
packageUuid: item.package_uuid
|
|
};
|
|
});
|
|
const satisfiedVersions = availableVersions
|
|
.filter(item => (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .isVersionSatisfies */ .y)(version, item.version))
|
|
.sort((a, b) => {
|
|
// Azul provides two versions: java_version and distro_version
|
|
// we should sort by both fields by descending
|
|
return (-semver__WEBPACK_IMPORTED_MODULE_3___default().compareBuild(a.version, b.version) ||
|
|
-semver__WEBPACK_IMPORTED_MODULE_3___default().compareBuild(a.zuluVersion, b.zuluVersion));
|
|
})
|
|
.map((item) => ({
|
|
version: item.version,
|
|
url: item.url,
|
|
packageUuid: item.packageUuid
|
|
}));
|
|
const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null;
|
|
if (!resolvedFullVersion) {
|
|
const availableVersionStrings = availableVersions.map(item => item.version);
|
|
throw this.createVersionNotFoundError(version, availableVersionStrings);
|
|
}
|
|
const packageDetailsUrl = `https://api.azul.com/metadata/v1/zulu/packages/${resolvedFullVersion.packageUuid}`;
|
|
const packageDetails = (await this.http.getJson(packageDetailsUrl)).result;
|
|
const digest = packageDetails?.sha256_hash?.match(/^[a-f0-9]{64}$/i)?.[0];
|
|
if (!digest) {
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .debug */ .Yz(`No authoritative sha256 checksum is available for Zulu version ${resolvedFullVersion.version} from ${packageDetailsUrl}; skipping checksum verification.`);
|
|
}
|
|
return {
|
|
version: resolvedFullVersion.version,
|
|
url: resolvedFullVersion.url,
|
|
checksum: digest
|
|
? {
|
|
algorithm: 'sha256',
|
|
value: digest,
|
|
source: packageDetailsUrl
|
|
}
|
|
: undefined
|
|
};
|
|
}
|
|
async downloadTool(javaRelease) {
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .info */ .pq(`Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`);
|
|
let javaArchivePath = await this.downloadAndVerify(javaRelease);
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .info */ .pq(`Extracting Java archive...`);
|
|
const extension = (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .getDownloadArchiveExtension */ .ag)();
|
|
if (process.platform === 'win32') {
|
|
javaArchivePath = (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .renameWinArchive */ .n2)(javaArchivePath);
|
|
}
|
|
const extractedJavaPath = await (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .extractJdkFile */ .PE)(javaArchivePath, extension);
|
|
const archiveName = fs__WEBPACK_IMPORTED_MODULE_2___default().readdirSync(extractedJavaPath)[0];
|
|
const archivePath = path__WEBPACK_IMPORTED_MODULE_1___default().join(extractedJavaPath, archiveName);
|
|
const javaPath = await (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .cacheJdkDir */ .Vj)(archivePath, this.toolcacheFolderName, this.getToolcacheVersionName(javaRelease.version), this.architecture);
|
|
return { version: javaRelease.version, path: javaPath };
|
|
}
|
|
async getAvailableVersions() {
|
|
const arch = this.getArchitectureOptions();
|
|
const [bundleType, features] = this.packageType.split('+');
|
|
const platform = this.getPlatformOption();
|
|
const extension = (0,_util_js__WEBPACK_IMPORTED_MODULE_6__/* .getDownloadArchiveExtension */ .ag)();
|
|
const javafx = features?.includes('fx') ?? false;
|
|
const crac = features?.includes('crac') ?? false;
|
|
const releaseStatus = this.stable ? 'ga' : 'ea';
|
|
if (_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .isDebug */ ._o()) {
|
|
console.time('Retrieving available versions for Zulu took'); // eslint-disable-line no-console
|
|
}
|
|
const baseRequestArguments = [
|
|
`os=${platform}`,
|
|
`archive_type=${extension}`,
|
|
`java_package_type=${bundleType}`,
|
|
`javafx_bundled=${javafx}`,
|
|
`crac_supported=${crac}`,
|
|
`arch=${arch}`,
|
|
`release_status=${releaseStatus}`,
|
|
`availability_types=ca`
|
|
].join('&');
|
|
// Need to iterate through all pages to retrieve the list of all versions.
|
|
// The Azul API doesn't return a total page count, so paginate until a page
|
|
// comes back empty (or short), guarding against a runaway loop with a cap.
|
|
const pageSize = 100;
|
|
const maxPages = 100;
|
|
let pageIndex = 1;
|
|
const availableVersions = [];
|
|
while (pageIndex <= maxPages) {
|
|
const requestArguments = `${baseRequestArguments}&page=${pageIndex}&page_size=${pageSize}`;
|
|
const availableVersionsUrl = `https://api.azul.com/metadata/v1/zulu/packages/?${requestArguments}`;
|
|
if (_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .isDebug */ ._o() && pageIndex === 1) {
|
|
// the url is identical except for the page number, so print it once for debug
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .debug */ .Yz(`Gathering available versions from '${availableVersionsUrl}'`);
|
|
}
|
|
const paginationPage = (await this.http.getJson(availableVersionsUrl)).result;
|
|
if (!paginationPage || paginationPage.length === 0) {
|
|
// stop paginating because we have reached the end of the results
|
|
break;
|
|
}
|
|
availableVersions.push(...paginationPage);
|
|
if (paginationPage.length < pageSize) {
|
|
// a short page means this was the last one; avoid an extra empty request
|
|
break;
|
|
}
|
|
pageIndex++;
|
|
}
|
|
if (pageIndex > maxPages) {
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .warning */ .$e(`Reached the maximum of ${maxPages} pages while listing Zulu versions; results may be truncated.`);
|
|
}
|
|
if (_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .isDebug */ ._o()) {
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .startGroup */ .Oh('Print information about available versions');
|
|
console.timeEnd('Retrieving available versions for Zulu took'); // eslint-disable-line no-console
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .debug */ .Yz(`Available versions: [${availableVersions.length}]`);
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .debug */ .Yz(availableVersions.map(item => item.java_version.join('.')).join(', '));
|
|
_actions_core__WEBPACK_IMPORTED_MODULE_0__/* .endGroup */ .N4();
|
|
}
|
|
return availableVersions;
|
|
}
|
|
getArchitectureOptions() {
|
|
const arch = this.distributionArchitecture();
|
|
switch (arch) {
|
|
case 'x64':
|
|
return 'x64';
|
|
case 'x86':
|
|
// The Azul Metadata API's "x86" value returns both 32-bit (i686) and
|
|
// 64-bit (x64) packages, which are indistinguishable by version and
|
|
// would let a 32-bit request resolve to a 64-bit JDK. Use "i686" to
|
|
// target only genuine 32-bit builds, matching the legacy API behavior.
|
|
return 'i686';
|
|
case 'armv7':
|
|
return 'arm';
|
|
case 'aarch64':
|
|
case 'arm64':
|
|
return 'aarch64';
|
|
default:
|
|
return arch;
|
|
}
|
|
}
|
|
getPlatformOption() {
|
|
// Azul has own platform names so need to map them
|
|
switch (process.platform) {
|
|
case 'darwin':
|
|
return 'macos';
|
|
case 'win32':
|
|
return 'windows';
|
|
case 'linux':
|
|
// The new Metadata API's "linux" value returns both glibc and musl
|
|
// packages, so target the libc the runner actually has. A glibc JDK
|
|
// cannot run on Alpine.
|
|
return (0,_platform_types_js__WEBPACK_IMPORTED_MODULE_5__/* .isAlpineLinux */ .G6)() ? 'linux_musl' : 'linux_glibc';
|
|
default:
|
|
return process.platform;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***/ })
|
|
|
|
};
|