Rename distribution to Eclipse Temurin

README.md

@@ -13,7 +13,7 @@ This action provides the following functionality for GitHub Actions runners:
 - Registering problem matchers for error output
 
 ## V2 vs V1
-- V2 supports custom distributions and provides support for Zulu OpenJDK, Adopt OpenJDK and Adoptium OpenJDK out of the box. V1 supports only Zulu OpenJDK
+- V2 supports custom distributions and provides support for Zulu OpenJDK, Adopt OpenJDK and Eclipse Temurin out of the box. V1 supports only Zulu OpenJDK
 - V2 requires you to specify distribution along with the version. V1 defaults to Zulu OpenJDK, only version input is required. Follow [the migration guide](docs/switching-to-v2.md) to switch from V1 to V2
 
 ## Usage
@@ -31,13 +31,13 @@ steps:
 - run: java -cp java HelloWorldApp
 ```
 
-**Adoptium OpenJDK**
+**Eclipse Temurin**
 ```yaml
 steps:
 - uses: actions/checkout@v2
 - uses: actions/setup-java@v2
   with:
-    distribution: 'adoptium' # See 'Supported distributions' for available options
+    distribution: 'temurin' # See 'Supported distributions' for available options
     java-version: '8'
 - run: java -cp java HelloWorldApp
 ```
@@ -66,7 +66,7 @@ Currently, the following distributions are supported:
 | `zulu` | Zulu OpenJDK | [Link](https://www.azul.com/downloads/zulu-community/?package=jdk) | [Link](https://www.azul.com/products/zulu-and-zulu-enterprise/zulu-terms-of-use/) |
 | `adopt` or `adopt-hotspot` | Adopt OpenJDK Hotspot | [Link](https://adoptopenjdk.net/) | [Link](https://adoptopenjdk.net/about.html)
 | `adopt-openj9` | Adopt OpenJDK OpenJ9 | [Link](https://adoptopenjdk.net/) | [Link](https://adoptopenjdk.net/about.html)
-| `adoptium` or `adoptium-hotspot` | Adoptium OpenJDK Hotspot | [Link](https://adoptium.net/) | [Link](https://adoptium.net/about.html)
+| `temurin` | Eclipse Temurin | [Link](https://adoptium.net/) | [Link](https://adoptium.net/about.html)
 
 **NOTE:** The different distributors can provide discrepant list of available versions / supported configurations. Please refer to the official documentation to see the list of supported versions.
 

__tests__/distributors/temurin-installer.test.ts

@@ -1,12 +1,12 @@
 import { HttpClient } from '@actions/http-client';
 
 import {
-  AdoptiumDistribution,
+  TemurinDistribution,
-  AdoptiumImplementation
+  TemurinImplementation
-} from '../../src/distributions/adoptium/installer';
+} from '../../src/distributions/temurin/installer';
 import { JavaInstallerOptions } from '../../src/distributions/base-models';
 
-let manifestData = require('../data/adoptium.json') as [];
+let manifestData = require('../data/temurin.json') as [];
 
 describe('getAvailableVersions', () => {
   let spyHttpClient: jest.SpyInstance;
@@ -29,32 +29,32 @@ describe('getAvailableVersions', () => {
   it.each([
     [
       { version: '16', architecture: 'x64', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot,
+      TemurinImplementation.Hotspot,
       'os=mac&architecture=x64&image_type=jdk&release_type=ga&jvm_impl=hotspot&page_size=20&page=0'
     ],
     [
       { version: '16', architecture: 'x86', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot,
+      TemurinImplementation.Hotspot,
       'os=mac&architecture=x86&image_type=jdk&release_type=ga&jvm_impl=hotspot&page_size=20&page=0'
     ],
     [
       { version: '16', architecture: 'x64', packageType: 'jre', checkLatest: false },
-      AdoptiumImplementation.Hotspot,
+      TemurinImplementation.Hotspot,
       'os=mac&architecture=x64&image_type=jre&release_type=ga&jvm_impl=hotspot&page_size=20&page=0'
     ],
     [
       { version: '16-ea', architecture: 'x64', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot,
+      TemurinImplementation.Hotspot,
       'os=mac&architecture=x64&image_type=jdk&release_type=ea&jvm_impl=hotspot&page_size=20&page=0'
     ]
   ])(
     'build correct url for %s',
     async (
       installerOptions: JavaInstallerOptions,
-      impl: AdoptiumImplementation,
+      impl: TemurinImplementation,
       expectedParameters
     ) => {
-      const distribution = new AdoptiumDistribution(installerOptions, impl);
+      const distribution = new TemurinDistribution(installerOptions, impl);
       const baseUrl = 'https://api.adoptium.net/v3/assets/version/%5B1.0,100.0%5D';
       const expectedUrl = `${baseUrl}?project=jdk&vendor=adoptium&heap_size=normal&sort_method=DEFAULT&sort_order=DESC&${expectedParameters}`;
       distribution['getPlatformOption'] = () => 'mac';
@@ -85,9 +85,9 @@ describe('getAvailableVersions', () => {
         result: []
       });
 
-    const distribution = new AdoptiumDistribution(
+    const distribution = new TemurinDistribution(
       { version: '8', architecture: 'x64', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot
+      TemurinImplementation.Hotspot
     );
     const availableVersions = await distribution['getAvailableVersions']();
     expect(availableVersions).not.toBeNull();
@@ -95,12 +95,12 @@ describe('getAvailableVersions', () => {
   });
 
   it.each([
-    [AdoptiumImplementation.Hotspot, 'jdk', 'Java_Adoptium-Hotspot_jdk'],
+    [TemurinImplementation.Hotspot, 'jdk', 'Java_Temurin-Hotspot_jdk'],
-    [AdoptiumImplementation.Hotspot, 'jre', 'Java_Adoptium-Hotspot_jre']
+    [TemurinImplementation.Hotspot, 'jre', 'Java_Temurin-Hotspot_jre']
   ])(
     'find right toolchain folder',
-    (impl: AdoptiumImplementation, packageType: string, expected: string) => {
+    (impl: TemurinImplementation, packageType: string, expected: string) => {
-      const distribution = new AdoptiumDistribution(
+      const distribution = new TemurinDistribution(
         { version: '8', architecture: 'x64', packageType: packageType, checkLatest: false },
         impl
       );
@@ -120,9 +120,9 @@ describe('findPackageForDownload', () => {
     ['8.x', '8.0.302+8'],
     ['x', '16.0.2+7']
   ])('version is resolved correctly %s -> %s', async (input, expected) => {
-    const distribution = new AdoptiumDistribution(
+    const distribution = new TemurinDistribution(
       { version: '8', architecture: 'x64', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot
+      TemurinImplementation.Hotspot
     );
     distribution['getAvailableVersions'] = async () => manifestData;
     const resolvedVersion = await distribution['findPackageForDownload'](input);
@@ -130,9 +130,9 @@ describe('findPackageForDownload', () => {
   });
 
   it('version is found but binaries list is empty', async () => {
-    const distribution = new AdoptiumDistribution(
+    const distribution = new TemurinDistribution(
       { version: '9.0.8', architecture: 'x64', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot
+      TemurinImplementation.Hotspot
     );
     distribution['getAvailableVersions'] = async () => manifestData;
     await expect(distribution['findPackageForDownload']('9.0.8')).rejects.toThrowError(
@@ -141,9 +141,9 @@ describe('findPackageForDownload', () => {
   });
 
   it('version is not found', async () => {
-    const distribution = new AdoptiumDistribution(
+    const distribution = new TemurinDistribution(
       { version: '7.x', architecture: 'x64', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot
+      TemurinImplementation.Hotspot
     );
     distribution['getAvailableVersions'] = async () => manifestData;
     await expect(distribution['findPackageForDownload']('7.x')).rejects.toThrowError(
@@ -152,9 +152,9 @@ describe('findPackageForDownload', () => {
   });
 
   it('version list is empty', async () => {
-    const distribution = new AdoptiumDistribution(
+    const distribution = new TemurinDistribution(
       { version: '8', architecture: 'x64', packageType: 'jdk', checkLatest: false },
-      AdoptiumImplementation.Hotspot
+      TemurinImplementation.Hotspot
     );
     distribution['getAvailableVersions'] = async () => [];
     await expect(distribution['findPackageForDownload']('8')).rejects.toThrowError(

dist/setup/index.js

@@ -1479,11 +1479,13 @@ exports.getJavaDistribution = void 0;
 const installer_1 = __webpack_require__(144);
 const installer_2 = __webpack_require__(393);
 const installer_3 = __webpack_require__(584);
+const installer_4 = __webpack_require__(852);
 var JavaDistribution;
 (function (JavaDistribution) {
     JavaDistribution["Adopt"] = "adopt";
     JavaDistribution["AdoptHotspot"] = "adopt-hotspot";
     JavaDistribution["AdoptOpenJ9"] = "adopt-openj9";
+    JavaDistribution["Temurin"] = "temurin";
     JavaDistribution["Zulu"] = "zulu";
     JavaDistribution["JdkFile"] = "jdkfile";
 })(JavaDistribution || (JavaDistribution = {}));
@@ -1496,6 +1498,8 @@ function getJavaDistribution(distributionName, installerOptions, jdkFile) {
             return new installer_3.AdoptDistribution(installerOptions, installer_3.AdoptImplementation.Hotspot);
         case JavaDistribution.AdoptOpenJ9:
             return new installer_3.AdoptDistribution(installerOptions, installer_3.AdoptImplementation.OpenJ9);
+        case JavaDistribution.Temurin:
+            return new installer_4.TemurinDistribution(installerOptions, installer_4.TemurinImplementation.Hotspot);
         case JavaDistribution.Zulu:
             return new installer_2.ZuluDistribution(installerOptions);
         default:
@@ -39873,7 +39877,171 @@ module.exports = new Type('tag:yaml.org,2002:omap', {
 /* 849 */,
 /* 850 */,
 /* 851 */,
-/* 852 */,
+/* 852 */
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemurinDistribution = exports.TemurinImplementation = void 0;
+const core = __importStar(__webpack_require__(470));
+const tc = __importStar(__webpack_require__(139));
+const fs_1 = __importDefault(__webpack_require__(747));
+const path_1 = __importDefault(__webpack_require__(622));
+const semver_1 = __importDefault(__webpack_require__(876));
+const base_installer_1 = __webpack_require__(83);
+const util_1 = __webpack_require__(322);
+var TemurinImplementation;
+(function (TemurinImplementation) {
+    TemurinImplementation["Hotspot"] = "Hotspot";
+})(TemurinImplementation = exports.TemurinImplementation || (exports.TemurinImplementation = {}));
+class TemurinDistribution extends base_installer_1.JavaBase {
+    constructor(installerOptions, jvmImpl) {
+        super(`Temurin-${jvmImpl}`, installerOptions);
+        this.jvmImpl = jvmImpl;
+    }
+    findPackageForDownload(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableVersionsRaw = yield this.getAvailableVersions();
+            const availableVersionsWithBinaries = availableVersionsRaw
+                .filter(item => item.binaries.length > 0)
+                .map(item => {
+                return {
+                    version: item.version_data.semver,
+                    url: item.binaries[0].package.link
+                };
+            });
+            const satisfiedVersions = availableVersionsWithBinaries
+                .filter(item => util_1.isVersionSatisfies(version, item.version))
+                .sort((a, b) => {
+                return -semver_1.default.compareBuild(a.version, b.version);
+            });
+            const resolvedFullVersion = satisfiedVersions.length > 0 ? satisfiedVersions[0] : null;
+            if (!resolvedFullVersion) {
+                const availableOptions = availableVersionsWithBinaries.map(item => item.version).join(', ');
+                const availableOptionsMessage = availableOptions
+                    ? `\nAvailable versions: ${availableOptions}`
+                    : '';
+                throw new Error(`Could not find satisfied version for SemVer '${version}'. ${availableOptionsMessage}`);
+            }
+            return resolvedFullVersion;
+        });
+    }
+    downloadTool(javaRelease) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let javaPath;
+            let extractedJavaPath;
+            core.info(`Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`);
+            const javaArchivePath = yield tc.downloadTool(javaRelease.url);
+            core.info(`Extracting Java archive...`);
+            let extension = util_1.getDownloadArchiveExtension();
+            extractedJavaPath = yield util_1.extractJdkFile(javaArchivePath, extension);
+            const archiveName = fs_1.default.readdirSync(extractedJavaPath)[0];
+            const archivePath = path_1.default.join(extractedJavaPath, archiveName);
+            const version = this.getToolcacheVersionName(javaRelease.version);
+            javaPath = yield tc.cacheDir(archivePath, this.toolcacheFolderName, version, this.architecture);
+            return { version: javaRelease.version, path: javaPath };
+        });
+    }
+    get toolcacheFolderName() {
+        return super.toolcacheFolderName;
+    }
+    getAvailableVersions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = this.getPlatformOption();
+            const arch = this.architecture;
+            const imageType = this.packageType;
+            const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions
+            const releaseType = this.stable ? 'ga' : 'ea';
+            console.time('temurin-retrieve-available-versions');
+            const baseRequestArguments = [
+                `project=jdk`,
+                'vendor=adoptium',
+                `heap_size=normal`,
+                'sort_method=DEFAULT',
+                'sort_order=DESC',
+                `os=${platform}`,
+                `architecture=${arch}`,
+                `image_type=${imageType}`,
+                `release_type=${releaseType}`,
+                `jvm_impl=${this.jvmImpl.toLowerCase()}`
+            ].join('&');
+            // need to iterate through all pages to retrieve the list of all versions
+            // Adoptium API doesn't provide way to retrieve the count of pages to iterate so infinity loop
+            let page_index = 0;
+            const availableVersions = [];
+            while (true) {
+                const requestArguments = `${baseRequestArguments}&page_size=20&page=${page_index}`;
+                const availableVersionsUrl = `https://api.adoptium.net/v3/assets/version/${versionRange}?${requestArguments}`;
+                if (core.isDebug() && page_index === 0) {
+                    // url is identical except page_index so print it once for debug
+                    core.debug(`Gathering available versions from '${availableVersionsUrl}'`);
+                }
+                const paginationPage = (yield this.http.getJson(availableVersionsUrl)).result;
+                if (paginationPage === null || paginationPage.length === 0) {
+                    // break infinity loop because we have reached end of pagination
+                    break;
+                }
+                availableVersions.push(...paginationPage);
+                page_index++;
+            }
+            if (core.isDebug()) {
+                core.startGroup('Print information about available versions');
+                console.timeEnd('temurin-retrieve-available-versions');
+                console.log(`Available versions: [${availableVersions.length}]`);
+                console.log(availableVersions.map(item => item.version_data.semver).join(', '));
+                core.endGroup();
+            }
+            return availableVersions;
+        });
+    }
+    getPlatformOption() {
+        // Adoptium has own platform names so need to map them
+        switch (process.platform) {
+            case 'darwin':
+                return 'mac';
+            case 'win32':
+                return 'windows';
+            default:
+                return process.platform;
+        }
+    }
+}
+exports.TemurinDistribution = TemurinDistribution;
+
+
+/***/ }),
 /* 853 */,
 /* 854 */,
 /* 855 */,

