@gatling.io/cli 3.11.7 → 3.13.1

package/src/commands/options.ts

@@ -0,0 +1,308 @@
+import { Option, Argument } from "commander";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import { SimulationFile } from "../simulations";
+import { keyInSelectPaginated } from "../readline";
+import { logger } from "../log";
+
+const getStringValueOptional =
+  (option: Option) =>
+  (options: any): string | undefined => {
+    const value = options[option.attributeName()];
+    if (typeof value === "string" || typeof value === "undefined") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type string|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getStringValueMandatory =
+  (option: Option) =>
+  (options: any): string => {
+    const value = options[option.attributeName()];
+    if (typeof value === "string") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type string for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getBooleanValueOptional =
+  (option: Option) =>
+  (options: any): boolean | undefined => {
+    const value = options[option.attributeName()];
+    if (typeof value === "boolean" || typeof value === "undefined") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type boolean|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getBooleanValueMandatory =
+  (option: Option) =>
+  (options: any): boolean => {
+    const value = options[option.attributeName()];
+    if (typeof value === "boolean") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type boolean for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+const getNumberValueOptional =
+  (option: Option) =>
+  (options: any): number | undefined => {
+    const value = options[option.attributeName()];
+    if (typeof value === "number" || typeof value === "undefined") {
+      return value;
+    } else {
+      throw Error(
+        `Expected type number|undefined for attribute ${option.attributeName()}, got ${typeof value} - please report this as a bug.`
+      );
+    }
+  };
+
+export const gatlingHomeOption = new Option(
+  "--gatling-home <value>",
+  'The folder used to download and install Gatling components (default: "~/.gatling")'
+);
+export const gatlingHomeOptionValueWithDefaults = (options: any): string =>
+  getStringValueOptional(gatlingHomeOption)(options) || `${os.homedir()}/.gatling`;
+
+export const sourcesFolderOption = new Option("--sources-folder <value>", "The sources folder path").default("src");
+export const sourcesFolderOptionValue = getStringValueMandatory(sourcesFolderOption);
+
+export const simulationOption = new Option(
+  "--simulation <value>",
+  "The simulation entry point function name (default: if only one *.gatling.js or *.gatling.ts file is found, will execute that simulation)"
+);
+export const simulationOptionValueWithDefaults = (
+  options: any,
+  simulationsFound: SimulationFile[],
+  interactive: boolean
+): string => {
+  const declaredSimulation = getStringValueOptional(simulationOption)(options);
+  if (declaredSimulation !== undefined) {
+    return declaredSimulation;
+  } else if (simulationsFound.length === 1) {
+    return simulationsFound[0].name;
+  } else if (simulationsFound.length === 0) {
+    throw new Error(
+      "No simulation found, simulations must be defined in a <simulation name>.gatling.js or <simulation name>.gatling.ts file)"
+    );
+  } else if (interactive) {
+    const sortedSimulations = simulationsFound.sort((a, b) => a.name.localeCompare(b.name));
+    const idx = keyInSelectPaginated(
+      sortedSimulations.map((s) => s.name),
+      "Choose a simulation to run"
+    );
+    if (idx >= 0) {
+      const simulation = sortedSimulations[idx].name;
+      logger.info(`Simulation '${simulation}' was chosen.`);
+      return simulation;
+    } else {
+      throw new Error("Simulation choice was cancelled.");
+    }
+  } else {
+    throw new Error(
+      `Several simulations found, specify one using the --simulation option (available simulations: ${simulationsFound.map((s) => s.name)})`
+    );
+  }
+};
+
+export const simulationMandatoryOption = new Option(
+  "--simulation <value>",
+  "The simulation entry point function name"
+).makeOptionMandatory(true);
+export const simulationMandatoryOptionValue = getStringValueMandatory(simulationMandatoryOption);
+
+export const bundleFileOption = new Option(
+  "--bundle-file <value>",
+  "The target bundle file path when building simulations (must have a .js extension)"
+)
+  .default("target/bundle.js")
+  .argParser((value) => {
+    if (!value.endsWith(".js")) {
+      throw Error(`'${value}' is not a valid bundle file path: should have a .js extension`);
+    }
+    return value;
+  });
+export const bundleFileOptionValue = getStringValueMandatory(bundleFileOption);
+
+export const packageFileOption = new Option(
+  "--package-file <value>",
+  "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)"
+)
+  .default("target/package.zip")
+  .argParser((value) => {
+    if (!value.endsWith(".zip")) {
+      throw Error(`'${value}' is not a valid package file path: should have a .zip extension`);
+    }
+    return value;
+  });
+export const packageFileOptionValue = getStringValueMandatory(packageFileOption);
+
+export const resourcesFolderOption = new Option("--resources-folder <value>", "The resources folder path").default(
+  "resources"
+);
+export const resourcesFolderOptionValue = getStringValueMandatory(resourcesFolderOption);
+
+export const resultsFolderOption = new Option("--results-folder <value>", "The results folder path").default(
+  "target/gatling"
+);
+export const resultsFolderOptionValue = getStringValueMandatory(resultsFolderOption);
+
+export const typescriptOption = new Option(
+  "--typescript",
+  "Use the typescript compiler to compile your code (default: true if the sourcesFolder contains any *.gatling.ts file, false otherwise)"
+);
+export const typescriptOptionValueWithDefaults = (options: any, simulationsFound: SimulationFile[]): boolean => {
+  const value = getBooleanValueOptional(typescriptOption)(options);
+  return value !== undefined ? value : simulationsFound.findIndex((s) => s.type === "typescript") >= 0;
+};
+
+export const graalvmHomeMandatoryOption = new Option(
+  "--graalvm-home <value>",
+  "Path to the GraalVM home"
+).makeOptionMandatory(true);
+export const graalvmHomeMandatoryOptionValue = getStringValueMandatory(graalvmHomeMandatoryOption);
+
+export const jvmClasspathMandatoryOption = new Option(
+  "--jvm-classpath <value>",
+  "The classpath containing all Gatling JVM components"
+).makeOptionMandatory(true);
+export const jvmClasspathMandatoryOptionValue = getStringValueMandatory(jvmClasspathMandatoryOption);
+
+export const memoryOption = new Option(
+  "--memory <value>",
+  "Heap space memory size in MiB for Gatling. Half the total available memory is usually a good default, as the Gatling process will use more memory than just the heap space."
+).argParser((value) => {
+  const parsedValue = parseInt(value, 10);
+  if (isNaN(parsedValue)) {
+    throw new Error(`${value} is not a valid memory size, must be an integer number`);
+  }
+  return parsedValue;
+});
+export const memoryOptionValue = getNumberValueOptional(memoryOption);
+
+export const nonInteractiveOption = new Option(
+  "--non-interactive",
+  "Switch to non-interactive mode and fail if no simulation is explicitly specified"
+).default(false);
+export const nonInteractiveOptionValue = getBooleanValueMandatory(nonInteractiveOption);
+
+export const postmanOption = new Option(
+  "--postman <version>",
+  "Postman compatibility option: adds polyfills, etc."
+).hideHelp();
+export const postmanOptionValueWithDefaults = (options: any): string | undefined => {
+  const postmanOptionValue = getStringValueOptional(postmanOption)(options);
+  if (postmanOptionValue !== undefined) {
+    return postmanOptionValue;
+  } else {
+    try {
+      const conf = JSON.parse(fs.readFileSync("package.json", { encoding: "utf-8", flag: "r" }));
+      const withPostman =
+        conf.dependencies?.["@gatling.io/postman"] !== undefined ||
+        conf.devDependencies?.["@gatling.io/postman"] !== undefined;
+      if (withPostman) {
+        let directory = path.normalize(path.dirname("package.json"));
+        const root = path.parse(directory).root;
+        while (true) {
+          const file = path.join(directory, "node_modules", "@gatling.io", "postman", "package.json");
+          if (fs.existsSync(file)) {
+            const installedPackage = JSON.parse(fs.readFileSync(file, { encoding: "utf-8", flag: "r" }));
+            return installedPackage.version;
+          } else if (directory === root) {
+            return undefined;
+          } else {
+            directory = path.normalize(path.join(directory, ".."));
+          }
+        }
+      } else {
+        return undefined;
+      }
+    } catch {
+      return undefined;
+    }
+  }
+};
+
+export const runParametersArgument = new Argument(
+  "[optionKey=optionValue...]",
+  "Specify one or more parameter which can be read in the simulation script with the getParameter() function; format must be key=value"
+);
+export const parseRunParametersArgument = (args: string[]): Record<string, string> => {
+  const parsedParameters: Record<string, string> = {};
+  for (const arg of args) {
+    const i = arg.indexOf("=");
+    if (i < 0) {
+      throw Error(`Parameter '${arg}' is not valid: format should be key=value`);
+    } else {
+      const key = arg.slice(0, i).trim();
+      parsedParameters[key] = arg.slice(i + 1);
+    }
+  }
+  return parsedParameters;
+};
+
+export const apiUrlOption = new Option("--apiUrl <value>", "URL of the Gatling Enterprise API")
+  .default("https://api.gatling.io")
+  .hideHelp();
+export const apiUrlOptionValue = getStringValueMandatory(apiUrlOption);
+
+export const webAppUrlOption = new Option("--webAppUrl <value>", "URL of the Gatling Enterprise web app")
+  .default("https://cloud.gatling.io")
+  .hideHelp();
+export const webAppUrlOptionValue = getStringValueMandatory(webAppUrlOption);
+
+export const apiTokenOption = new Option(
+  "--api-token <value>",
+  "API Token on Gatling Enterprise. Prefer configuration using `GATLING_ENTERPRISE_API_TOKEN` environment variable."
+);
+export const apiTokenOptionValue = getStringValueOptional(apiTokenOption);
+
+// Plugin configuration
+
+export const controlPlaneUrlOption = new Option(
+  "--control-plane-url <value>",
+  "URL of a control plane for Gatling Enterprise providing a private repository. If this parameter is provided, packages will be registered as private packages and uploaded through this private control plane."
+);
+export const controlPlaneUrlOptionValue = getStringValueOptional(controlPlaneUrlOption);
+
+// Descriptor file
+
+export const packageDescriptorFilenameOption = new Option(
+  "--package-descriptor-filename <value>",
+  "Path to a package descriptor inside the .gatling folder"
+).default("package.conf");
+export const packageDescriptorFilenameOptionValue = getStringValueMandatory(packageDescriptorFilenameOption);
+
+// Deployment info
+
+export const enterpriseSimulationOption = new Option(
+  "--enterprise-simulation <value>",
+  "Specify the simulation name directly to bypass the prompt using the following command."
+);
+export const enterpriseSimulationOptionValue = getStringValueOptional(enterpriseSimulationOption);
+
+export const runTitleOption = new Option("--run-title <value>", "Allows setting a title for your run reports.");
+export const runTitleOptionValue = getStringValueOptional(runTitleOption);
+
+export const runDescriptionOption = new Option(
+  "--run-description <value>",
+  "Allows setting a description for your run reports summary."
+);
+export const runDescriptionOptionValue = getStringValueOptional(runDescriptionOption);
+
+export const waitForRunEndOption = new Option(
+  "--wait-for-run-end",
+  "Wait for the result after starting the simulation on Gatling Enterprise, and complete with an error if the simulation ends with any error status"
+).default(false);
+export const waitForRunEndOptionValue = getBooleanValueMandatory(waitForRunEndOption);

package/src/commands/recorder.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+
+import {
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults
+} from "./options";
+import { findSimulations } from "../simulations";
+import { installRecorder } from "../dependencies";
+import { logger } from "../log";
+import { runRecorder } from "../run";
+
+export default (program: Command): void => {
+  program
+    .command("recorder")
+    .description("Run the Gatling recorder")
+    .addOption(gatlingHomeOption)
+    .addOption(sourcesFolderOption)
+    .addOption(typescriptOption)
+    .addOption(resourcesFolderOption)
+    .action(async (options) => {
+      const gatlingHome: string = gatlingHomeOptionValueWithDefaults(options);
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+
+      const { graalvmHome, coursierBinary, jvmClasspath } = await installRecorder({ gatlingHome });
+      logger.debug(`graalvmHome=${graalvmHome}`);
+      logger.debug(`coursierBinary=${coursierBinary}`);
+      logger.debug(`jvmClasspath=${jvmClasspath}`);
+
+      await runRecorder({ graalvmHome, jvmClasspath, sourcesFolder, typescript, resourcesFolder });
+    });
+};

package/src/commands/run.ts

@@ -0,0 +1,82 @@
+import { Command } from "commander";
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  gatlingHomeOption,
+  gatlingHomeOptionValueWithDefaults,
+  memoryOption,
+  memoryOptionValue,
+  nonInteractiveOption,
+  nonInteractiveOptionValue,
+  parseRunParametersArgument,
+  postmanOption,
+  postmanOptionValueWithDefaults,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  runParametersArgument,
+  simulationOption,
+  simulationOptionValueWithDefaults,
+  sourcesFolderOption,
+  sourcesFolderOptionValue,
+  typescriptOption,
+  typescriptOptionValueWithDefaults
+} from "./options";
+import { findSimulations } from "../simulations";
+import { installGatlingJs } from "../dependencies";
+import { logger } from "../log";
+import { bundle } from "../bundle";
+import { runSimulation } from "../run";
+
+export default (program: Command): void => {
+  program
+    .command("run")
+    .description(
+      "Build and run a Gatling simulation, after installing all required components and dependencies for Gatling"
+    )
+    .addOption(sourcesFolderOption)
+    .addOption(simulationOption)
+    .addOption(typescriptOption)
+    .addOption(bundleFileOption)
+    .addOption(resourcesFolderOption)
+    .addOption(resultsFolderOption)
+    .addOption(gatlingHomeOption)
+    .addOption(memoryOption)
+    .addOption(postmanOption)
+    .addOption(nonInteractiveOption)
+    .addArgument(runParametersArgument)
+    .action(async (args: string[], options) => {
+      const gatlingHome = gatlingHomeOptionValueWithDefaults(options);
+      const sourcesFolder: string = sourcesFolderOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const memory: number | undefined = memoryOptionValue(options);
+      const nonInteractive: boolean = nonInteractiveOptionValue(options);
+      const postman = postmanOptionValueWithDefaults(options);
+      const runParameters = parseRunParametersArgument(args);
+
+      const simulations = await findSimulations(sourcesFolder);
+      const typescript = typescriptOptionValueWithDefaults(options, simulations);
+      const simulation = simulationOptionValueWithDefaults(options, simulations, !nonInteractive);
+
+      const { graalvmHome, coursierBinary, jvmClasspath } = await installGatlingJs({ gatlingHome, postman });
+      logger.debug(`graalvmHome=${graalvmHome}`);
+      logger.debug(`coursierBinary=${coursierBinary}`);
+      logger.debug(`jvmClasspath=${jvmClasspath}`);
+
+      await bundle({ sourcesFolder, bundleFile, postman, typescript, simulations });
+
+      await runSimulation({
+        graalvmHome,
+        jvmClasspath,
+        simulation,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        memory,
+        runParameters
+      });
+    });
+};

package/src/commands/runOnly.ts

@@ -0,0 +1,56 @@
+import { Command } from "commander";
+
+import {
+  bundleFileOption,
+  bundleFileOptionValue,
+  graalvmHomeMandatoryOption,
+  graalvmHomeMandatoryOptionValue,
+  jvmClasspathMandatoryOption,
+  jvmClasspathMandatoryOptionValue,
+  memoryOption,
+  memoryOptionValue,
+  parseRunParametersArgument,
+  resourcesFolderOption,
+  resourcesFolderOptionValue,
+  resultsFolderOption,
+  resultsFolderOptionValue,
+  runParametersArgument,
+  simulationMandatoryOption,
+  simulationMandatoryOptionValue
+} from "./options";
+import { runSimulation } from "../run";
+
+export default (program: Command): void => {
+  program
+    .command("run-only")
+    .description("Run a Gatling simulation from an already built bundle")
+    .addOption(graalvmHomeMandatoryOption)
+    .addOption(jvmClasspathMandatoryOption)
+    .addOption(simulationMandatoryOption)
+    .addOption(bundleFileOption)
+    .addOption(resourcesFolderOption)
+    .addOption(resultsFolderOption)
+    .addOption(memoryOption)
+    .addArgument(runParametersArgument)
+    .action(async (args: string[], options) => {
+      const graalvmHome: string = graalvmHomeMandatoryOptionValue(options);
+      const jvmClasspath: string = jvmClasspathMandatoryOptionValue(options);
+      const simulation: string = simulationMandatoryOptionValue(options);
+      const bundleFile = bundleFileOptionValue(options);
+      const resourcesFolder: string = resourcesFolderOptionValue(options);
+      const resultsFolder: string = resultsFolderOptionValue(options);
+      const memory: number | undefined = memoryOptionValue(options);
+      const runParameters = parseRunParametersArgument(args);
+
+      await runSimulation({
+        graalvmHome,
+        jvmClasspath,
+        simulation: simulation,
+        bundleFile,
+        resourcesFolder,
+        resultsFolder,
+        memory,
+        runParameters
+      });
+    });
+};

package/src/dependencies/coursier.ts

@@ -0,0 +1,84 @@
+import { existsSync } from "fs";
+import fs from "fs/promises";
+
+import { downloadFile } from "./download";
+import { logger } from "../log";
+import { versions } from "./versions";
+import { promisify } from "util";
+import { exec } from "child_process";
+import { osType } from "./os";
+
+export const installCoursier = async (gatlingHomeDir: string, downloadDir: string): Promise<string> => {
+  const coursierRootPath = `${gatlingHomeDir}/coursier/${versions.coursier}`;
+  const coursierPath = `${coursierRootPath}/cs`;
+
+  if (!existsSync(coursierPath)) {
+    const jarUrl = `https://github.com/coursier/coursier/releases/download/v${versions.coursier}/coursier`;
+    const windowsBatUrl = `https://github.com/coursier/launchers/raw/master/coursier.bat`;
+    const downloadPath = `${downloadDir}/cs`;
+
+    if (existsSync(coursierRootPath)) {
+      await fs.rm(coursierRootPath, { recursive: true });
+    }
+    if (existsSync(downloadPath)) {
+      await fs.rm(downloadPath);
+    }
+    await fs.mkdir(coursierRootPath, { recursive: true });
+
+    logger.info(`Downloading Coursier ${versions.coursier} to ${downloadPath}`);
+    await downloadFile(jarUrl, downloadPath);
+    if (osType === "Windows_NT") {
+      await downloadFile(windowsBatUrl, `${downloadPath}.bat`);
+    } else {
+      await fs.chmod(downloadPath, 0o744);
+    }
+
+    logger.info(`Installing Coursier to ${coursierPath}`);
+    await fs.rename(downloadPath, coursierPath);
+    if (osType === "Windows_NT") {
+      await fs.rename(`${downloadPath}.bat`, `${coursierPath}.bat`);
+    }
+  } else {
+    logger.info(`Coursier ${versions.coursier} already installed at ${coursierPath}`);
+  }
+
+  return coursierPath;
+};
+
+export const resolveGatlingJsDependencies = async (
+  coursierPath: string,
+  javaHome: string,
+  postmanVersion?: string
+): Promise<string> => {
+  const dependencies = [
+    `"io.gatling.highcharts:gatling-charts-highcharts:${versions.gatling.core}"`,
+    `"io.gatling:gatling-jvm-to-js-adapter:${versions.gatling.jsAdapter}"`,
+    `"io.gatling:gatling-enterprise-plugin-commons:${versions.gatling.enterprisePluginCommons}"`,
+    `"org.graalvm.polyglot:js-community:${versions.graalvm.js}"`
+  ];
+  if (postmanVersion !== undefined) {
+    dependencies.push(`"io.gatling:gatling-postman-jvm-to-js-adapter:${postmanVersion}"`);
+  }
+
+  return await resolveDependencies(coursierPath, javaHome, ...dependencies);
+};
+
+export const resolveRecorderDependencies = async (coursierPath: string, javaHome: string): Promise<string> => {
+  const recorderDep = `io.gatling:gatling-recorder:${versions.gatling.core}`;
+  return await resolveDependencies(coursierPath, javaHome, recorderDep);
+};
+
+const resolveDependencies = async (
+  coursierPath: string,
+  javaHome: string,
+  ...dependencies: string[]
+): Promise<string> => {
+  const command = `"${coursierPath}" fetch --classpath ${dependencies.join(" ")}`;
+
+  // TODO could add a timeout
+  logger.info(`Resolving dependencies with Coursier`);
+  const { stdout } = await execAsync(command, { env: { ...process.env, JAVA_HOME: javaHome } });
+  return stdout;
+};
+
+const execAsync = promisify(exec);

package/src/dependencies/download.ts

@@ -0,0 +1,11 @@
+import axios from "axios";
+import fs from "fs";
+import stream from "stream";
+import util from "util";
+
+const pipeline = util.promisify(stream.pipeline);
+
+export const downloadFile = async (url: string, targetFile: string): Promise<void> => {
+  const request = await axios.get(url, { responseType: "stream" });
+  await pipeline(request.data, fs.createWriteStream(targetFile));
+};

package/src/dependencies/graalVm.ts

@@ -0,0 +1,74 @@
+import { existsSync } from "fs";
+import fs from "fs/promises";
+import decompress from "decompress";
+
+import { downloadFile } from "./download";
+import { logger } from "../log";
+import { osType, osArch } from "./os";
+import { versions } from "./versions";
+
+export const installGraalVm = async (gatlingHomeDir: string, downloadDir: string): Promise<string> => {
+  const { os, arch, extension, homePath, binPath } = graalVmPlatformParams();
+  const graalvmRootPath = `${gatlingHomeDir}/graalvm/${versions.graalvm.jdk}`;
+  const graalvmHomePath = `${graalvmRootPath}${homePath}`;
+  const graalvmJavaPath = `${graalvmHomePath}${binPath}`;
+
+  if (!existsSync(graalvmJavaPath)) {
+    const url = `https://github.com/graalvm/graalvm-ce-builds/releases/download/jdk-${versions.graalvm.jdk}/graalvm-community-jdk-${versions.graalvm.jdk}_${os}-${arch}_bin.${extension}`;
+    const downloadPath = `${downloadDir}/graalvm.${extension}`;
+
+    if (existsSync(graalvmRootPath)) {
+      await fs.rm(graalvmRootPath, { recursive: true });
+    }
+    if (existsSync(downloadPath)) {
+      await fs.rm(downloadPath);
+    }
+    await fs.mkdir(graalvmRootPath, { recursive: true });
+
+    logger.info(`Downloading GraalVM Community Edition ${versions.graalvm.jdk} to ${downloadPath}`);
+    await downloadFile(url, downloadPath);
+
+    logger.info(`Unpacking GraalVM to ${graalvmRootPath}`);
+    await decompress(downloadPath, graalvmRootPath, {
+      map: (file) => {
+        // Remove first level of file name, because it already contains a root directory
+        file.path = file.path.split("/").slice(1).join("/");
+        return file;
+      }
+    });
+
+    await fs.rm(downloadPath);
+  } else {
+    logger.info(`GraalVM Community Edition ${versions.graalvm.jdk} already installed at ${graalvmRootPath}`);
+  }
+
+  return graalvmHomePath;
+};
+
+const graalVmPlatformParams = () => {
+  if (osType === "Linux") {
+    const os = "linux";
+    const extension = "tar.gz";
+    const homePath = "";
+    const binPath = "/bin/java";
+    if (osArch === "x64") {
+      return { os, arch: "x64", extension, homePath, binPath };
+    } else if (osArch === "arm64") {
+      return { os, arch: "aarch64", extension, homePath, binPath };
+    }
+  } else if (osType === "Darwin") {
+    const os = "macos";
+    const extension = "tar.gz";
+    const homePath = "/Contents/Home";
+    const binPath = "/bin/java";
+    if (osArch === "x64") {
+      return { os, arch: "x64", extension, homePath, binPath };
+    } else if (osArch === "arm64") {
+      return { os, arch: "aarch64", extension, homePath, binPath };
+    }
+  } else if (osType === "Windows_NT" && osArch === "x64") {
+    return { os: "windows", arch: "x64", extension: "zip", homePath: "", binPath: "/bin/java.exe" };
+  }
+
+  throw Error(`Operating system type '${osType}' with architecture '${osArch}' is not currently supported.`);
+};