@gatling.io/cli 0.1.0

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@gatling.io/cli",
+  "version": "0.1.0",
+  "bin": {
+    "gatling-js-cli": "target/index.js"
+  },
+  "main": "target/index.js",
+  "types": "target/index.d.ts",
+  "dependencies": {
+    "axios": "1.6.8",
+    "commander": "12.0.0",
+    "decompress": "4.2.1",
+    "esbuild": "0.20.2",
+    "esbuild-plugin-tsc": "0.4.0"
+  },
+  "devDependencies": {
+    "@types/decompress": "4.2.7",
+    "@types/node": "20.12.9",
+    "prettier": "3.2.5",
+    "rimraf": "5.0.5",
+    "typescript": "5.4.5"
+  },
+  "scripts": {
+    "clean": "rimraf target results tmp",
+    "format": "prettier --write '**/*.ts'",
+    "build": "tsc -p . && chmod +x ./target/index.js"
+  }
+}

package/target/bundle.d.ts

@@ -0,0 +1,6 @@
+export interface BundleOptions {
+    entrypointFile: string;
+    bundleFile: string;
+    typescript: boolean;
+}
+export declare const bundle: (options: BundleOptions) => Promise<void>;

package/target/bundle.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundle = void 0;
+const esbuild = __importStar(require("esbuild"));
+const esbuild_plugin_tsc_1 = __importDefault(require("esbuild-plugin-tsc"));
+const log_1 = require("./log");
+const bundle = async (options) => {
+    log_1.logger.info(`Packaging a Gatling simulation with options:
+ - entrypointFile: ${options.entrypointFile}
+ - bundleFile: ${options.bundleFile}`);
+    const plugins = options.typescript ? [(0, esbuild_plugin_tsc_1.default)({ force: true })] : [];
+    await esbuild.build({
+        entryPoints: [options.entrypointFile],
+        outfile: options.bundleFile,
+        bundle: true,
+        minify: false,
+        sourcemap: true,
+        format: "iife",
+        globalName: "gatling",
+        plugins
+    });
+};
+exports.bundle = bundle;

package/target/dependencies/download.d.ts

@@ -0,0 +1 @@
+export declare const downloadFile: (url: string, targetFile: string) => Promise<void>;

package/target/dependencies/download.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const stream_1 = __importDefault(require("stream"));
+const util_1 = __importDefault(require("util"));
+const pipeline = util_1.default.promisify(stream_1.default.pipeline);
+const downloadFile = async (url, targetFile) => {
+    const request = await axios_1.default.get(url, { responseType: "stream" });
+    await pipeline(request.data, fs_1.default.createWriteStream(targetFile));
+};
+exports.downloadFile = downloadFile;

package/target/dependencies/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { exec } from "child_process";
+export declare const execAsync: typeof exec.__promisify__;
+export interface DependenciesOptions {
+    gatlingHome: string;
+}
+export interface ResolvedDependencies {
+    graalvmHome: string;
+    coursierBinary: string;
+    jvmClasspath: string;
+}
+export declare const installAll: (options: DependenciesOptions) => Promise<ResolvedDependencies>;

