Semeru Support

.github/workflows/e2e-versions.yml

@@ -19,9 +19,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest, ubuntu-latest]
-        distribution: ['temurin', 'adopt', 'adopt-openj9', 'zulu', 'liberica', 'microsoft' ] # internally 'adopt-hotspot' is the same as 'adopt'
-        version: ['8', '11', '16']
+        os: [ubuntu-latest]
+        distribution: ['semeru'] # internally 'adopt-hotspot' is the same as 'adopt'
+        version: ['8', '11', '16', '17']
         exclude:
         - distribution: microsoft
           version: 8

.gitignore

@@ -94,3 +94,6 @@ typings/
 # DynamoDB Local files
 .dynamodb/
 .vscode/
+
+# IntelliJ / WebStorm
+/.idea/

README.md

@@ -60,10 +60,11 @@ Currently, the following distributions are supported:
 | `adopt-openj9` | Adopt OpenJDK OpenJ9 | [Link](https://adoptopenjdk.net/) | [Link](https://adoptopenjdk.net/about.html) |
 | `liberica` | Liberica JDK | [Link](https://bell-sw.com/) | [Link](https://bell-sw.com/liberica_eula/) |
 | `microsoft` | Microsoft Build of OpenJDK | [Link](https://www.microsoft.com/openjdk) | [Link](https://docs.microsoft.com/java/openjdk/faq)
+| `semeru` | IBM Semeru OpenJDK with OpenJ9 | [Link](https://developer.ibm.com/languages/java/semeru-runtimes/downloads/) | [Link](https://openjdk.java.net/legal/gplv2+ce.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.
 
-**NOTE:** Adopt OpenJDK got moved to Eclipse Temurin and won't be updated anymore. It is highly recommended to migrate workflows from `adopt` to `temurin` to keep receiving software and security updates. See more details in the [Good-bye AdoptOpenJDK post](https://blog.adoptopenjdk.net/2021/08/goodbye-adoptopenjdk-hello-adoptium/).
+**NOTE:** Adopt OpenJDK got moved to Eclipse Temurin and won't be updated anymore. It is highly recommended to migrate workflows from `adopt` and `adopt-openj9`, to `temurin` and `semeru` respectively, to keep receiving software and security updates. See more details in the [Good-bye AdoptOpenJDK post](https://blog.adoptopenjdk.net/2021/08/goodbye-adoptopenjdk-hello-adoptium/).
 
 ### Caching packages dependencies
 The action has a built-in functionality for caching and restoring dependencies. It uses [actions/cache](https://github.com/actions/cache) under hood for caching dependencies but requires less configuration settings. Supported package managers are gradle and maven. The format of the used cache key is `setup-java-${{ platform }}-${{ packageManager }}-${{ fileHash }}`, where the hash is based on the following files:

__tests__/distributors/semeru-installer.test.ts

@@ -0,0 +1,254 @@
+import { HttpClient } from '@actions/http-client';
+
+import { JavaInstallerOptions } from '../../src/distributions/base-models';
+import { SemeruDistribution } from '../../src/distributions/semeru/installer';
+
+let manifestData = require('../data/semeru.json') as [];
+
+describe('getAvailableVersions', () => {
+  let spyHttpClient: jest.SpyInstance;
+
+  beforeEach(() => {
+    spyHttpClient = jest.spyOn(HttpClient.prototype, 'getJson');
+    spyHttpClient.mockReturnValue({
+      statusCode: 200,
+      headers: {},
+      result: []
+    });
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it.each([
+    [
+      { version: '16', architecture: 'x64', packageType: 'jdk', checkLatest: false },
+      'os=mac&architecture=x64&image_type=jdk&release_type=ga&jvm_impl=openj9&page_size=20&page=0'
+    ],
+    [
+      { version: '16', architecture: 'x86', packageType: 'jdk', checkLatest: false },
+      'os=mac&architecture=x86&image_type=jdk&release_type=ga&jvm_impl=openj9&page_size=20&page=0'
+    ],
+    [
+      { version: '16', architecture: 'x64', packageType: 'jre', checkLatest: false },
+      'os=mac&architecture=x64&image_type=jre&release_type=ga&jvm_impl=openj9&page_size=20&page=0'
+    ],
+    [
+      { version: '16', architecture: 'x64', packageType: 'jdk', checkLatest: false },
+      'os=mac&architecture=x64&image_type=jdk&release_type=ga&jvm_impl=openj9&page_size=20&page=0'
+    ]
+  ])(
+    'build correct url for %s',
+    async (installerOptions: JavaInstallerOptions, expectedParameters) => {
+      const distribution = new SemeruDistribution(installerOptions);
+      const baseUrl = 'https://api.adoptopenjdk.net/v3/assets/version/%5B1.0,100.0%5D';
+      const expectedUrl = `${baseUrl}?project=jdk&vendor=ibm&heap_size=normal&sort_method=DEFAULT&sort_order=DESC&${expectedParameters}`;
+      distribution['getPlatformOption'] = () => 'mac';
+
+      await distribution['getAvailableVersions']();
+
+      expect(spyHttpClient.mock.calls).toHaveLength(1);
+      expect(spyHttpClient.mock.calls[0][0]).toBe(expectedUrl);
+    }
+  );
+
+  it('load available versions', async () => {
+    spyHttpClient = jest.spyOn(HttpClient.prototype, 'getJson');
+    spyHttpClient
+      .mockReturnValueOnce({
+        statusCode: 200,
+        headers: {},
+        result: manifestData
+      })
+      .mockReturnValueOnce({
+        statusCode: 200,
+        headers: {},
+        result: manifestData
+      })
+      .mockReturnValueOnce({
+        statusCode: 200,
+        headers: {},
+        result: []
+      });
+
+    const distribution = new SemeruDistribution({
+      version: '8',
+      architecture: 'x64',
+      packageType: 'jdk',
+      checkLatest: false
+    });
+    const availableVersions = await distribution['getAvailableVersions']();
+    expect(availableVersions).not.toBeNull();
+    expect(availableVersions.length).toBe(manifestData.length * 2);
+  });
+
+  it.each([
+    ['jdk', 'Java_IBM_Semeru_jdk'],
+    ['jre', 'Java_IBM_Semeru_jre']
+  ])('find right toolchain folder', (packageType: string, expected: string) => {
+    const distribution = new SemeruDistribution({
+      version: '8',
+      architecture: 'x64',
+      packageType: packageType,
+      checkLatest: false
+    });
+
+    // @ts-ignore - because it is protected
+    expect(distribution.toolcacheFolderName).toBe(expected);
+  });
+});
+
+describe('findPackageForDownload', () => {
+  it.each([
+    ['8', '8.0.322+6'],
+    ['16', '16.0.2+7'],
+    ['16.0', '16.0.2+7'],
+    ['16.0.2', '16.0.2+7'],
+    ['8.x', '8.0.322+6'],
+    ['x', '17.0.2+8']
+  ])('version is resolved correctly %s -> %s', async (input, expected) => {
+    const distribution = new SemeruDistribution({
+      version: '8',
+      architecture: 'x64',
+      packageType: 'jdk',
+      checkLatest: false
+    });
+    distribution['getAvailableVersions'] = async () => manifestData;
+    const resolvedVersion = await distribution['findPackageForDownload'](input);
+    expect(resolvedVersion.version).toBe(expected);
+  });
+
+  it('version is found but binaries list is empty', async () => {
+    const distribution = new SemeruDistribution({
+      version: '9.0.8',
+      architecture: 'x64',
+      packageType: 'jdk',
+      checkLatest: false
+    });
+    distribution['getAvailableVersions'] = async () => manifestData;
+    await expect(distribution['findPackageForDownload']('9.0.8')).rejects.toThrowError(
+      /Could not find satisfied version for SemVer */
+    );
+  });
+
+  it('version is not found', async () => {
+    const distribution = new SemeruDistribution({
+      version: '7.x',
+      architecture: 'x64',
+      packageType: 'jdk',
+      checkLatest: false
+    });
+    distribution['getAvailableVersions'] = async () => manifestData;
+    await expect(distribution['findPackageForDownload']('7.x')).rejects.toThrowError(
+      /Could not find satisfied version for SemVer */
+    );
+  });
+
+  it('version list is empty', async () => {
+    const distribution = new SemeruDistribution({
+      version: '8',
+      architecture: 'x64',
+      packageType: 'jdk',
+      checkLatest: false
+    });
+    distribution['getAvailableVersions'] = async () => [];
+    await expect(distribution['findPackageForDownload']('8')).rejects.toThrowError(
+      /Could not find satisfied version for SemVer */
+    );
+  });
+
+  it.each(['x64', 'x86', 'ppc64le', 'ppc64', 's390x', 'aarch64'])(
+    'correct Semeru `%s` architecture resolves',
+    async (arch: string) => {
+      const distribution = new SemeruDistribution({
+        version: '8',
+        architecture: arch,
+        packageType: 'jdk',
+        checkLatest: false
+      });
+      distribution['getAvailableVersions'] = async () => manifestData;
+      const resolvedVersion = await distribution['findPackageForDownload']('8');
+      expect(resolvedVersion.version).not.toBeNull();
+    }
+  );
+
+  it.each(['zos', 'z/OS', 'z/os', 'test0987654321=', '++=++', 'myArch'])(
+    'incorrect Semeru `%s` architecture throws',
+    async (arch: string) => {
+      const distribution = new SemeruDistribution({
+        version: '8',
+        architecture: arch,
+        packageType: 'jdk',
+        checkLatest: false
+      });
+      distribution['getAvailableVersions'] = async () => [];
+      await expect(distribution['findPackageForDownload']('8')).rejects.toThrowError(
+        `Unsupported architecture for IBM Semeru: ${arch}, the following are supported: x64, x86, ppc64le, ppc64, s390x, aarch64`
+      );
+    }
+  );
+
+  it.each(['9-ea', '17-ea', '8-ea', '4-ea'])(
+    'early access version are illegal for Semeru (%s)',
+    async (version: string) => {
+      const distribution = new SemeruDistribution({
+        version: version,
+        architecture: 'x64',
+        packageType: 'jdk',
+        checkLatest: false
+      });
+      distribution['getAvailableVersions'] = async () => manifestData;
+      await expect(distribution['findPackageForDownload'](version)).rejects.toThrowError(
+        'IBM Semeru does not provide builds for early access versions'
+      );
+    }
+  );
+
+  it.each(['jdk+fx', ' jre+fx', 'test', 'test2', 'jdk-fx', 'javafx', 'jdk-javafx', 'ibm'])(
+    'rejects incorrect `%s` Semeru package type',
+    async (packageType: string) => {
+      const distribution = new SemeruDistribution({
+        version: '8',
+        architecture: 'x64',
+        packageType: packageType,
+        checkLatest: false
+      });
+      distribution['getAvailableVersions'] = async () => manifestData;
+      await expect(distribution['findPackageForDownload']('8')).rejects.toThrowError(
+        'IBM Semeru only provide `jdk` and `jre` package types'
+      );
+    }
+  );
+
+  it.each(['jdk', 'jre'])(
+    'accepts correct `%s` Semeru package type',
+    async (packageType: string) => {
+      const distribution = new SemeruDistribution({
+        version: '8',
+        architecture: 'x64',
+        packageType: packageType,
+        checkLatest: false
+      });
+      distribution['getAvailableVersions'] = async () => manifestData;
+      const resolvedVersion = await distribution['findPackageForDownload']('8');
+      await expect(resolvedVersion.version).toMatch(/8[0-9.]+/);
+    }
+  );
+
+  it('fails when long release name is used', async () => {
+    expect(
+      () =>
+        new SemeruDistribution({
+          version: 'jdk-16.0.2+7_openj9-0.27.1',
+          architecture: 'x64',
+          packageType: 'jdk',
+          checkLatest: false
+        })
+    ).toThrowError(
+      "The string 'jdk-16.0.2+7_openj9-0.27.1' is not valid SemVer notation for a Java version. Please check README file for code snippets and more detailed information"
+    );
+  });
+});

dist/setup/index.js

@@ -56140,6 +56140,7 @@ const installer_3 = __webpack_require__(584);
 const installer_4 = __webpack_require__(439);
 const installer_5 = __webpack_require__(507);
 const installer_6 = __webpack_require__(196);
+const installer_7 = __webpack_require__(847);
 var JavaDistribution;
 (function (JavaDistribution) {
     JavaDistribution["Adopt"] = "adopt";
@@ -56150,6 +56151,7 @@ var JavaDistribution;
     JavaDistribution["Liberica"] = "liberica";
     JavaDistribution["JdkFile"] = "jdkfile";
     JavaDistribution["Microsoft"] = "microsoft";
+    JavaDistribution["Semeru"] = "semeru";
 })(JavaDistribution || (JavaDistribution = {}));
 function getJavaDistribution(distributionName, installerOptions, jdkFile) {
     switch (distributionName) {
@@ -56168,6 +56170,8 @@ function getJavaDistribution(distributionName, installerOptions, jdkFile) {
             return new installer_5.LibericaDistributions(installerOptions);
         case JavaDistribution.Microsoft:
             return new installer_6.MicrosoftDistributions(installerOptions);
+        case JavaDistribution.Semeru:
+            return new installer_7.SemeruDistribution(installerOptions);
         default:
             return null;
     }
@@ -88640,7 +88644,185 @@ Object.defineProperty(exports, "__esModule", { value: true });
 
 /***/ }),
 /* 846 */,
-/* 847 */,
+/* 847 */
+/***/ (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.SemeruDistribution = void 0;
+const base_installer_1 = __webpack_require__(83);
+const semver_1 = __importDefault(__webpack_require__(876));
+const util_1 = __webpack_require__(322);
+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));
+class SemeruDistribution extends base_installer_1.JavaBase {
+    constructor(installerOptions) {
+        super('IBM_Semeru', installerOptions);
+    }
+    findPackageForDownload(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.architecture !== 'x64' &&
+                this.architecture !== 'x86' &&
+                this.architecture !== 'ppc64le' &&
+                this.architecture !== 'ppc64' &&
+                this.architecture !== 's390x' &&
+                this.architecture !== 'aarch64') {
+                throw new Error(`Unsupported architecture for IBM Semeru: ${this.architecture}, the following are supported: ` +
+                    'x64, x86, ppc64le, ppc64, s390x, aarch64');
+            }
+            if (!this.stable) {
+                throw new Error('IBM Semeru does not provide builds for early access versions');
+            }
+            if (this.packageType !== 'jdk' && this.packageType !== 'jre') {
+                throw new Error('IBM Semeru only provide `jdk` and `jre` package types');
+            }
+            const availableVersionsRaw = yield this.getAvailableVersions();
+            const availableVersionsWithBinaries = availableVersionsRaw
+                .filter(item => item.binaries.length > 0)
+                .map(item => {
+                // normalize 17.0.0-beta+33.0.202107301459 to 17.0.0+33.0.202107301459 for earlier access versions
+                const formattedVersion = this.stable
+                    ? item.version_data.semver
+                    : item.version_data.semver.replace('-beta+', '+');
+                return {
+                    version: formattedVersion,
+                    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('semeru-retrieve-available-versions');
+            const baseRequestArguments = [
+                `project=jdk`,
+                'vendor=ibm',
+                `heap_size=normal`,
+                'sort_method=DEFAULT',
+                'sort_order=DESC',
+                `os=${platform}`,
+                `architecture=${arch}`,
+                `image_type=${imageType}`,
+                `release_type=${releaseType}`,
+                `jvm_impl=openj9`
+            ].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.adoptopenjdk.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 IBM Semeru versions');
+                console.timeEnd('semeru-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.SemeruDistribution = SemeruDistribution;
+
+
+/***/ }),
 /* 848 */,
 /* 849 */
 /***/ (function(__unusedmodule, exports, __webpack_require__) {

src/distributions/distribution-factory.ts

@@ -6,6 +6,7 @@ import { AdoptDistribution, AdoptImplementation } from './adopt/installer';
 import { TemurinDistribution, TemurinImplementation } from './temurin/installer';
 import { LibericaDistributions } from './liberica/installer';
 import { MicrosoftDistributions } from './microsoft/installer';
+import { SemeruDistribution } from './semeru/installer';
 
 enum JavaDistribution {
   Adopt = 'adopt',
@@ -15,7 +16,8 @@ enum JavaDistribution {
   Zulu = 'zulu',
   Liberica = 'liberica',
   JdkFile = 'jdkfile',
-  Microsoft = 'microsoft'
+  Microsoft = 'microsoft',
+  Semeru = 'semeru'
 }
 
 export function getJavaDistribution(
@@ -39,6 +41,8 @@ export function getJavaDistribution(
       return new LibericaDistributions(installerOptions);
     case JavaDistribution.Microsoft:
       return new MicrosoftDistributions(installerOptions);
+    case JavaDistribution.Semeru:
+      return new SemeruDistribution(installerOptions);
     default:
       return null;
   }

src/distributions/semeru/installer.ts

@@ -0,0 +1,168 @@
+import { JavaBase } from '../base-installer';
+import { JavaDownloadRelease, JavaInstallerOptions, JavaInstallerResults } from '../base-models';
+import semver from 'semver';
+import { extractJdkFile, getDownloadArchiveExtension, isVersionSatisfies } from '../../util';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+import fs from 'fs';
+import path from 'path';
+import { ISemeruAvailableVersions } from './models';
+
+export class SemeruDistribution extends JavaBase {
+  constructor(installerOptions: JavaInstallerOptions) {
+    super('IBM_Semeru', installerOptions);
+  }
+
+  protected async findPackageForDownload(version: string): Promise<JavaDownloadRelease> {
+    if (
+      this.architecture !== 'x64' &&
+      this.architecture !== 'x86' &&
+      this.architecture !== 'ppc64le' &&
+      this.architecture !== 'ppc64' &&
+      this.architecture !== 's390x' &&
+      this.architecture !== 'aarch64'
+    ) {
+      throw new Error(
+        `Unsupported architecture for IBM Semeru: ${this.architecture}, the following are supported: ` +
+          'x64, x86, ppc64le, ppc64, s390x, aarch64'
+      );
+    }
+
+    if (!this.stable) {
+      throw new Error('IBM Semeru does not provide builds for early access versions');
+    }
+
+    if (this.packageType !== 'jdk' && this.packageType !== 'jre') {
+      throw new Error('IBM Semeru only provide `jdk` and `jre` package types');
+    }
+
+    const availableVersionsRaw = await this.getAvailableVersions();
+    const availableVersionsWithBinaries = availableVersionsRaw
+      .filter(item => item.binaries.length > 0)
+      .map(item => {
+        // normalize 17.0.0-beta+33.0.202107301459 to 17.0.0+33.0.202107301459 for earlier access versions
+        const formattedVersion = this.stable
+          ? item.version_data.semver
+          : item.version_data.semver.replace('-beta+', '+');
+        return {
+          version: formattedVersion,
+          url: item.binaries[0].package.link
+        } as JavaDownloadRelease;
+      });
+
+    const satisfiedVersions = availableVersionsWithBinaries
+      .filter(item => isVersionSatisfies(version, item.version))
+      .sort((a, b) => {
+        return -semver.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;
+  }
+
+  protected async downloadTool(javaRelease: JavaDownloadRelease): Promise<JavaInstallerResults> {
+    let javaPath: string;
+    let extractedJavaPath: string;
+
+    core.info(
+      `Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`
+    );
+    const javaArchivePath = await tc.downloadTool(javaRelease.url);
+
+    core.info(`Extracting Java archive...`);
+    let extension = getDownloadArchiveExtension();
+
+    extractedJavaPath = await extractJdkFile(javaArchivePath, extension);
+
+    const archiveName = fs.readdirSync(extractedJavaPath)[0];
+    const archivePath = path.join(extractedJavaPath, archiveName);
+    const version = this.getToolcacheVersionName(javaRelease.version);
+
+    javaPath = await tc.cacheDir(archivePath, this.toolcacheFolderName, version, this.architecture);
+
+    return { version: javaRelease.version, path: javaPath };
+  }
+
+  protected get toolcacheFolderName(): string {
+    return super.toolcacheFolderName;
+  }
+
+  public async getAvailableVersions(): Promise<ISemeruAvailableVersions[]> {
+    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('semeru-retrieve-available-versions');
+
+    const baseRequestArguments = [
+      `project=jdk`,
+      'vendor=ibm',
+      `heap_size=normal`,
+      'sort_method=DEFAULT',
+      'sort_order=DESC',
+      `os=${platform}`,
+      `architecture=${arch}`,
+      `image_type=${imageType}`,
+      `release_type=${releaseType}`,
+      `jvm_impl=openj9`
+    ].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: ISemeruAvailableVersions[] = [];
+    while (true) {
+      const requestArguments = `${baseRequestArguments}&page_size=20&page=${page_index}`;
+      const availableVersionsUrl = `https://api.adoptopenjdk.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 = (
+        await this.http.getJson<ISemeruAvailableVersions[]>(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 IBM Semeru versions');
+      console.timeEnd('semeru-retrieve-available-versions');
+      console.log(`Available versions: [${availableVersions.length}]`);
+      console.log(availableVersions.map(item => item.version_data.semver).join(', '));
+      core.endGroup();
+    }
+
+    return availableVersions;
+  }
+
+  private getPlatformOption(): string {
+    // 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;
+    }
+  }
+}

src/distributions/semeru/models.ts

@@ -0,0 +1,36 @@
+export interface ISemeruAvailableVersions {
+  binaries: [
+    {
+      architecture: string;
+      heap_size: string;
+      image_type: string;
+      jvm_impl: string;
+      os: string;
+      package: {
+        checksum: string;
+        checksum_link: string;
+        download_count: number;
+        link: string;
+        metadata_link: string;
+        name: string;
+        size: string;
+      };
+      project: string;
+      scm_ref: string;
+      updated_at: string;
+    }
+  ];
+  id: string;
+  release_link: string;
+  release_name: string;
+  release_type: string;
+  vendor: string;
+  version_data: {
+    build: number;
+    major: number;
+    minor: number;
+    openjdk_version: string;
+    security: string;
+    semver: string;
+  };
+}