@gatling.io/cli 3.11.3 → 3.11.4-M2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gatling.io/cli",
-  "version": "3.11.3",
+  "version": "3.11.4-M2",
   "license": "Apache-2.0",
   "bin": {
     "gatling": "target/index.js"
@@ -8,6 +8,7 @@
   "main": "target/index.js",
   "types": "target/index.d.ts",
   "dependencies": {
+    "archiver": "7.0.1",
     "axios": "1.6.8",
     "commander": "12.0.0",
     "decompress": "4.2.1",
@@ -15,6 +16,7 @@
     "esbuild-plugin-tsc": "0.4.0"
   },
   "devDependencies": {
+    "@types/archiver": "6.0.2",
     "@types/decompress": "4.2.7",
     "@types/node": "20.12.12",
     "prettier": "3.2.5",

package/target/bundle.d.ts

@@ -1,6 +1,8 @@
+import { SimulationFile } from "./simulations";
 export interface BundleOptions {
     sourcesFolder: string;
     bundleFile: string;
     typescript: boolean;
+    simulations: SimulationFile[];
 }
 export declare const bundle: (options: BundleOptions) => Promise<void>;

package/target/bundle.js

@@ -29,17 +29,13 @@ 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 promises_1 = __importDefault(require("fs/promises"));
 const log_1 = require("./log");
 const bundle = async (options) => {
-    log_1.logger.info(`Packaging a Gatling simulation with options:
+    log_1.logger.info(`Bundling a Gatling simulation with options:
  - sourcesFolder: ${options.sourcesFolder}
- - bundleFile: ${options.bundleFile}`);
-    const children = await promises_1.default.readdir(options.sourcesFolder, { recursive: false });
-    const contents = children
-        .filter((f) => (options.typescript ? f.endsWith(".gatling.ts") : f.endsWith(".gatling.js")))
-        .map((f) => `export { default as "${f.slice(0, -11)}" } from "./${f}";`)
-        .join("\n");
+ - bundleFile: ${options.bundleFile}
+ - typescript: ${options.typescript}`);
+    const contents = options.simulations.map((s) => `export { default as "${s.name}" } from "./${s.path}";`).join("\n");
     const plugins = options.typescript ? [(0, esbuild_plugin_tsc_1.default)({ force: true })] : [];
     await esbuild.build({
         stdin: {

package/target/dependencies/versions.js

@@ -9,6 +9,6 @@ exports.versions = {
     coursier: "2.1.10",
     gatling: {
         core: "3.11.3",
-        jsAdapter: "3.11.3"
+        jsAdapter: "3.11.4-M2"
     }
 };

package/target/enterprisePackage.d.ts

@@ -0,0 +1,8 @@
+import { SimulationFile } from "./simulations";
+export interface EnterprisePackageOptions {
+    bundleFile: string;
+    resourcesFolder: string;
+    enterprisePackageFile: string;
+    simulations: SimulationFile[];
+}
+export declare const enterprisePackage: (options: EnterprisePackageOptions) => Promise<void>;

package/target/enterprisePackage.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enterprisePackage = void 0;
+const archiver_1 = __importDefault(require("archiver"));
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = require("stream/promises");
+const zlib_1 = require("zlib");
+const versions_1 = require("./dependencies/versions");
+const log_1 = require("./log");
+const enterprisePackage = async (options) => {
+    log_1.logger.info(`Packaging a Gatling simulation with options:
+ - bundleFile: ${options.bundleFile}
+ - enterprisePackageFile: ${options.enterprisePackageFile}`);
+    const manifest = generateManifest(options.simulations.map((s) => s.name));
+    const output = fs_1.default.createWriteStream(options.enterprisePackageFile);
+    const archive = (0, archiver_1.default)("zip", {
+        zlib: { level: zlib_1.constants.Z_MAX_LEVEL }
+    });
+    archive.on("warning", (err) => {
+        // The pipeline will rethrow errors but not warnings. We don't want to ignore warnings from the archiver, because
+        // they include things like 'no such file or directory'.
+        throw err;
+    });
+    archive.file(options.bundleFile, { name: "bundle.js" });
+    archive.append(Buffer.from(manifest), { name: "META-INF/MANIFEST.MF" });
+    archive.directory(options.resourcesFolder + "/", false);
+    archive.finalize();
+    await (0, promises_1.pipeline)(archive, output);
+    log_1.logger.info(`Package for Gatling Enterprise created at ${options.enterprisePackageFile}`);
+};
+exports.enterprisePackage = enterprisePackage;
+const generateManifest = (simulationNames) => {
+    const utf8Encoder = new TextEncoder();
+    const eol = utf8Encoder.encode("\n");
+    const continuation = utf8Encoder.encode("\n ");
+    const lines = [
+        "Manifest-Version: 1.0",
+        "Implementation-Title: gatling-javascript",
+        `Implementation-Version: ${versions_1.versions.gatling.jsAdapter}`,
+        "Implementation-Vendor: GatlingCorp",
+        "Specification-Vendor: GatlingCorp",
+        "Gatling-Context: js",
+        `Gatling-Version: ${versions_1.versions.gatling.core}`,
+        "Gatling-Packager: javascript",
+        `Gatling-Packager-Version: ${versions_1.versions.gatling.jsAdapter}`,
+        `Gatling-Simulations: ${simulationNames.join(",")}`,
+        `Java-Version: ${versions_1.versions.graalvm.jdk.split(".")[0]}`
+    ];
+    let totalLength = 0;
+    const buffer = [];
+    for (const line of lines) {
+        let lineLength = 0;
+        for (const char of line) {
+            const bytes = utf8Encoder.encode(char);
+            const byteLength = bytes.byteLength;
+            if (lineLength + byteLength > 71) {
+                buffer.push(continuation);
+                buffer.push(bytes);
+                // reset length for the new line (with +1 for leading space)
+                lineLength = byteLength + 1;
+                totalLength += byteLength + 2;
+            }
+            else {
+                buffer.push(bytes);
+                lineLength += byteLength;
+                totalLength += byteLength;
+            }
+        }
+        buffer.push(eol);
+        totalLength += 1;
+    }
+    const manifest = new Uint8Array(totalLength);
+    let cursor = 0;
+    for (const elt of buffer) {
+        manifest.set(elt, cursor);
+        cursor += elt.byteLength;
+    }
+    return manifest;
+};

package/target/index.js

@@ -8,6 +8,8 @@ const commander_1 = require("commander");
 const os_1 = __importDefault(require("os"));
 const bundle_1 = require("./bundle");
 const dependencies_1 = require("./dependencies");
+const enterprisePackage_1 = require("./enterprisePackage");
+const simulations_1 = require("./simulations");
 const log_1 = require("./log");
 const run_1 = require("./run");
 const program = new commander_1.Command()
@@ -17,11 +19,42 @@ const program = new commander_1.Command()
 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 sourcesFolderOption = new commander_1.Option("--sources-folder <value>", "The sources folder path").default("src");
-const simulationOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name").default("default", '"default", compatible with using "export default"');
-const bundleFileOption = new commander_1.Option("--bundle-file <value>", "The simulation target bundle file path").default("target/bundle.js");
+const simulationOption = new commander_1.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)");
+const simulationWithDefaults = (options, simulationsFound) => {
+    if (options.simulation !== undefined) {
+        return options.simulation;
+    }
+    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 {
+        throw new Error(`Several simulations found, specify one using the --simulation option (available simulations: ${simulationsFound.map((s) => s.name)})`);
+    }
+};
+const simulationRequiredOption = new commander_1.Option("--simulation <value>", "The simulation entry point function name").makeOptionMandatory(true);
+const bundleFileOption = new commander_1.Option("--bundle-file <value>", "The target bundle file path when building simulations (must have a .js extension)").default("target/bundle.js");
+const validateBundleFile = (options) => {
+    if (!options.bundleFile.endsWith(".js")) {
+        throw Error(`'${options.bundleFile}' is not a valid bundle file path: should have a .js extension`);
+    }
+    return options.bundleFile;
+};
+const enterprisePackageFileOption = new commander_1.Option("--enterprise-package-file <value>", "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)").default("target/package.zip");
+const validateEnterprisePackageFile = (options) => {
+    if (!options.enterprisePackageFile.endsWith(".zip")) {
+        throw Error(`'${options.enterprisePackageFile}' is not a valid package file path: should have a .zip extension`);
+    }
+    return options.enterprisePackageFile;
+};
 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("target/gatling");
-const typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code").default(false);
+const typescriptOption = new commander_1.Option("--typescript", "Use the typescript compiler to compile your code (default: true if the sourcesFolder contains any *.gatling.ts file, false otherwise)");
+const typescriptWithDefaults = (options, simulationsFound) => options.typescript !== undefined
+    ? options.typescript
+    : simulationsFound.findIndex((s) => s.type === "typescript") >= 0;
 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
@@ -37,22 +70,23 @@ program
 });
 program
     .command("build")
-    .description("Build a Gatling simulation")
+    .description("Build Gatling simulations")
     .addOption(sourcesFolderOption)
     .addOption(bundleFileOption)
     .addOption(typescriptOption)
     .action(async (options) => {
     const sourcesFolder = options.sourcesFolder;
-    const bundleFile = options.bundleFile;
-    const typescript = options.typescript;
-    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript });
+    const bundleFile = validateBundleFile(options);
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
 });
 program
     .command("run-only")
-    .description("Run a Gatling simulation")
+    .description("Run a Gatling simulation from an already built bundle")
     .addOption(graalvmHomeMandatoryOption)
     .addOption(jvmClasspathMandatoryOption)
-    .addOption(simulationOption)
+    .addOption(simulationRequiredOption)
     .addOption(bundleFileOption)
     .addOption(resourcesFolderOption)
     .addOption(resultsFolderOption)
@@ -60,7 +94,7 @@ program
     const graalvmHome = options.graalvmHome;
     const jvmClasspath = options.jvmClasspath;
     const simulation = options.simulation;
-    const bundleFile = options.bundleFile;
+    const bundleFile = validateBundleFile(options);
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
     await (0, run_1.runSimulation)({
@@ -85,16 +119,17 @@ program
     .action(async (options) => {
     const gatlingHome = gatlingHomeDirWithDefaults(options);
     const sourcesFolder = options.sourcesFolder;
-    const simulation = options.simulation;
-    const bundleFile = options.bundleFile;
+    const bundleFile = validateBundleFile(options);
     const resourcesFolder = options.resourcesFolder;
     const resultsFolder = options.resultsFolder;
-    const typescript = options.typescript;
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    const simulation = simulationWithDefaults(options, simulations);
     const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installGatlingJs)({ gatlingHome });
     log_1.logger.debug(`graalvmHome=${graalvmHome}`);
     log_1.logger.debug(`coursierBinary=${coursierBinary}`);
     log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
-    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript });
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
     await (0, run_1.runSimulation)({ graalvmHome, jvmClasspath, simulation, bundleFile, resourcesFolder, resultsFolder });
 });
 program
