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"
+    );
+  });
+});

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;
+  };
+}