IBM Semeru (OpenJ9) Support (#289)

.github/workflows/e2e-versions.yml

@@ -28,6 +28,7 @@ jobs:
             'zulu',
             'liberica',
             'microsoft',
+            'semeru',
             'corretto'
           ] # internally 'adopt-hotspot' is the same as 'adopt'
         version: ['8', '11', '16']
@@ -199,7 +200,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [macos-latest, windows-latest, ubuntu-latest]
-        distribution: ['temurin', 'zulu', 'liberica']
+        distribution: ['temurin', 'zulu', 'liberica', 'semeru']
         java-package: ['jre']
         version: ['17.0']
         include:

.gitignore

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

README.md

@@ -103,11 +103,12 @@ Currently, the following distributions are supported:
 | `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)
 | `corretto` | Amazon Corretto Build of OpenJDK | [Link](https://aws.amazon.com/corretto/) | [Link](https://aws.amazon.com/corretto/faqs/)
+| `semeru` | IBM Semeru Runtime Open Edition | [Link](https://developer.ibm.com/languages/java/semeru-runtimes/downloads/) | [Link](https://openjdk.java.net/legal/gplv2+ce.html) |
 | `oracle` | Oracle JDK | [Link](https://www.oracle.com/java/technologies/downloads/) | [Link](https://java.com/freeuselicense)
 
 **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:** AdoptOpenJDK 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:** AdoptOpenJDK 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/).
 
 **NOTE:** For Azul Zulu OpenJDK architectures x64 and arm64 are mapped to x86 / arm with proper hw_bitness.
 

__tests__/distributors/semeru-installer.test.ts

@@ -0,0 +1,287 @@
+import {HttpClient} from '@actions/http-client';
+
+import {JavaInstallerOptions} from '../../src/distributions/base-models';
+import {SemeruDistribution} from '../../src/distributions/semeru/installer';
+
+import manifestData from '../data/semeru.json';
+
+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 as any
+      })
+      .mockReturnValueOnce({
+        statusCode: 200,
+        headers: {},
+        result: manifestData as any
+      })
+      .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 as any;
+    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 as any;
+    await expect(
+      distribution['findPackageForDownload']('9.0.8')
+    ).rejects.toThrow(/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 as any;
+    await expect(distribution['findPackageForDownload']('7.x')).rejects.toThrow(
+      /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.toThrow(
+      /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 as any;
+      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.toThrow(
+        `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 as any;
+      await expect(
+        distribution['findPackageForDownload'](version)
+      ).rejects.toThrow(
+        '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 as any;
+      await expect(distribution['findPackageForDownload']('8')).rejects.toThrow(
+        '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 as any;
+      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
+        })
+    ).toThrow(
+      "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

@@ -104316,8 +104316,9 @@ const installer_3 = __nccwpck_require__(8766);
 const installer_4 = __nccwpck_require__(8579);
 const installer_5 = __nccwpck_require__(883);
 const installer_6 = __nccwpck_require__(3613);
-const installer_7 = __nccwpck_require__(4750);
+const installer_7 = __nccwpck_require__(1121);
-const installer_8 = __nccwpck_require__(4298);
+const installer_8 = __nccwpck_require__(4750);
+const installer_9 = __nccwpck_require__(4298);
 var JavaDistribution;
 (function (JavaDistribution) {
     JavaDistribution["Adopt"] = "adopt";
@@ -104328,6 +104329,7 @@ var JavaDistribution;
     JavaDistribution["Liberica"] = "liberica";
     JavaDistribution["JdkFile"] = "jdkfile";
     JavaDistribution["Microsoft"] = "microsoft";
+    JavaDistribution["Semeru"] = "semeru";
     JavaDistribution["Corretto"] = "corretto";
     JavaDistribution["Oracle"] = "oracle";
 })(JavaDistribution || (JavaDistribution = {}));
@@ -104348,10 +104350,12 @@ 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);
         case JavaDistribution.Corretto:
-            return new installer_7.CorrettoDistribution(installerOptions);
+            return new installer_8.CorrettoDistribution(installerOptions);
         case JavaDistribution.Oracle:
-            return new installer_8.OracleDistribution(installerOptions);
+            return new installer_9.OracleDistribution(installerOptions);
         default:
             return null;
     }