@@ -108,11 +143,30 @@ program
     const gatlingHome = gatlingHomeDirWithDefaults(options);
     const sourcesFolder = options.sourcesFolder;
     const resourcesFolder = options.resourcesFolder;
-    const typescript = options.typescript;
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
     const { graalvmHome, coursierBinary, jvmClasspath } = await (0, dependencies_1.installRecorder)({ gatlingHome });
     log_1.logger.debug(`graalvmHome=${graalvmHome}`);
     log_1.logger.debug(`coursierBinary=${coursierBinary}`);
     log_1.logger.debug(`jvmClasspath=${jvmClasspath}`);
     await (0, run_1.runRecorder)({ graalvmHome, jvmClasspath, sourcesFolder, typescript, resourcesFolder });
 });
+program
+    .command("enterprise-package")
+    .description("Build Gatling simulations and package them for Gatling Enterprise")
+    .addOption(sourcesFolderOption)
+    .addOption(resourcesFolderOption)
+    .addOption(bundleFileOption)
+    .addOption(enterprisePackageFileOption)
+    .addOption(typescriptOption)
+    .action(async (options) => {
+    const sourcesFolder = options.sourcesFolder;
+    const resourcesFolder = options.resourcesFolder;
+    const bundleFile = validateBundleFile(options);
+    const enterprisePackageFile = validateEnterprisePackageFile(options);
+    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
+    const typescript = typescriptWithDefaults(options, simulations);
+    await (0, bundle_1.bundle)({ sourcesFolder, bundleFile, typescript, simulations });
+    await (0, enterprisePackage_1.enterprisePackage)({ bundleFile, resourcesFolder, enterprisePackageFile, simulations });
+});
 program.parse(process.argv);