package/target/dependencies/index.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installAll = exports.execAsync = void 0;
+const child_process_1 = require("child_process");
+const decompress_1 = __importDefault(require("decompress"));
+const fs_1 = require("fs");
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const util_1 = require("util");
+const download_1 = require("./download");
+const log_1 = require("../log");
+const versions_1 = require("./versions");
+exports.execAsync = (0, util_1.promisify)(child_process_1.exec);
+const installAll = async (options) => {
+    const downloadDir = `${options.gatlingHome}/tmp/download`;
+    await promises_1.default.mkdir(downloadDir, { recursive: true });
+    const graalvmHomePath = await installGraalVm(options.gatlingHome, downloadDir);
+    const coursierPath = await installCoursier(options.gatlingHome, downloadDir);
+    const classpath = await resolveDependencies(coursierPath, graalvmHomePath);
+    return {
+        graalvmHome: graalvmHomePath,
+        coursierBinary: coursierPath,
+        jvmClasspath: classpath.trim()
+    };
+};
+exports.installAll = installAll;
+const installGraalVm = async (gatlingHomeDir, downloadDir) => {
+    // TODO test Linux and Windows
+    const { os, arch, extension, homePath } = graalVmPlatformParams();
+    const graalvmRootPath = `${gatlingHomeDir}/graalvm/${versions_1.versions.graalvm.jdk}`;
+    const graalvmHomePath = `${graalvmRootPath}${homePath}`;
+    const graalvmJavaPath = `${graalvmHomePath}/bin/java`;
+    if (!(0, fs_1.existsSync)(graalvmJavaPath)) {
+        const url = `https://github.com/graalvm/graalvm-ce-builds/releases/download/jdk-${versions_1.versions.graalvm.jdk}/graalvm-community-jdk-${versions_1.versions.graalvm.jdk}_${os}-${arch}_bin.${extension}`;
+        const downloadPath = `${downloadDir}/graalvm.${extension}`;
+        if ((0, fs_1.existsSync)(graalvmRootPath)) {
+            await promises_1.default.rm(graalvmRootPath, { recursive: true });
+        }
+        if ((0, fs_1.existsSync)(downloadPath)) {
+            await promises_1.default.rm(downloadPath);
+        }
+        await promises_1.default.mkdir(graalvmRootPath, { recursive: true });
+        log_1.logger.info(`Downloading GraalVM Community Edition ${versions_1.versions.graalvm.jdk} to ${downloadPath}`);
+        await (0, download_1.downloadFile)(url, downloadPath);
+        log_1.logger.info(`Unpacking GraalVM to ${graalvmRootPath}`);
+        await (0, decompress_1.default)(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 promises_1.default.rm(downloadPath);
+    }
+    else {
+        log_1.logger.info(`GraalVM Community Edition ${versions_1.versions.graalvm.jdk} already installed at ${graalvmRootPath}`);
+    }
+    return graalvmHomePath;
+};
+const graalVmPlatformParams = () => {
+    const osType = os_1.default.type(); // 'Darwin', 'Linux', 'Windows_NT'
+    const osArch = os_1.default.arch(); // 'x64', 'arm64', etc.
+    if (osType === "Linux") {
+        const os = "linux";
+        const extension = "tar.gz";
+        const homePath = "";
+        if (osArch === "x64") {
+            return { os, arch: "x64", extension, homePath };
+        }
+        else if (osArch === "arm64") {
+            return { os, arch: "aarch64", extension, homePath };
+        }
+    }
+    else if (osType === "Darwin") {
+        const os = "macos";
+        const extension = "tar.gz";
+        const homePath = "/Contents/Home";
+        if (osArch === "x64") {
+            return { os, arch: "x64", extension, homePath };
+        }
+        else if (osArch === "arm64") {
+            return { os, arch: "aarch64", extension, homePath };
+        }
+    }
+    else if (osType === "Windows_NT" && osArch === "x64") {
+        return { os: "windows", arch: "x64", extension: "zip", homePath: "" };
+    }
+    throw Error(`Operating system type '${osType}' with architecture '${osArch}' is not currently supported.`);
+};
+const installCoursier = async (gatlingHomeDir, downloadDir) => {
+    const coursierRootPath = `${gatlingHomeDir}/coursier/${versions_1.versions.coursier}`;
+    const coursierPath = `${coursierRootPath}/cs`;
+    if (!(0, fs_1.existsSync)(coursierPath)) {
+        // TODO test Linux/windows
+        const url = `https://github.com/coursier/coursier/releases/download/v${versions_1.versions.coursier}/coursier`;
+        const downloadPath = `${downloadDir}/cs`;
+        if ((0, fs_1.existsSync)(coursierRootPath)) {
+            await promises_1.default.rm(coursierRootPath, { recursive: true });
+        }
+        if ((0, fs_1.existsSync)(downloadPath)) {
+            await promises_1.default.rm(downloadPath);
+        }
+        await promises_1.default.mkdir(coursierRootPath, { recursive: true });
+        log_1.logger.info(`Downloading Coursier ${versions_1.versions.coursier} to ${downloadPath}`);
+        await (0, download_1.downloadFile)(url, downloadPath);
+        await promises_1.default.chmod(downloadPath, 0o744);
+        log_1.logger.info(`Installing Coursier to ${coursierPath}`);
+        await promises_1.default.rename(downloadPath, coursierPath);
+    }
+    else {
+        log_1.logger.info(`Coursier ${versions_1.versions.coursier} already installed at ${coursierPath}`);
+    }
+    return coursierPath;
+};
+const resolveDependencies = async (coursierPath, javaHome) => {
+    const gatlingDep = `"io.gatling.highcharts:gatling-charts-highcharts:${versions_1.versions.gatling.core}"`;
+    const gatlingAdapterDep = `"io.gatling:gatling-jvm-to-js-adapter:${versions_1.versions.gatling.jsAdapter}"`;
+    const graalvmJsDep = `"org.graalvm.polyglot:js-community:${versions_1.versions.graalvm.js}"`;
+    const command = `"${coursierPath}" fetch --classpath ${gatlingDep} ${gatlingAdapterDep} ${graalvmJsDep}`;
+    // TODO could add a timeout
+    log_1.logger.info(`Resolving dependencies with Coursier`);
+    const { stdout } = await (0, exports.execAsync)(command, { env: { ...process.env, JAVA_HOME: javaHome } });
+    return stdout;
+};

package/target/dependencies/versions.d.ts

@@ -0,0 +1,11 @@
+export declare const versions: {
+    graalvm: {
+        jdk: string;
+        js: string;
+    };
+    coursier: string;
+    gatling: {
+        core: string;
+        jsAdapter: string;
+    };
+};

package/target/dependencies/versions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versions = void 0;
+exports.versions = {
+    graalvm: {
+        jdk: "22.0.1",
+        js: "24.0.1"
+    },
+    coursier: "2.1.9",
+    gatling: {
+        core: "3.11.2",
+        jsAdapter: "0.0.8+8-e84571c3-SNAPSHOT"
+    }
+};

package/target/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/target/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const os_1 = __importDefault(require("os"));
+const bundle_1 = require("./bundle");
+const dependencies_1 = require("./dependencies");
+const log_1 = require("./log");
+const run_1 = require("./run");
+const program = new commander_1.Command()
+    .name("gatling-js-cli")
+    .version("0.0.1")
+    .description("The Gatling Javascript run & packaging tool");
+const gatlingHomeOption = new commander_1.Option("--gatling-home <value>", 'The folder used to download and install Gatling components (default: "~/.gatling")');
+const gatlingHomeDirWithDefaults = (options) => options.gatlingHome || `${os_1.default.homedir()}/.gatling`;
+const entrypointFileOption = new commander_1.Option("--entrypoint-file <value>", 'The simulation entry point source file path (default: "src/index.js", or "src/index.ts" when using the "--typescript" option)');
+const entrypointNameOption = new commander_1.Option("--entrypoint-name <value>", "The simulation entry point function name").default("default", '"default", compatible with using "export default"');
+const entrypointFileWithDefaults = (options) => options.entrypointFile || (options.typescript ? "src/index.ts" : "src/index.js");
+const bundleFileOption = new commander_1.Option("--bundle-file <value>", "The simulation target bundle file path").default("target/bundle.js");
+const resourcesFolderOption = new commander_1.Option("--resources-folder <value>", "The resources folder path").default("resources");
+const resultsFolderOption = new commander_1.Option("--results-folder <value>", "The results folder path").default("results");
+const typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code").default(false);
+const graalvmHomeMandatoryOption = new commander_1.Option("--graalvm-home <value>", "Path to the GraalVM home").makeOptionMandatory(true);
+const jvmClasspathMandatoryOption = new commander_1.Option("--jvm-classpath <value>", "The classpath containing all Gatling JVM components").makeOptionMandatory(true);
+program
+    .command("install")
+    .description("Install all required components and dependencies for Gatling")
+    .addOption(gatlingHomeOption)
+    .action(async (options) => {
+    const gatlingHome = gatlingHomeDirWithDefaults(options);
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installAll)({ gatlingHome });
+    log_1.logger.info(`graalvmHome=${graalvmHome}`);
+    log_1.logger.info(`coursierBinary=${coursierBinary}`);
+    log_1.logger.info(`jvmClasspath=${jvmClasspath}`);
+});
+program
+    .command("build")
+    .description("Build a Gatling simulation")
+    .addOption(entrypointFileOption)
+    .addOption(bundleFileOption)
+    .addOption(typescriptOption)
+    .action(async (options) => {
+    const entrypointFile = entrypointFileWithDefaults(options);
+    const bundleFile = options.bundleFile;
+    const typescript = options.typescript;
+    await (0, bundle_1.bundle)({ entrypointFile, bundleFile, typescript });
+});
+program
+    .command("run-only")
+    .description("Run a Gatling simulation")
+    .addOption(graalvmHomeMandatoryOption)
+    .addOption(jvmClasspathMandatoryOption)
+    .addOption(entrypointNameOption)
+    .addOption(bundleFileOption)
+    .addOption(resourcesFolderOption)
+    .addOption(resultsFolderOption)
+    .action(async (options) => {
+    const graalvmHome = options.graalvmHome;
+    const jvmClasspath = options.jvmClasspath;
+    const entrypointName = options.entrypointName;
+    const bundleFile = options.bundleFile;
+    const resourcesFolder = options.resourcesFolder;
+    const resultsFolder = options.resultsFolder;
+    await (0, run_1.run)({ graalvmHome, jvmClasspath, entrypointName, bundleFile, resourcesFolder, resultsFolder });
+});
+program
+    .command("run")
+    .description("Build and run a Gatling simulation, after installing all required components and dependencies for Gatling")
+    .addOption(entrypointFileOption)
+    .addOption(entrypointNameOption)
+    .addOption(typescriptOption)
+    .addOption(bundleFileOption)
+    .addOption(resourcesFolderOption)
+    .addOption(resultsFolderOption)
+    .addOption(gatlingHomeOption)
+    .action(async (options) => {
+    const gatlingHome = gatlingHomeDirWithDefaults(options);
+    const entrypointFile = entrypointFileWithDefaults(options);
+    const entrypointName = options.entrypointName;
+    const bundleFile = options.bundleFile;
+    const resourcesFolder = options.resourcesFolder;
+    const resultsFolder = options.resultsFolder;
+    const typescript = options.typescript;
+    const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installAll)({ gatlingHome });
+    log_1.logger.debug(`graalvmHome=${graalvmHome}`);
+    log_1.logger.debug(`coursierBinary=${coursierBinary}`);
+    log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
+    await (0, bundle_1.bundle)({ entrypointFile, bundleFile, typescript });
+    await (0, run_1.run)({ graalvmHome, jvmClasspath, entrypointName, bundleFile, resourcesFolder, resultsFolder });
+});
+program.parse(process.argv);

