feat(cli): convert java installer

src/cli/install-tool/index.ts

@@ -8,6 +8,11 @@
 import { InstallFlutterService } from '../tools/flutter';
 import { InstallFluxService } from '../tools/flux';
 import { InstallGleamService } from '../tools/gleam';
+import {
+  InstallJavaJdkService,
+  InstallJavaJreService,
+  InstallJavaService,
+} from '../tools/java';
 import { InstallMavenService } from '../tools/java/maven';
 import { InstallNodeService } from '../tools/node';
 import {
@@ -49,6 +54,9 @@
   container.bind(INSTALL_TOOL_TOKEN).to(InstallDotnetService);
   container.bind(INSTALL_TOOL_TOKEN).to(InstallFlutterService);
   container.bind(INSTALL_TOOL_TOKEN).to(InstallFluxService);
+  container.bind(INSTALL_TOOL_TOKEN).to(InstallJavaService);
+  container.bind(INSTALL_TOOL_TOKEN).to(InstallJavaJreService);
+  container.bind(INSTALL_TOOL_TOKEN).to(InstallJavaJdkService);
   container.bind(INSTALL_TOOL_TOKEN).to(InstallMavenService);
   container.bind(INSTALL_TOOL_TOKEN).to(InstallNodeService);
   container.bind(INSTALL_TOOL_TOKEN).to(InstallRenovateService);

src/cli/prepare-tool/index.ts

@@ -4,6 +4,11 @@
 import { PrepareDockerService } from '../tools/docker';
 import { PrepareDotnetService } from '../tools/dotnet';
 import { PrepareFlutterService } from '../tools/flutter';
+import {
+  PrepareJavaJdkService,
+  PrepareJavaJreService,
+  PrepareJavaService,
+} from '../tools/java';
 import { logger } from '../utils';
 import { PrepareLegacyToolsService } from './prepare-legacy-tools.service';
 import { PREPARE_TOOL_TOKEN, PrepareToolService } from './prepare-tool.service';
@@ -22,6 +27,9 @@
   container.bind(PREPARE_TOOL_TOKEN).to(PrepareDotnetService);
   container.bind(PREPARE_TOOL_TOKEN).to(PrepareDockerService);
   container.bind(PREPARE_TOOL_TOKEN).to(PrepareFlutterService);
+  container.bind(PREPARE_TOOL_TOKEN).to(PrepareJavaService);
+  container.bind(PREPARE_TOOL_TOKEN).to(PrepareJavaJreService);
+  container.bind(PREPARE_TOOL_TOKEN).to(PrepareJavaJdkService);
 
   logger.trace('preparing container done');
   return container;

src/cli/tools/java/index.ts

@@ -0,0 +1,186 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execa } from 'execa';
+import { inject, injectable } from 'inversify';
+import semver from 'semver';
+import { InstallToolBaseService } from '../../install-tool/install-tool-base.service';
+import { PrepareToolBaseService } from '../../prepare-tool/prepare-tool-base.service';
+import {
+  CompressionService,
+  EnvService,
+  HttpService,
+  PathService,
+} from '../../services';
+import { logger } from '../../utils';
+import { resolveJavaDownloadUrl, resolveLatestJavaLtsVersion } from './utils';
+
+@injectable()
+export class PrepareJavaService extends PrepareToolBaseService {
+  readonly name: string = 'java';
+
+  constructor(
+    @inject(PathService) pathSvc: PathService,
+    @inject(EnvService) envSvc: EnvService,
+    @inject(HttpService) private readonly httpSvc: HttpService,
+    @inject(CompressionService)
+    private readonly compressionSvc: CompressionService,
+  ) {
+    super(pathSvc, envSvc);
+  }
+
+  override async execute(): Promise<void> {
+    const ssl = this.pathSvc.sslPath;
+
+    if (await this.isPrepared()) {
+      // cert store already there
+      return;
+    }
+
+    const version = await resolveLatestJavaLtsVersion(
+      this.httpSvc,
+      'jre',
+      this.envSvc.arch,
+    );
+    if (!version) {
+      throw new Error('Could not resolve latest java version');
+    }
+
+    const pkg = await resolveJavaDownloadUrl(
+      this.httpSvc,
+      'jre',
+      this.envSvc.arch,
+      version,
+    );
+
+    if (!pkg) {
+      throw new Error(`Could not resolve download url for java ${version}`);
+    }
+
+    logger.debug(`downloading cacerts from ${version}`);
+
+    const jre = await this.httpSvc.download({
+      url: pkg.link,
+      checksumType: 'sha256',
+      expectedChecksum: pkg.checksum,
+      fileName: pkg.name,
+    });
+
+    const tmp = path.join(this.pathSvc.tmpDir, 'java');
+
+    await fs.mkdir(tmp, { recursive: true });
+
+    await this.compressionSvc.extract({ file: jre, cwd: tmp, strip: 1 });
+
+    await fs.cp(
+      path.join(tmp, 'lib/security/cacerts'),
+      path.join(ssl, 'cacerts'),
+    );
+
+    // cleanup will be done by caller
+  }
+
+  override async isPrepared(): Promise<boolean> {
+    return await this.pathSvc.fileExists(
+      path.join(this.pathSvc.sslPath, 'cacerts'),
+    );
+  }
+}
+
+@injectable()
+export class PrepareJavaJdkService extends PrepareJavaService {
+  override readonly name = 'java-jdk';
+}
+
+@injectable()
+export class PrepareJavaJreService extends PrepareJavaService {
+  override readonly name = 'java-jre';
+}
+
+@injectable()
+export class InstallJavaService extends InstallToolBaseService {
+  override name: string = 'java';
+
+  constructor(
+    @inject(EnvService) envSvc: EnvService,
+    @inject(PathService) pathSvc: PathService,
+    @inject(HttpService) private http: HttpService,
+    @inject(CompressionService) private compress: CompressionService,
+  ) {
+    super(pathSvc, envSvc);
+  }
+
+  override async install(version: string): Promise<void> {
+    const type = this.name === 'java-jre' ? 'jre' : 'jdk';
+
+    const pkg = await resolveJavaDownloadUrl(
+      this.http,
+      type,
+      this.envSvc.arch,
+      version,
+    );
+
+    if (!pkg) {
+      throw new Error(
+        `Could not resolve download url for java ${version} and type ${type}`,
+      );
+    }
+
+    const file = await this.http.download({
+      url: pkg.link,
+      checksumType: 'sha256',
+      expectedChecksum: pkg.checksum,
+      fileName: pkg.name,
+    });
+
+    // TODO: create recursive
+    if (!(await this.pathSvc.findToolPath(this.name))) {
+      await this.pathSvc.createToolPath(this.name);
+    }
+
+    const cwd = await this.pathSvc.createVersionedToolPath(this.name, version);
+    await this.compress.extract({
+      file,
+      cwd,
+      strip: 1,
+    });
+
+    const v = semver.parse(version);
+    // we've a different cacerts location in java 8 jdk
+    const cacerts =
+      v?.major === 8 && this.name !== 'java-jre'
+        ? path.join(cwd, 'jre/lib/security/cacerts')
+        : path.join(cwd, 'lib/security/cacerts');
+    await fs.rm(cacerts);
+    await fs.symlink(path.join(this.pathSvc.sslPath, 'cacerts'), cacerts);
+  }
+
+  override async isPrepared(): Promise<boolean> {
+    return await this.pathSvc.fileExists(
+      path.join(this.pathSvc.sslPath, 'cacerts'),
+    );
+  }
+
+  override async link(version: string): Promise<void> {
+    const src = path.join(
+      this.pathSvc.versionedToolPath(this.name, version),
+      'bin',
+    );
+    await this.shellwrapper({ srcDir: src, name: 'java' });
+  }
+
+  override async test(_version: string): Promise<void> {
+    await execa('java', ['-version'], {
+      stdio: ['inherit', 'inherit', 1],
+    });
+  }
+}
+
+@injectable()
+export class InstallJavaJreService extends InstallJavaService {
+  override readonly name = 'java-jre';
+}
+
+@injectable()
+export class InstallJavaJdkService extends InstallJavaService {
+  override readonly name = 'java-jdk';
+}