package/target/run.js

@@ -8,7 +8,9 @@ const os_1 = require("./dependencies/os");
 const runSimulation = async (options) => {
     log_1.logger.info(`Running a Gatling simulation with options:
  - simulation: ${options.simulation}
- - bundleFile: ${options.bundleFile}`);
+ - bundleFile: ${options.bundleFile}
+ - resourcesFolder: ${options.resourcesFolder}
+ - resultsFolder: ${options.resultsFolder}`);
     const additionalClasspathElements = [options.resourcesFolder];
     const javaArgs = [
         `-Dgatling.js.bundle.filePath=${options.bundleFile}`,
@@ -28,7 +30,10 @@ const runSimulation = async (options) => {
 };
 exports.runSimulation = runSimulation;
 const runRecorder = async (options) => {
-    log_1.logger.info("Running the Gatling Recorder");
+    log_1.logger.info(`Running the Gatling Recorder with options:
+ - sourcesFolder: ${options.sourcesFolder}
+ - resourcesFolder: ${options.resourcesFolder}
+ - typescript: ${options.typescript}`);
     const recorderArgs = [
         "--simulations-folder",
         options.sourcesFolder,

package/target/simulations.d.ts

@@ -0,0 +1,6 @@
+export interface SimulationFile {
+    path: string;
+    name: string;
+    type: "javascript" | "typescript";
+}
+export declare const findSimulations: (sourcesFolder: string) => Promise<Array<SimulationFile>>;

package/target/simulations.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSimulations = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const findSimulations = async (sourcesFolder) => {
+    const children = await promises_1.default.readdir(sourcesFolder, { recursive: false });
+    const simulations = children
+        .filter((path) => path.endsWith(".gatling.js") || path.endsWith(".gatling.ts"))
+        .map((path) => ({
+        path,
+        name: path.slice(0, -11),
+        type: path.endsWith(".ts") ? "typescript" : "javascript"
+    }));
+    const duplicates = simulations.filter((value, index) => simulations.findIndex((other) => other.name === value.name) !== index);
+    if (duplicates.length > 0) {
+        throw Error(`Found ambiguous simulation name(s) ${duplicates.map((s) => s.name)}: found as both *.gatling.js and *.gatling.ts file(s)`);
+    }
+    return simulations;
+};
+exports.findSimulations = findSimulations;