package/target/log.d.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    error: (message: string) => void;
+}
+export declare const logger: Logger;

package/target/log.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const debug = 
+// On Node.js, console.debug is just an alias to console.log, so we handle debug level ourselves
+process.env["DEBUG"] === "true" ? console.debug : () => { };
+const info = console.info;
+const error = console.error;
+exports.logger = {
+    debug,
+    info,
+    error
+};

package/target/run.d.ts

@@ -0,0 +1,9 @@
+export interface RunOptions {
+    graalvmHome: string;
+    jvmClasspath: string;
+    entrypointName: string;
+    bundleFile: string;
+    resourcesFolder: string;
+    resultsFolder: string;
+}
+export declare const run: (options: RunOptions) => Promise<void>;

package/target/run.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const log_1 = require("./log");
+const run = async (options) => {
+    log_1.logger.info(`Running a Gatling simulation with options:
+ - entrypointName: ${options.entrypointName}
+ - bundleFile: ${options.bundleFile}`);
+    const bundleFolder = path.parse(options.bundleFile).dir;
+    const bundleFileName = path.parse(options.bundleFile).base;
+    const command = `${options.graalvmHome}/bin/java`;
+    const args = [
+        "-server",
+        "-XX:+HeapDumpOnOutOfMemoryError",
+        "-XX:MaxInlineLevel=20",
+        "-XX:MaxTrivialSize=12",
+        "-Xmx1G",
+        "-classpath",
+        `${bundleFolder}:${options.resourcesFolder}:${options.jvmClasspath}`,
+        `-Dgatling.js.bundle.resourcePath=${bundleFileName}`,
+        `-Dgatling.js.entrypointName=${options.entrypointName}`,
+        "io.gatling.app.Gatling",
+        "--results-folder",
+        options.resultsFolder,
+        "--simulation",
+        "io.gatling.js.JsSimulation"
+    ];
+    const process = (0, child_process_1.spawn)(command, args);
+    return new Promise((resolve, reject) => {
+        process.stdout.on("data", (data) => log_1.logger.info(data.toString()));
+        process.stderr.on("data", (data) => log_1.logger.error(data.toString()));
+        process.on("error", (error) => log_1.logger.error("Failed to run Gatling process: " + error.toString()));
+        process.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(Error("Gatling process finished with code " + code));
+            }
+        });
+    });
+};
+exports.run = run;