Default to runner architecture (#376)

__tests__/distributors/adopt-installer.test.ts

@@ -3,6 +3,8 @@ import { HttpClient } from '@actions/http-client';
 import { AdoptDistribution, AdoptImplementation } from '../../src/distributions/adopt/installer';
 import { JavaInstallerOptions } from '../../src/distributions/base-models';
 
+import os from 'os';
+
 let manifestData = require('../data/adopt.json') as [];
 
 describe('getAvailableVersions', () => {
@@ -128,6 +130,35 @@ describe('getAvailableVersions', () => {
       expect(distribution.toolcacheFolderName).toBe(expected);
     }
   );
+
+  it.each([
+    ['amd64', 'x64'],
+    ['arm64', 'aarch64']
+  ])(
+    'defaults to os.arch(): %s mapped to distro arch: %s',
+    async (osArch: string, distroArch: string) => {
+      jest.spyOn(os, 'arch').mockReturnValue(osArch);
+
+      const installerOptions: JavaInstallerOptions = {
+        version: '17',
+        architecture: '', // to get default value
+        packageType: 'jdk',
+        checkLatest: false
+      };
+
+      const expectedParameters = `os=mac&architecture=${distroArch}&image_type=jdk&release_type=ga&jvm_impl=hotspot&page_size=20&page=0`;
+
+      const distribution = new AdoptDistribution(installerOptions, AdoptImplementation.Hotspot);
+      const baseUrl = 'https://api.adoptopenjdk.net/v3/assets/version/%5B1.0,100.0%5D';
+      const expectedUrl = `${baseUrl}?project=jdk&vendor=adoptopenjdk&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);
+    }
+  );
 });
 
 describe('findPackageForDownload', () => {

__tests__/distributors/base-installer.test.ts

@@ -12,6 +12,8 @@ import {
   JavaInstallerResults
 } from '../../src/distributions/base-models';
 
+import os from 'os';
+
 class EmptyJavaBase extends JavaBase {
   constructor(installerOptions: JavaInstallerOptions) {
     super('Empty', installerOptions);
@@ -192,6 +194,8 @@ describe('setupJava', () => {
 
     spyCoreSetOutput = jest.spyOn(core, 'setOutput');
     spyCoreSetOutput.mockImplementation(() => undefined);
+
+    jest.spyOn(os, 'arch').mockReturnValue('x86');
   });
 
   afterEach(() => {
@@ -212,6 +216,10 @@ describe('setupJava', () => {
     [
       { version: '11.0.8', architecture: 'x86', packageType: 'jdk', checkLatest: false },
       { version: installedJavaVersion, path: javaPath }
+    ],
+    [
+      { version: '11', architecture: '', packageType: 'jdk', checkLatest: false },
+      { version: installedJavaVersion, path: javaPath }
     ]
   ])('should find java locally for %s', (input, expected) => {
     mockJavaBase = new EmptyJavaBase(input);
@@ -237,6 +245,10 @@ describe('setupJava', () => {
     [
       { version: '11', architecture: 'x64', packageType: 'jre', checkLatest: false },
       { path: path.join('toolcache', 'Java_Empty_jre', '11.0.9', 'x64'), version: '11.0.9' }
+    ],
+    [
+      { version: '11', architecture: '', packageType: 'jre', checkLatest: false },
+      { path: path.join('toolcache', 'Java_Empty_jre', '11.0.9', 'x86'), version: '11.0.9' }
     ]
   ])('download java with configuration %s', async (input, expected) => {
     mockJavaBase = new EmptyJavaBase(input);
@@ -245,7 +257,7 @@ describe('setupJava', () => {
     expect(spyCoreAddPath).toHaveBeenCalled();
     expect(spyCoreExportVariable).toHaveBeenCalled();
     expect(spyCoreExportVariable).toHaveBeenCalledWith(
-      `JAVA_HOME_${input.version}_${input.architecture.toLocaleUpperCase()}`,
+      `JAVA_HOME_${input.version}_${(input.architecture || 'x86').toLocaleUpperCase()}`,
       expected.path
     );
     expect(spyCoreSetOutput).toHaveBeenCalled();
@@ -260,6 +272,10 @@ describe('setupJava', () => {
     [
       { version: '11.0.9', architecture: 'x86', packageType: 'jdk', checkLatest: true },
       { version: '11.0.9', path: javaPathInstalled }
+    ],
+    [
+      { version: '11.0.9', architecture: '', packageType: 'jdk', checkLatest: true },
+      { version: '11.0.9', path: javaPathInstalled }
     ]
   ])('should check the latest java version for %s and resolve locally', async (input, expected) => {
     mockJavaBase = new EmptyJavaBase(input);
@@ -283,6 +299,10 @@ describe('setupJava', () => {
     [
       { version: '11.0.x', architecture: 'x86', packageType: 'jdk', checkLatest: true },
       { version: actualJavaVersion, path: javaPathInstalled }
+    ],
+    [
+      { version: '11', architecture: '', packageType: 'jdk', checkLatest: true },
+      { version: actualJavaVersion, path: javaPathInstalled }
     ]
   ])('should check the latest java version for %s and download', async (input, expected) => {
     mockJavaBase = new EmptyJavaBase(input);

__tests__/distributors/corretto-installer.test.ts

@@ -3,6 +3,8 @@ import { JavaInstallerOptions } from '../../src/distributions/base-models';
 
 import { CorrettoDistribution } from '../../src/distributions/corretto/installer';
 import * as util from '../../src/util';
+import os from 'os';
+import { isGeneratorFunction } from 'util/types';
 
 const manifestData = require('../data/corretto.json') as [];
 
@@ -142,6 +144,33 @@ describe('getAvailableVersions', () => {
         "Could not find satisfied version for SemVer '4'"
       );
     });
+
+    it.each([
+      ['arm64', 'aarch64'],
+      ['amd64', 'x64']
+    ])(
+      'defaults to os.arch(): %s mapped to distro arch: %s',
+      async (osArch: string, distroArch: string) => {
+        jest.spyOn(os, 'arch').mockReturnValue(osArch);
+
+        const version = '17';
+        const installerOptions: JavaInstallerOptions = {
+          version,
+          architecture: '', // to get default value
+          packageType: 'jdk',
+          checkLatest: false
+        };
+
+        const distribution = new CorrettoDistribution(installerOptions);
+        mockPlatform(distribution, 'macos');
+
+        const expectedLink = `https://corretto.aws/downloads/resources/17.0.2.8.1/amazon-corretto-17.0.2.8.1-macosx-${distroArch}.tar.gz`;
+
+        const availableVersion = await distribution['findPackageForDownload'](version);
+        expect(availableVersion).not.toBeNull();
+        expect(availableVersion.url).toBe(expectedLink);
+      }
+    );
   });
 
   const mockPlatform = (distribution: CorrettoDistribution, platform: string) => {

__tests__/distributors/liberica-installer.test.ts

@@ -1,6 +1,7 @@
 import { LibericaDistributions } from '../../src/distributions/liberica/installer';
 import { ArchitectureOptions, LibericaVersion } from '../../src/distributions/liberica/models';
 import { HttpClient } from '@actions/http-client';
+import os from 'os';
 
 const manifestData = require('../data/liberica.json') as LibericaVersion[];
 
@@ -61,6 +62,39 @@ describe('getAvailableVersions', () => {
     expect(spyHttpClient.mock.calls[0][0]).toBe(buildUrl);
   });
 
+  type DistroArch = {
+    bitness: string;
+    arch: string;
+  };
+  it.each([
+    ['amd64', { bitness: '64', arch: 'x86' }],
+    ['arm64', { bitness: '64', arch: 'arm' }]
+  ])(
+    'defaults to os.arch(): %s mapped to distro arch: %s',
+    async (osArch: string, distroArch: DistroArch) => {
+      jest.spyOn(os, 'arch').mockReturnValue(osArch);
+
+      const distribution = new LibericaDistributions({
+        version: '17',
+        architecture: '', // to get default value
+        packageType: 'jdk',
+        checkLatest: false
+      });
+
+      const additionalParams =
+        '&installation-type=archive&fields=downloadUrl%2Cversion%2CfeatureVersion%2CinterimVersion%2C' +
+        'updateVersion%2CbuildVersion';
+      distribution['getPlatformOption'] = () => 'macos';
+
+      const buildUrl = `https://api.bell-sw.com/v1/liberica/releases?os=macos&bundle-type=jdk&bitness=${distroArch.bitness}&arch=${distroArch.arch}&build-type=all${additionalParams}`;
+
+      await distribution['getAvailableVersions']();
+
+      expect(spyHttpClient.mock.calls).toHaveLength(1);
+      expect(spyHttpClient.mock.calls[0][0]).toBe(buildUrl);
+    }
+  );
+
   it('load available versions', async () => {
     const distribution = new LibericaDistributions({
       version: '11',

__tests__/distributors/microsoft-installer.test.ts

@@ -1,5 +1,5 @@
 import { MicrosoftDistributions } from '../../src/distributions/microsoft/installer';
-import * as tc from '@actions/tool-cache';
+import os from 'os';
 import data from '../../src/distributions/microsoft/microsoft-openjdk-versions.json';
 import * as httpm from '@actions/http-client';
 import * as core from '@actions/core';
@@ -77,6 +77,30 @@ describe('findPackageForDownload', () => {
     expect(result.url).toBe(url);
   });
 
+  it.each([
+    ['amd64', 'x64'],
+    ['arm64', 'aarch64']
+  ])(
+    'defaults to os.arch(): %s mapped to distro arch: %s',
+    async (osArch: string, distroArch: string) => {
+      jest.spyOn(os, 'arch').mockReturnValue(osArch);
+      jest.spyOn(os, 'platform').mockReturnValue('linux');
+
+      const version = '17';
+      const distro = new MicrosoftDistributions({
+        version,
+        architecture: '', // to get default value
+        packageType: 'jdk',
+        checkLatest: false
+      });
+
+      const result = await distro['findPackageForDownload'](version);
+      const expectedUrl = `https://aka.ms/download-jdk/microsoft-jdk-17.0.3-linux-${distroArch}.tar.gz`;
+
+      expect(result.url).toBe(expectedUrl);
+    }
+  );
+
   it('should throw an error', async () => {
     await expect(distribution['findPackageForDownload']('8')).rejects.toThrow(
       /Could not find satisfied version for SemVer */

__tests__/distributors/temurin-installer.test.ts

@@ -1,5 +1,5 @@
 import { HttpClient } from '@actions/http-client';
-
+import os from 'os';
 import {
   TemurinDistribution,
   TemurinImplementation
@@ -109,6 +109,35 @@ describe('getAvailableVersions', () => {
       expect(distribution.toolcacheFolderName).toBe(expected);
     }
   );
+
+  it.each([
+    ['amd64', 'x64'],
+    ['arm64', 'aarch64']
+  ])(
+    'defaults to os.arch(): %s mapped to distro arch: %s',
+    async (osArch: string, distroArch: string) => {
+      jest.spyOn(os, 'arch').mockReturnValue(distroArch);
+
+      const installerOptions: JavaInstallerOptions = {
+        version: '17',
+        architecture: '',
+        packageType: 'jdk',
+        checkLatest: false
+      };
+
+      const expectedParameters = `os=mac&architecture=${distroArch}&image_type=jdk&release_type=ga&jvm_impl=hotspot&page_size=20&page=0`;
+
+      const distribution = new TemurinDistribution(installerOptions, TemurinImplementation.Hotspot);
+      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';
+
+      await distribution['getAvailableVersions']();
+
+      expect(spyHttpClient.mock.calls).toHaveLength(1);
+      expect(spyHttpClient.mock.calls[0][0]).toBe(expectedUrl);
+    }
+  );
 });
 
 describe('findPackageForDownload', () => {

__tests__/distributors/zulu-installer.test.ts

@@ -3,6 +3,7 @@ import * as semver from 'semver';
 import { ZuluDistribution } from '../../src/distributions/zulu/installer';
 import { IZuluVersions } from '../../src/distributions/zulu/models';
 import * as utils from '../../src/util';
+import os from 'os';
 
 const manifestData = require('../data/zulu-releases-default.json') as [];
 
@@ -72,6 +73,34 @@ describe('getAvailableVersions', () => {
     expect(spyHttpClient.mock.calls[0][0]).toBe(buildUrl);
   });
 
+  type DistroArch = {
+    bitness: string;
+    arch: string;
+  };
+  it.each([
+    ['amd64', { bitness: '64', arch: 'x86' }],
+    ['arm64', { bitness: '64', arch: 'arm' }]
+  ])(
+    'defaults to os.arch(): %s mapped to distro arch: %s',
+    async (osArch: string, distroArch: DistroArch) => {
+      jest.spyOn(os, 'arch').mockReturnValue(osArch);
+
+      const distribution = new ZuluDistribution({
+        version: '17',
+        architecture: '', // to get default value
+        packageType: 'jdk',
+        checkLatest: false
+      });
+      distribution['getPlatformOption'] = () => 'macos';
+      const buildUrl = `https://api.azul.com/zulu/download/community/v1.0/bundles/?os=macos&ext=tar.gz&bundle_type=jdk&javafx=false&arch=${distroArch.arch}&hw_bitness=${distroArch.bitness}&release_status=ga`;
+
+      await distribution['getAvailableVersions']();
+
+      expect(spyHttpClient.mock.calls).toHaveLength(1);
+      expect(spyHttpClient.mock.calls[0][0]).toBe(buildUrl);
+    }
+  );
+
   it('load available versions', async () => {
     const distribution = new ZuluDistribution({
       version: '11',

action.yml

@@ -14,9 +14,8 @@ inputs:
     required: false
     default: 'jdk'
   architecture:
-    description: 'The architecture of the package'
+    description: "The architecture of the package (defaults to the action runner's architecture)"
     required: false
-    default: 'x64'
   jdkFile:
     description: 'Path to where the compressed JDK is located'
     required: false

dist/setup/index.js

@@ -103661,7 +103661,7 @@ class AdoptDistribution extends base_installer_1.JavaBase {
     getAvailableVersions() {
         return __awaiter(this, void 0, void 0, function* () {
             const platform = this.getPlatformOption();
-            const arch = this.architecture;
+            const arch = this.distributionArchitecture();
             const imageType = this.packageType;
             const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions
             const releaseType = this.stable ? 'ga' : 'ea';
@@ -103772,6 +103772,7 @@ const path_1 = __importDefault(__nccwpck_require__(1017));
 const httpm = __importStar(__nccwpck_require__(9925));
 const util_1 = __nccwpck_require__(2629);
 const constants_1 = __nccwpck_require__(9042);
+const os_1 = __importDefault(__nccwpck_require__(2037));
 class JavaBase {
     constructor(distribution, installerOptions) {
         this.distribution = distribution;
@@ -103780,7 +103781,7 @@ class JavaBase {
             maxRetries: 3
         });
         ({ version: this.version, stable: this.stable } = this.normalizeVersion(installerOptions.version));
-        this.architecture = installerOptions.architecture;
+        this.architecture = installerOptions.architecture || os_1.default.arch();
         this.packageType = installerOptions.packageType;
         this.checkLatest = installerOptions.checkLatest;
     }
@@ -103891,6 +103892,24 @@ class JavaBase {
         core.setOutput('version', version);
         core.exportVariable(`JAVA_HOME_${majorVersion}_${this.architecture.toUpperCase()}`, toolPath);
     }
+    distributionArchitecture() {
+        // default mappings of config architectures to distribution architectures
+        // override if a distribution uses any different names; see liberica for an example
+        // node's os.arch() - which this defaults to - can return any of:
+        // 'arm', 'arm64', 'ia32', 'mips', 'mipsel', 'ppc', 'ppc64', 's390', 's390x', and 'x64'
+        // so we need to map these to java distribution architectures
+        // 'amd64' is included here too b/c it's a common alias for 'x64' people might use explicitly
+        switch (this.architecture) {
+            case 'amd64':
+                return 'x64';
+            case 'ia32':
+                return 'x86';
+            case 'arm64':
+                return 'aarch64';
+            default:
+                return this.architecture;
+        }
+    }
 }
 exports.JavaBase = JavaBase;
 
@@ -103990,7 +104009,7 @@ class CorrettoDistribution extends base_installer_1.JavaBase {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const platform = this.getPlatformOption();
-            const arch = this.architecture;
+            const arch = this.distributionArchitecture();
             const imageType = this.packageType;
             if (core.isDebug()) {
                 console.time('corretto-retrieve-available-versions');
@@ -104165,7 +104184,7 @@ const tc = __importStar(__nccwpck_require__(7784));
 const fs_1 = __importDefault(__nccwpck_require__(7147));
 const path_1 = __importDefault(__nccwpck_require__(1017));
 const supportedPlatform = `'linux', 'linux-musl', 'macos', 'solaris', 'windows'`;
-const supportedArchitecture = `'x86', 'x64', 'armv7', 'aarch64', 'ppc64le'`;
+const supportedArchitectures = `'x86', 'x64', 'armv7', 'aarch64', 'ppc64le'`;
 class LibericaDistributions extends base_installer_1.JavaBase {
     constructor(installerOptions) {
         super('Liberica', installerOptions);
@@ -104237,7 +104256,8 @@ class LibericaDistributions extends base_installer_1.JavaBase {
         return bundleType;
     }
     getArchitectureOptions() {
-        switch (this.architecture) {
+        const arch = this.distributionArchitecture();
+        switch (arch) {
             case 'x86':
                 return { bitness: '32', arch: 'x86' };
             case 'x64':
@@ -104249,7 +104269,7 @@ class LibericaDistributions extends base_installer_1.JavaBase {
             case 'ppc64le':
                 return { bitness: '64', arch: 'ppc' };
             default:
-                throw new Error(`Architecture '${this.architecture}' is not supported. Supported architectures: ${supportedArchitecture}`);
+                throw new Error(`Architecture '${this.architecture}' is not supported. Supported architectures: ${supportedArchitectures}`);
         }
     }
     getPlatformOption(platform = process.platform) {
@@ -104275,6 +104295,15 @@ class LibericaDistributions extends base_installer_1.JavaBase {
         }
         return mainVersion;
     }
+    distributionArchitecture() {
+        let arch = super.distributionArchitecture();
+        switch (arch) {
+            case 'arm':
+                return 'armv7';
+            default:
+                return arch;
+        }
+    }
 }
 exports.LibericaDistributions = LibericaDistributions;
 
@@ -104447,7 +104476,8 @@ class MicrosoftDistributions extends base_installer_1.JavaBase {
     }
     findPackageForDownload(range) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.architecture !== 'x64' && this.architecture !== 'aarch64') {
+            const arch = this.distributionArchitecture();
+            if (arch !== 'x64' && arch !== 'aarch64') {
                 throw new Error(`Unsupported architecture: ${this.architecture}`);
             }
             if (!this.stable) {
@@ -104460,7 +104490,7 @@ class MicrosoftDistributions extends base_installer_1.JavaBase {
             if (!manifest) {
                 throw new Error('Could not load manifest for Microsoft Build of OpenJDK');
             }
-            const foundRelease = yield tc.findFromManifest(range, true, manifest, this.architecture);
+            const foundRelease = yield tc.findFromManifest(range, true, manifest, arch);
             if (!foundRelease) {
                 throw new Error(`Could not find satisfied version for SemVer ${range}. ${manifest
                     .map(item => item.version)
@@ -104614,7 +104644,7 @@ class TemurinDistribution extends base_installer_1.JavaBase {
     getAvailableVersions() {
         return __awaiter(this, void 0, void 0, function* () {
             const platform = this.getPlatformOption();
-            const arch = this.architecture;
+            const arch = this.distributionArchitecture();
             const imageType = this.packageType;
             const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions
             const releaseType = this.stable ? 'ga' : 'ea';
@@ -104818,17 +104848,17 @@ class ZuluDistribution extends base_installer_1.JavaBase {
         });
     }
     getArchitectureOptions() {
-        if (this.architecture == 'x64') {
+        const arch = this.distributionArchitecture();
-            return { arch: 'x86', hw_bitness: '64', abi: '' };
+        switch (arch) {
-        }
+            case 'x64':
-        else if (this.architecture == 'x86') {
+                return { arch: 'x86', hw_bitness: '64', abi: '' };
-            return { arch: 'x86', hw_bitness: '32', abi: '' };
+            case 'x86':
-        }
+                return { arch: 'x86', hw_bitness: '32', abi: '' };
-        else if (this.architecture == 'arm64') {
+            case 'aarch64':
-            return { arch: 'arm', hw_bitness: '64', abi: '' };
+            case 'arm64':
-        }
+                return { arch: 'arm', hw_bitness: '64', abi: '' };
-        else {
+            default:
-            return { arch: this.architecture, hw_bitness: '', abi: '' };
+                return { arch: arch, hw_bitness: '', abi: '' };
         }
     }
     getPlatformOption() {

src/distributions/adopt/installer.ts

@@ -88,7 +88,7 @@ export class AdoptDistribution extends JavaBase {
 
   private async getAvailableVersions(): Promise<IAdoptAvailableVersions[]> {
     const platform = this.getPlatformOption();
-    const arch = this.architecture;
+    const arch = this.distributionArchitecture();
     const imageType = this.packageType;
     const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions
     const releaseType = this.stable ? 'ga' : 'ea';

src/distributions/base-installer.ts

@@ -7,6 +7,7 @@ import * as httpm from '@actions/http-client';
 import { getToolcachePath, isVersionSatisfies } from '../util';
 import { JavaDownloadRelease, JavaInstallerOptions, JavaInstallerResults } from './base-models';
 import { MACOS_JAVA_CONTENT_POSTFIX } from '../constants';
+import os from 'os';
 
 export abstract class JavaBase {
   protected http: httpm.HttpClient;
@@ -25,7 +26,7 @@ export abstract class JavaBase {
     ({ version: this.version, stable: this.stable } = this.normalizeVersion(
       installerOptions.version
     ));
-    this.architecture = installerOptions.architecture;
+    this.architecture = installerOptions.architecture || os.arch();
     this.packageType = installerOptions.packageType;
     this.checkLatest = installerOptions.checkLatest;
   }
@@ -150,4 +151,24 @@ export abstract class JavaBase {
     core.setOutput('version', version);
     core.exportVariable(`JAVA_HOME_${majorVersion}_${this.architecture.toUpperCase()}`, toolPath);
   }
+
+  protected distributionArchitecture(): string {
+    // default mappings of config architectures to distribution architectures
+    // override if a distribution uses any different names; see liberica for an example
+
+    // node's os.arch() - which this defaults to - can return any of:
+    // 'arm', 'arm64', 'ia32', 'mips', 'mipsel', 'ppc', 'ppc64', 's390', 's390x', and 'x64'
+    // so we need to map these to java distribution architectures
+    // 'amd64' is included here too b/c it's a common alias for 'x64' people might use explicitly
+    switch (this.architecture) {
+      case 'amd64':
+        return 'x64';
+      case 'ia32':
+        return 'x86';
+      case 'arm64':
+        return 'aarch64';
+      default:
+        return this.architecture;
+    }
+  }
 }

src/distributions/corretto/installer.ts

@@ -68,7 +68,7 @@ export class CorrettoDistribution extends JavaBase {
 
   private async getAvailableVersions(): Promise<ICorrettoAvailableVersions[]> {
     const platform = this.getPlatformOption();
-    const arch = this.architecture;
+    const arch = this.distributionArchitecture();
     const imageType = this.packageType;
 
     if (core.isDebug()) {

src/distributions/liberica/installer.ts

@@ -10,7 +10,7 @@ import path from 'path';
 
 const supportedPlatform = `'linux', 'linux-musl', 'macos', 'solaris', 'windows'`;
 
-const supportedArchitecture = `'x86', 'x64', 'armv7', 'aarch64', 'ppc64le'`;
+const supportedArchitectures = `'x86', 'x64', 'armv7', 'aarch64', 'ppc64le'`;
 
 export class LibericaDistributions extends JavaBase {
   constructor(installerOptions: JavaInstallerOptions) {
@@ -112,7 +112,8 @@ export class LibericaDistributions extends JavaBase {
   }
 
   private getArchitectureOptions(): ArchitectureOptions {
-    switch (this.architecture) {
+    const arch = this.distributionArchitecture();
+    switch (arch) {
       case 'x86':
         return { bitness: '32', arch: 'x86' };
       case 'x64':
@@ -125,7 +126,7 @@ export class LibericaDistributions extends JavaBase {
         return { bitness: '64', arch: 'ppc' };
       default:
         throw new Error(
-          `Architecture '${this.architecture}' is not supported. Supported architectures: ${supportedArchitecture}`
+          `Architecture '${this.architecture}' is not supported. Supported architectures: ${supportedArchitectures}`
         );
     }
   }
@@ -156,4 +157,14 @@ export class LibericaDistributions extends JavaBase {
     }
     return mainVersion;
   }
+
+  protected distributionArchitecture(): string {
+    let arch = super.distributionArchitecture();
+    switch (arch) {
+      case 'arm':
+        return 'armv7';
+      default:
+        return arch;
+    }
+  }
 }

src/distributions/microsoft/installer.ts

@@ -37,7 +37,8 @@ export class MicrosoftDistributions extends JavaBase {
   }
 
   protected async findPackageForDownload(range: string): Promise<JavaDownloadRelease> {
-    if (this.architecture !== 'x64' && this.architecture !== 'aarch64') {
+    const arch = this.distributionArchitecture();
+    if (arch !== 'x64' && arch !== 'aarch64') {
       throw new Error(`Unsupported architecture: ${this.architecture}`);
     }
 
@@ -55,7 +56,7 @@ export class MicrosoftDistributions extends JavaBase {
       throw new Error('Could not load manifest for Microsoft Build of OpenJDK');
     }
 
-    const foundRelease = await tc.findFromManifest(range, true, manifest, this.architecture);
+    const foundRelease = await tc.findFromManifest(range, true, manifest, arch);
 
     if (!foundRelease) {
       throw new Error(

src/distributions/temurin/installer.ts

@@ -86,7 +86,7 @@ export class TemurinDistribution extends JavaBase {
 
   private async getAvailableVersions(): Promise<ITemurinAvailableVersions[]> {
     const platform = this.getPlatformOption();
-    const arch = this.architecture;
+    const arch = this.distributionArchitecture();
     const imageType = this.packageType;
     const versionRange = encodeURI('[1.0,100.0]'); // retrieve all available versions
     const releaseType = this.stable ? 'ga' : 'ea';

src/distributions/zulu/installer.ts

@@ -131,14 +131,17 @@ export class ZuluDistribution extends JavaBase {
     hw_bitness: string;
     abi: string;
   } {
-    if (this.architecture == 'x64') {
+    const arch = this.distributionArchitecture();
-      return { arch: 'x86', hw_bitness: '64', abi: '' };
+    switch (arch) {
-    } else if (this.architecture == 'x86') {
+      case 'x64':
-      return { arch: 'x86', hw_bitness: '32', abi: '' };
+        return { arch: 'x86', hw_bitness: '64', abi: '' };
-    } else if (this.architecture == 'arm64') {
+      case 'x86':
-      return { arch: 'arm', hw_bitness: '64', abi: '' };
+        return { arch: 'x86', hw_bitness: '32', abi: '' };
-    } else {
+      case 'aarch64':
-      return { arch: this.architecture, hw_bitness: '', abi: '' };
+      case 'arm64':
+        return { arch: 'arm', hw_bitness: '64', abi: '' };
+      default:
+        return { arch: arch, hw_bitness: '', abi: '' };
     }
   }