src/cli/tools/java/schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+// https://api.adoptium.net/q/swagger-ui
+
+const AdoptiumVersionData = z.object({
+  semver: z.string(),
+});
+
+export const AdoptiumReleaseVersions = z.object({
+  versions: z.array(AdoptiumVersionData),
+});
+
+const AdoptiumPackage = z.object({
+  /**
+   * sha256 checksum
+   */
+  checksum: z.string(),
+  link: z.string(),
+  name: z.string(),
+});
+
+export type AdoptiumPackage = z.infer<typeof AdoptiumPackage>;
+
+const AdoptiumBinary = z.object({
+  package: AdoptiumPackage,
+});
+
+const AdoptiumRelease = z.object({
+  binaries: z.array(AdoptiumBinary),
+});
+
+export const AdoptiumReleases = z.array(AdoptiumRelease);

src/cli/tools/java/utils.ts

@@ -0,0 +1,44 @@
+import type { HttpService } from '../../services';
+import type { Arch } from '../../utils';
+import {
+  type AdoptiumPackage,
+  AdoptiumReleaseVersions,
+  AdoptiumReleases,
+} from './schema';
+
+export async function resolveLatestJavaLtsVersion(
+  http: HttpService,
+  type: 'jre' | 'jdk',
+  arch: Arch,
+): Promise<string> {
+  const base_url = 'https://api.adoptium.net/v3/info/release_versions';
+  const api_args =
+    'heap_size=normal&os=linux&page=0&page_size=1&project=jdk&release_type=ga&lts=true&semver=true';
+
+  const res = AdoptiumReleaseVersions.parse(
+    await http.getJson(
+      `${base_url}?architecture=${arch === 'amd64' ? 'x64' : 'aarch64'}&image_type=${type}&${api_args}`,
+    ),
+  );
+
+  return res.versions[0]!.semver;
+}
+
+export async function resolveJavaDownloadUrl(
+  http: HttpService,
+  type: 'jre' | 'jdk',
+  arch: Arch,
+  version: string,
+): Promise<AdoptiumPackage | undefined> {
+  const base_url = 'https://api.adoptium.net/v3/assets/version';
+  const api_args =
+    'heap_size=normal&os=linux&page=0&page_size=1&project=jdk&semver=true';
+
+  const res = AdoptiumReleases.parse(
+    await http.getJson(
+      `${base_url}/${version}?architecture=${arch === 'amd64' ? 'x64' : 'aarch64'}&image_type=${type}&${api_args}`,
+    ),
+  );
+
+  return res?.[0]?.binaries?.[0]?.package;
+}