src/distributions/distribution-factory.ts

@@ -3,14 +3,13 @@ import { JavaInstallerOptions } from './base-models';
 import { LocalDistribution } from './local/installer';
 import { ZuluDistribution } from './zulu/installer';
 import { AdoptDistribution, AdoptImplementation } from './adopt/installer';
-import { AdoptiumDistribution, AdoptiumImplementation } from './adoptium/installer';
+import { TemurinDistribution, TemurinImplementation } from './temurin/installer';
 
 enum JavaDistribution {
   Adopt = 'adopt',
   AdoptHotspot = 'adopt-hotspot',
   AdoptOpenJ9 = 'adopt-openj9',
-  Adoptium = 'adoptium',
+  Temurin = 'temurin',
-  AdoptiumHotspot = 'adoptium-hotspot',
   Zulu = 'zulu',
   JdkFile = 'jdkfile'
 }
@@ -28,9 +27,8 @@ export function getJavaDistribution(
       return new AdoptDistribution(installerOptions, AdoptImplementation.Hotspot);
     case JavaDistribution.AdoptOpenJ9:
       return new AdoptDistribution(installerOptions, AdoptImplementation.OpenJ9);
-    case JavaDistribution.Adoptium:
+    case JavaDistribution.Temurin:
-    case JavaDistribution.AdoptiumHotspot:
+      return new TemurinDistribution(installerOptions, TemurinImplementation.Hotspot);
-      return new AdoptiumDistribution(installerOptions, AdoptiumImplementation.Hotspot);
     case JavaDistribution.Zulu:
       return new ZuluDistribution(installerOptions);
     default:

src/distributions/temurin/installer.ts

@@ -6,20 +6,20 @@ import path from 'path';
 import semver from 'semver';
 
 import { JavaBase } from '../base-installer';
-import { IAdoptiumAvailableVersions } from './models';
+import { ITemurinAvailableVersions } from './models';
 import { JavaDownloadRelease, JavaInstallerOptions, JavaInstallerResults } from '../base-models';
 import { extractJdkFile, getDownloadArchiveExtension, isVersionSatisfies } from '../../util';
 
-export enum AdoptiumImplementation {
+export enum TemurinImplementation {
   Hotspot = 'Hotspot'
 }
 
-export class AdoptiumDistribution extends JavaBase {
+export class TemurinDistribution extends JavaBase {
   constructor(
     installerOptions: JavaInstallerOptions,
-    private readonly jvmImpl: AdoptiumImplementation
+    private readonly jvmImpl: TemurinImplementation
   ) {
-    super(`Adoptium-${jvmImpl}`, installerOptions);
+    super(`Temurin-${jvmImpl}`, installerOptions);
   }
 
   protected async findPackageForDownload(version: string): Promise<JavaDownloadRelease> {
@@ -80,14 +80,14 @@ export class AdoptiumDistribution extends JavaBase {
     return super.toolcacheFolderName;
   }
 
-  private async getAvailableVersions(): Promise<IAdoptiumAvailableVersions[]> {
+  private async getAvailableVersions(): Promise<ITemurinAvailableVersions[]> {
     const platform = this.getPlatformOption();
     const arch = this.architecture;
     const imageType = this.packageType;
     const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions
     const releaseType = this.stable ? 'ga' : 'ea';
 
-    console.time('adoptium-retrieve-available-versions');
+    console.time('temurin-retrieve-available-versions');
 
     const baseRequestArguments = [
       `project=jdk`,
@@ -105,7 +105,7 @@ export class AdoptiumDistribution extends JavaBase {
     // need to iterate through all pages to retrieve the list of all versions
     // Adoptium API doesn't provide way to retrieve the count of pages to iterate so infinity loop
     let page_index = 0;
-    const availableVersions: IAdoptiumAvailableVersions[] = [];
+    const availableVersions: ITemurinAvailableVersions[] = [];
     while (true) {
       const requestArguments = `${baseRequestArguments}&page_size=20&page=${page_index}`;
       const availableVersionsUrl = `https://api.adoptium.net/v3/assets/version/${versionRange}?${requestArguments}`;
@@ -115,7 +115,7 @@ export class AdoptiumDistribution extends JavaBase {
       }
 
       const paginationPage = (
-        await this.http.getJson<IAdoptiumAvailableVersions[]>(availableVersionsUrl)
+        await this.http.getJson<ITemurinAvailableVersions[]>(availableVersionsUrl)
       ).result;
       if (paginationPage === null || paginationPage.length === 0) {
         // break infinity loop because we have reached end of pagination
@@ -128,7 +128,7 @@ export class AdoptiumDistribution extends JavaBase {
 
     if (core.isDebug()) {
       core.startGroup('Print information about available versions');
-      console.timeEnd('adoptium-retrieve-available-versions');
+      console.timeEnd('temurin-retrieve-available-versions');
       console.log(`Available versions: [${availableVersions.length}]`);
       console.log(availableVersions.map(item => item.version_data.semver).join(', '));
       core.endGroup();

src/distributions/temurin/models.ts

@@ -1,6 +1,6 @@
 // Models from https://api.adoptium.net/q/swagger-ui/#/Assets/searchReleasesByVersion
 
-export interface IAdoptiumAvailableVersions {
+export interface ITemurinAvailableVersions {
   binaries: [
     {
       architecture: string;