@gatling.io/cli 3.11.7 → 3.12.0

package/target/index.js

@@ -1,340 +1,5 @@
 #!/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 enterprise_1 = require("./enterprise");
-const simulations_1 = require("./simulations");
-const log_1 = require("./log");
-const readline_1 = require("./readline");
-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 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: if only one *.gatling.js or *.gatling.ts file is found, will execute that simulation)");
-const simulationWithDefaults = (options, simulationsFound, interactive) => {
-    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 if (interactive) {
-        const idx = (0, readline_1.keyInSelectPaginated)(simulationsFound.map((s) => s.name).sort((a, b) => a.localeCompare(b)), "Choose a simulation to run");
-        if (idx >= 0) {
-            const simulation = simulationsFound[idx].name;
-            log_1.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)})`);
-    }
-};
-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 packageFileOption = new commander_1.Option("--package-file <value>", "The target package file path when packaging simulations for Gatling Enterprise (must have a .zip extension)").default("target/package.zip");
-const validatePackageFile = (options) => {
-    if (!options.packageFile.endsWith(".zip")) {
-        throw Error(`'${options.packageFile}' is not a valid package file path: should have a .zip extension`);
-    }
-    return options.packageFile;
-};
-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: 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);
-const memoryOption = new commander_1.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;
-});
-const nonInteractiveOption = new commander_1.Option("--non-interactive", "Switch to non-interactive mode and fail if no simulation is explicitly specified").default(false);
-const runParametersArgument = new commander_1.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");
-const parseRunParameters = (args) => {
-    const parsedParameters = {};
-    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;
-};
-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.installGatlingJs)({ gatlingHome });
-    log_1.logger.info(`graalvmHome=${graalvmHome}`);
-    log_1.logger.info(`coursierBinary=${coursierBinary}`);
-    log_1.logger.info(`jvmClasspath=${jvmClasspath}`);
-});
-program
-    .command("build")
-    .description("Build Gatling simulations")
-    .addOption(sourcesFolderOption)
-    .addOption(bundleFileOption)
-    .addOption(typescriptOption)
-    .action(async (options) => {
-    const sourcesFolder = options.sourcesFolder;
-    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 from an already built bundle")
-    .addOption(graalvmHomeMandatoryOption)
-    .addOption(jvmClasspathMandatoryOption)
-    .addOption(simulationRequiredOption)
-    .addOption(bundleFileOption)
-    .addOption(resourcesFolderOption)
-    .addOption(resultsFolderOption)
-    .addOption(memoryOption)
-    .addArgument(runParametersArgument)
-    .action(async (args, options) => {
-    const graalvmHome = options.graalvmHome;
-    const jvmClasspath = options.jvmClasspath;
-    const simulation = options.simulation;
-    const bundleFile = validateBundleFile(options);
-    const resourcesFolder = options.resourcesFolder;
-    const resultsFolder = options.resultsFolder;
-    const memory = options.memory;
-    const runParameters = parseRunParameters(args);
-    await (0, run_1.runSimulation)({
-        graalvmHome,
-        jvmClasspath,
-        simulation: simulation,
-        bundleFile,
-        resourcesFolder,
-        resultsFolder,
-        memory,
-        runParameters
-    });
-});
-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(nonInteractiveOption)
-    .addArgument(runParametersArgument)
-    .action(async (args, options) => {
-    const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const sourcesFolder = options.sourcesFolder;
-    const bundleFile = validateBundleFile(options);
-    const resourcesFolder = options.resourcesFolder;
-    const resultsFolder = options.resultsFolder;
-    const memory = options.memory;
-    const nonInteractive = options.nonInteractive;
-    const runParameters = parseRunParameters(args);
-    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
-    const typescript = typescriptWithDefaults(options, simulations);
-    const simulation = simulationWithDefaults(options, simulations, !nonInteractive);
-    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, simulations });
-    await (0, run_1.runSimulation)({
-        graalvmHome,
-        jvmClasspath,
-        simulation,
-        bundleFile,
-        resourcesFolder,
-        resultsFolder,
-        memory,
-        runParameters
-    });
-});
-program
-    .command("recorder")
-    .description("Run the Gatling recorder")
-    .addOption(gatlingHomeOption)
-    .addOption(sourcesFolderOption)
-    .addOption(typescriptOption)
-    .addOption(resourcesFolderOption)
-    .action(async (options) => {
-    const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const sourcesFolder = options.sourcesFolder;
-    const resourcesFolder = options.resourcesFolder;
-    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(packageFileOption)
-    .addOption(typescriptOption)
-    .action(async (options) => {
-    const sourcesFolder = options.sourcesFolder;
-    const resourcesFolder = options.resourcesFolder;
-    const bundleFile = validateBundleFile(options);
-    const packageFile = validatePackageFile(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, enterprise_1.enterprisePackage)({ bundleFile, resourcesFolder, packageFile, simulations });
-});
-const urlOption = new commander_1.Option("--url <value>", "URL of Gatling Enterprise")
-    .default("https://cloud.gatling.io")
-    .hideHelp();
-const apiTokenOption = new commander_1.Option("--api-token <value>", "API Token on Gatling Enterprise. Prefer configuration using `GATLING_ENTERPRISE_API_TOKEN` environment variable.");
-// Plugin configuration
-const controlPlaneUrlOption = new commander_1.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.");
-// Descriptor file
-const packageDescriptorFilenameOption = new commander_1.Option("--package-descriptor-filename <value>", "Path to a package descriptor inside the .gatling folder").default("package.conf");
-const enterpriseBundleAndPackage = async (options) => {
-    const gatlingHome = gatlingHomeDirWithDefaults(options);
-    const sourcesFolder = options.sourcesFolder;
-    const bundleFile = validateBundleFile(options);
-    const resourcesFolder = options.resourcesFolder;
-    const resultsFolder = options.resultsFolder;
-    const simulations = await (0, simulations_1.findSimulations)(sourcesFolder);
-    const typescript = typescriptWithDefaults(options, simulations);
-    // Base
-    const url = options.url;
-    const apiToken = options.apiToken;
-    // Plugin configuration
-    const controlPlaneUrl = options.controlPlaneUrl;
-    const nonInteractive = options.nonInteractive;
-    // Descriptor file
-    const packageDescriptorFilename = options.packageDescriptorFilename;
-    // Deployment info
-    const packageFile = validatePackageFile(options);
-    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, simulations });
-    await (0, enterprise_1.enterprisePackage)({ bundleFile, resourcesFolder, packageFile, simulations });
-    return {
-        graalvmHome,
-        jvmClasspath,
-        bundleFile,
-        resourcesFolder,
-        resultsFolder,
-        // Base
-        url,
-        apiToken,
-        // Plugin configuration
-        controlPlaneUrl,
-        nonInteractive,
-        // Descriptor file
-        packageDescriptorFilename,
-        // Deployment info
-        packageFile
-    };
-};
-program
-    .command("enterprise-deploy")
-    .description("Deploy a package and configured simulations")
-    .addOption(sourcesFolderOption)
-    .addOption(resourcesFolderOption)
-    .addOption(bundleFileOption)
-    .addOption(resultsFolderOption)
-    // Base
-    .addOption(urlOption)
-    .addOption(apiTokenOption)
-    // Plugin configuration
-    .addOption(controlPlaneUrlOption)
-    .addOption(nonInteractiveOption)
-    // Descriptor file
-    .addOption(packageDescriptorFilenameOption)
-    // Deployment info
-    .addOption(packageFileOption)
-    .action(async (options) => {
-    const deployOptions = await enterpriseBundleAndPackage(options);
-    await (0, enterprise_1.enterpriseDeploy)(deployOptions);
-});
-// Deployment info
-const enterpriseSimulationOption = new commander_1.Option("--enterprise-simulation <value>", "Specify the simulation name directly to bypass the prompt using the following command.");
-const runTitleOption = new commander_1.Option("--run-title <value>", "Allows setting a title for your run reports.");
-const runDescriptionOption = new commander_1.Option("--run-description <value>", "Allows setting a description for your run reports summary.");
-const waitForRunEndOption = new commander_1.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);
-program
-    .command("enterprise-start")
-    .description("Start a simulation deployed with `enterprise-deploy`")
-    .addOption(sourcesFolderOption)
-    .addOption(resourcesFolderOption)
-    .addOption(bundleFileOption)
-    .addOption(resultsFolderOption)
-    // Base
-    .addOption(urlOption)
-    .addOption(apiTokenOption)
-    // Plugin configuration
-    .addOption(controlPlaneUrlOption)
-    .addOption(nonInteractiveOption)
-    // Descriptor file
-    .addOption(packageDescriptorFilenameOption)
-    // Deployment info
-    .addOption(packageFileOption)
-    // Start
-    .addOption(enterpriseSimulationOption)
-    .addOption(runTitleOption)
-    .addOption(runDescriptionOption)
-    .addOption(waitForRunEndOption)
-    .action(async (options) => {
-    const deployOptions = await enterpriseBundleAndPackage(options);
-    if (options.nonInteractive && options.enterpriseSimulation === undefined) {
-        throw new Error(`No simulation specified when using non-interactive mode`);
-    }
-    await (0, enterprise_1.enterpriseStart)({
-        ...deployOptions,
-        // Start
-        enterpriseSimulation: options.enterpriseSimulation,
-        runTitle: options.runTitle,
-        runDescription: options.runDescription,
-        waitForRunEnd: options.waitForRunEnd
-    });
-});
-program.parse(process.argv);
+const commands_1 = require("./commands");
+commands_1.program.parse(process.argv);

package/target/run.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRecorder = exports.runSimulation = void 0;
 const log_1 = require("./log");
-const versions_1 = require("./dependencies/versions");
+const dependencies_1 = require("./dependencies");
 const java_1 = require("./java");
 const runSimulation = async (options) => {
     log_1.logger.info(`Running a Gatling simulation with options:
@@ -11,11 +11,13 @@ const runSimulation = async (options) => {
  - resourcesFolder: ${options.resourcesFolder}
  - resultsFolder: ${options.resultsFolder}`);
     const additionalClasspathElements = [options.resourcesFolder];
+    const jitTuningArgs = ["-XX:JVMCINativeLibraryThreadFraction=0.8", "-Dgraal.MethodInlineBailoutLimit=500"];
     const memoryArgs = options.memory !== undefined ? [`-Xms${options.memory}M`, `-Xmx${options.memory}M`] : [];
     const javaArgs = [
         ...Object.entries(options.runParameters).map(([key, value]) => `-D${key}=${value}`),
         `-Dgatling.js.bundle.filePath=${options.bundleFile}`,
         `-Dgatling.js.simulation=${options.simulation}`,
+        ...jitTuningArgs,
         ...memoryArgs
     ];
     const simulationArgs = [
@@ -26,7 +28,7 @@ const runSimulation = async (options) => {
         "--launcher",
         "gatling-js-cli",
         "--build-tool-version",
-        versions_1.versions.gatling.jsAdapter
+        dependencies_1.versions.gatling.jsAdapter
     ];
     return (0, java_1.runJavaProcess)(options, "io.gatling.app.Gatling", additionalClasspathElements, javaArgs, simulationArgs);
 };

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./",
+    "rootDir": "src",
+    "outDir": "target",
+    "lib": ["es2021", "dom"],
+    "target": "es2021",
+    "module": "node16",
+    "esModuleInterop": true,
+    "moduleResolution": "node16",
+    "declaration": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/*.test.ts"]
+}