@@ -104893,6 +104897,190 @@ class OracleDistribution extends base_installer_1.JavaBase {
 exports.OracleDistribution = OracleDistribution;
 
 
+/***/ }),
+
+/***/ 1121:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_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 = __nccwpck_require__(9741);
+const semver_1 = __importDefault(__nccwpck_require__(1383));
+const util_1 = __nccwpck_require__(2629);
+const core = __importStar(__nccwpck_require__(2186));
+const tc = __importStar(__nccwpck_require__(7784));
+const fs_1 = __importDefault(__nccwpck_require__(7147));
+const path_1 = __importDefault(__nccwpck_require__(1017));
+const supportedArchitectures = [
+    'x64',
+    'x86',
+    'ppc64le',
+    'ppc64',
+    's390x',
+    'aarch64'
+];
+class SemeruDistribution extends base_installer_1.JavaBase {
+    constructor(installerOptions) {
+        super('IBM_Semeru', installerOptions);
+    }
+    findPackageForDownload(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!supportedArchitectures.includes(this.architecture)) {
+                throw new Error(`Unsupported architecture for IBM Semeru: ${this.architecture}, the following are supported: ${supportedArchitectures.join(', ')}`);
+            }
+            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* () {
+            core.info(`Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`);
+            const javaArchivePath = yield tc.downloadTool(javaRelease.url);
+            core.info(`Extracting Java archive...`);
+            const extension = util_1.getDownloadArchiveExtension();
+            const 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);
+            const 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';
+            if (core.isDebug()) {
+                console.time('Retrieving available versions for Semeru took'); // eslint-disable-line no-console
+            }
+            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 versions');
+                console.timeEnd('Retrieving available versions for Semeru took'); // eslint-disable-line no-console
+                core.debug(`Available versions: [${availableVersions.length}]`);
+                core.debug(availableVersions.map(item => item.version_data.semver).join(', '));
+                core.endGroup();
+            }
+            return availableVersions;
+        });
+    }
+    getPlatformOption() {
+        // Adopt 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;
+
+
 /***/ }),
 
 /***/ 8579:

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';
 import {CorrettoDistribution} from './corretto/installer';
 import {OracleDistribution} from './oracle/installer';
 
@@ -18,6 +19,7 @@ enum JavaDistribution {
   Liberica = 'liberica',
   JdkFile = 'jdkfile',
   Microsoft = 'microsoft',
+  Semeru = 'semeru',
   Corretto = 'corretto',
   Oracle = 'oracle'
 }
@@ -52,6 +54,8 @@ export function getJavaDistribution(
       return new LibericaDistributions(installerOptions);
     case JavaDistribution.Microsoft:
       return new MicrosoftDistributions(installerOptions);
+    case JavaDistribution.Semeru:
+      return new SemeruDistribution(installerOptions);
     case JavaDistribution.Corretto:
       return new CorrettoDistribution(installerOptions);
     case JavaDistribution.Oracle:

src/distributions/semeru/installer.ts

@@ -0,0 +1,201 @@
+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';
+
+const supportedArchitectures = [
+  'x64',
+  'x86',
+  'ppc64le',
+  'ppc64',
+  's390x',
+  'aarch64'
+];
+
+export class SemeruDistribution extends JavaBase {
+  constructor(installerOptions: JavaInstallerOptions) {
+    super('IBM_Semeru', installerOptions);
+  }
+
+  protected async findPackageForDownload(
+    version: string
+  ): Promise<JavaDownloadRelease> {
+    if (!supportedArchitectures.includes(this.architecture)) {
+      throw new Error(
+        `Unsupported architecture for IBM Semeru: ${
+          this.architecture
+        }, the following are supported: ${supportedArchitectures.join(', ')}`
+      );
+    }
+
+    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> {
+    core.info(
+      `Downloading Java ${javaRelease.version} (${this.distribution}) from ${javaRelease.url} ...`
+    );
+    const javaArchivePath = await tc.downloadTool(javaRelease.url);
+
+    core.info(`Extracting Java archive...`);
+    const extension = getDownloadArchiveExtension();
+
+    const extractedJavaPath: string = await extractJdkFile(
+      javaArchivePath,
+      extension
+    );
+
+    const archiveName = fs.readdirSync(extractedJavaPath)[0];
+    const archivePath = path.join(extractedJavaPath, archiveName);
+    const version = this.getToolcacheVersionName(javaRelease.version);
+
+    const javaPath: string = 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';
+
+    if (core.isDebug()) {
+      console.time('Retrieving available versions for Semeru took'); // eslint-disable-line no-console
+    }
+
+    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 versions');
+      console.timeEnd('Retrieving available versions for Semeru took'); // eslint-disable-line no-console
+      core.debug(`Available versions: [${availableVersions.length}]`);
+      core.debug(
+        availableVersions.map(item => item.version_data.semver).join(', ')
+      );
+      core.endGroup();
+    }
+
+    return availableVersions;
+  }
+
+  private getPlatformOption(): string {
+    // Adopt 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;
+  };
+}