@depup/artillery 2.0.30-depup.0

package/lib/cmds/run-aci.js

@@ -0,0 +1,91 @@
+// Copyright (c) Artillery Software Inc.
+// SPDX-License-Identifier: BUSL-1.1
+//
+// Non-evaluation use of Artillery on Azure requires a commercial license
+
+const { Command, Flags, Args } = require('@oclif/core');
+const { CommonRunFlags } = require('../cli/common-flags');
+
+const RunCommand = require('./run');
+
+class RunACICommand extends Command {
+  static aliases = ['run:aci'];
+  static strict = false;
+
+  async run() {
+    const { flags, argv, args } = await this.parse(RunACICommand);
+    flags.platform = 'az:aci';
+
+    flags['platform-opt'] = [
+      `region=${flags.region}`,
+      `count=${flags.count}`,
+      `cpu=${flags.cpu}`,
+      `memory=${flags.memory}`,
+      `tenant-id=${flags['tenant-id']}`,
+      `subscription-id=${flags['subscription-id']}`,
+      `storage-account=${flags['storage-account']}`,
+      `blob-container=${flags['blob-container']}`,
+      `resource-group=${flags['resource-group']}`
+    ];
+
+    RunCommand.runCommandImplementation(flags, argv, args);
+  }
+}
+
+RunACICommand.description = `launch a test using Azure ACI
+Launch a test on Azure ACI
+
+Examples:
+
+  To run a test script in my-test.yml on Azure ACI in eastus region
+  with 10 workers:
+
+    $ artillery run:aci --region eastus --count 10 my-test.yml
+`;
+RunACICommand.flags = {
+  ...CommonRunFlags,
+  count: Flags.string({
+    default: '1'
+  }),
+  region: Flags.string({
+    description: 'Azure region to run the test in',
+    default: 'eastus'
+  }),
+  cpu: Flags.string({
+    description:
+      'Number of CPU cores per worker (defaults to 4 CPUs). A number between 1-4.'
+  }),
+  memory: Flags.string({
+    description:
+      'Memory in GB per worker (defaults to 8 GB). A number between 1-16.'
+  }),
+  'tenant-id': Flags.string({
+    description:
+      'Azure tenant ID. May also be set via AZURE_TENANT_ID environment variable.'
+  }),
+  'subscription-id': Flags.string({
+    description:
+      'Azure subscription ID. May also be set via AZURE_SUBSCRIPTION_ID environment variable.'
+  }),
+  'storage-account': Flags.string({
+    description:
+      'Azure Blob Storage account name. May also be set via AZURE_STORAGE_ACCOUNT environment variable.'
+  }),
+  'blob-container': Flags.string({
+    description:
+      'Azure Blob Storage container name. May also be set via AZURE_STORAGE_BLOB_CONTAINER environment variable.'
+  }),
+  'resource-group': Flags.string({
+    description:
+      'Azure Resource Group name. May also be set via AZURE_RESOURCE_GROUP environment variable.'
+  })
+};
+
+RunACICommand.args = {
+  script: Args.string({
+    name: 'script',
+    required: true
+  })
+};
+
+module.exports = RunACICommand;

package/lib/cmds/run-fargate.js

@@ -0,0 +1,192 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { Command, Flags, Args } = require('@oclif/core');
+const { CommonRunFlags } = require('../cli/common-flags');
+const telemetry = require('../telemetry');
+
+const runCluster = require('../platform/aws-ecs/legacy/run-cluster');
+const { supportedRegions } = require('../platform/aws-ecs/legacy/util');
+const PlatformECS = require('../platform/aws-ecs/ecs');
+const { ECS_WORKER_ROLE_NAME } = require('../platform/aws/constants');
+const { Plugin: CloudPlugin } = require('../platform/cloud/cloud');
+const generateId = require('../util/generate-id');
+const dotenv = require('dotenv');
+const path = require('node:path');
+const fs = require('node:fs');
+class RunCommand extends Command {
+  static aliases = ['run:fargate', 'run:ecs', 'run-ecs'];
+  // Enable multiple args:
+  static strict = false;
+
+  async run() {
+    const { flags, _argv, args } = await this.parse(RunCommand);
+    flags['platform-opt'] = [`region=${flags.region}`];
+
+    flags.platform = 'aws:ecs';
+
+    if (flags.dotenv) {
+      const dotEnvPath = path.resolve(process.cwd(), flags.dotenv);
+      try {
+        fs.statSync(dotEnvPath);
+      } catch (_err) {
+        console.log(`WARNING: could not read dotenv file: ${flags.dotenv}`);
+      }
+      dotenv.config({ path: dotEnvPath });
+    }
+
+    const testRunId = process.env.ARTILLERY_TEST_RUN_ID || generateId('t');
+    global.artillery.testRunId = testRunId;
+
+    const cloud = new CloudPlugin(null, null, { flags });
+    global.artillery.cloudEnabled = cloud.enabled;
+    if (cloud.enabled) {
+      try {
+        await cloud.init();
+      } catch (err) {
+        if (err.name === 'CloudAPIKeyMissing') {
+          console.error(
+            'Error: API key is required to record test results to Artillery Cloud'
+          );
+          console.error(
+            'See https://docs.art/get-started-cloud for more information'
+          );
+
+          process.exit(7);
+        } else if (err.name === 'APIKeyUnauthorized') {
+          console.error(
+            'Error: API key is not recognized or is not authorized to record tests'
+          );
+
+          process.exit(7);
+        } else if (err.name === 'PingFailed') {
+          console.error(
+            'Error: unable to reach Artillery Cloud API. This could be due to firewall restrictions on your network'
+          );
+          console.log('Please see https://docs.art/cloud/err-ping');
+          process.exit(7);
+        } else {
+          console.error(
+            'Error: something went wrong connecting to Artillery Cloud'
+          );
+          console.error('Check https://status.artillery.io for status updates');
+          console.error(err);
+        }
+      }
+    }
+
+    flags.taskRoleName = flags['task-role-name'] || ECS_WORKER_ROLE_NAME;
+
+    const ECS = new PlatformECS(
+      null,
+      null,
+      {},
+      {
+        testRunId: 'foo',
+        region: flags.region,
+        taskRoleName: flags.taskRoleName
+      }
+    );
+    await ECS.init();
+
+    process.env.USE_NOOP_BACKEND_STORE = 'true';
+
+    telemetry.capture('run:fargate', {
+      region: flags.region,
+      count: flags.count
+    });
+
+    // Delegate the rest to existing implementation:
+    runCluster(args.script, flags);
+  }
+}
+
+RunCommand.description = `launch a test using AWS ECS/Fargate
+
+Examples:
+
+  To launch a test with 10 load generating workers using AWS Fargate in us-east-1:
+
+    $ artillery run:fargate --count 10 --region us-east-1 my-test.yml
+`;
+
+RunCommand.flags = {
+  ...CommonRunFlags,
+  count: Flags.integer({
+    description: 'Number of load generator workers to launch'
+  }),
+  cluster: Flags.string({
+    description: 'Name of the Fargate/ECS cluster to run the test on'
+  }),
+  region: Flags.string({
+    char: 'r',
+    description: 'The AWS region to run in',
+    options: supportedRegions,
+    default: 'us-east-1'
+  }),
+  secret: Flags.string({
+    multiple: true,
+    description:
+      'Make secrets available to workers. The secret must exist in SSM parameter store for the given region, under /artilleryio/<SECRET_NAME>'
+  }),
+  'launch-type': Flags.string({
+    description: 'The launch type to use for the test. Defaults to Fargate.',
+    options: ['ecs:fargate', 'ecs:ec2']
+  }),
+  spot: Flags.boolean({
+    description:
+      'Use Fargate Spot (https://docs.art/fargate-spot) Ignored when --launch-type is set to ecs:ec2'
+  }),
+  'launch-config': Flags.string({
+    description:
+      'JSON to customize launch configuration of ECS/Fargate tasks (see https://www.artillery.io/docs/reference/cli/run-fargate#using---launch-config)'
+  }),
+  'container-dns-servers': Flags.string({
+    description:
+      'Comma-separated list of DNS servers for Artillery container. Maps to dnsServers parameter in ECS container definition'
+  }),
+  'task-ephemeral-storage': Flags.string({
+    description:
+      'Ephemeral storage in GiB for the worker task. Maps to ephemeralStorage parameter in ECS container definition. Fargate-only.',
+    type: 'integer'
+  }),
+
+  'subnet-ids': Flags.string({
+    description:
+      'Comma-separated list of AWS VPC subnet IDs to launch Fargate tasks in'
+  }),
+  'security-group-ids': Flags.string({
+    description:
+      'Comma-separated list of AWS VPC security group IDs to launch Fargate tasks in'
+  }),
+  'task-role-name': Flags.string({
+    description: 'Custom IAM role name for Fargate containers to assume'
+  }),
+  cpu: Flags.string({
+    description:
+      'Set task vCPU on Fargate (defaults to 4 vCPU). Value may be set as a number of vCPUs between 1-16 (e.g. 4), or as number of vCPU units (e.g. 4096).'
+  }),
+  memory: Flags.string({
+    description:
+      'Set task memory on Fargate (defaults to 8 GB). Value may be set as number of GB between 1-120 (e.g. 8), or as MiB (e.g. 8192)'
+  }),
+  packages: Flags.string({
+    description:
+      'Path to package.json file which lists dependencies for the test script'
+  }),
+  'max-duration': Flags.string({
+    description: 'Maximum duration of the test run'
+  }),
+  'no-assign-public-ip': Flags.boolean({
+    description:
+      'Turn off the default behavior of assigning public IPs to Fargate worker tasks. When this option is used you must make sure tasks have a route to the internet, i.e. via a NAT gateway attached to a private subnet',
+    default: false
+  })
+};
+
+RunCommand.args = {
+  script: Args.string()
+};
+
+module.exports = RunCommand;

package/lib/cmds/run-lambda.js

@@ -0,0 +1,96 @@
+const { Command, Flags, Args } = require('@oclif/core');
+const { CommonRunFlags } = require('../cli/common-flags');
+
+const RunCommand = require('./run');
+
+class RunLambdaCommand extends Command {
+  static aliases = ['run:lambda'];
+  static strict = false;
+
+  async run() {
+    const { flags, argv, args } = await this.parse(RunLambdaCommand);
+
+    flags['platform-opt'] = [
+      `region=${flags.region}`,
+      `memory-size=${flags['memory-size']}`,
+      `architecture=${flags.architecture}`
+    ];
+
+    delete flags.region;
+    delete flags['memory-size'];
+    delete flags.architecture;
+
+    if (flags['lambda-role-arn']) {
+      flags['platform-opt'].push(`lambda-role-arn=${flags['lambda-role-arn']}`);
+    }
+
+    if (flags['security-group-ids']) {
+      flags['platform-opt'].push(
+        `security-group-ids=${flags['security-group-ids']}`
+      );
+    }
+
+    if (flags['subnet-ids']) {
+      flags['platform-opt'].push(`subnet-ids=${flags['subnet-ids']}`);
+    }
+
+    flags.platform = 'aws:lambda';
+
+    RunCommand.runCommandImplementation(flags, argv, args);
+  }
+}
+
+RunLambdaCommand.description = `launch a test using AWS Lambda
+Launch a test on AWS Lambda
+
+Examples:
+
+  To run a test script in my-test.yml on AWS Lambda in us-east-1 region
+  distributed across 10 Lambda functions:
+
+    $ artillery run:lambda --region us-east-1 --count 10 my-test.yml
+`;
+RunLambdaCommand.flags = {
+  ...CommonRunFlags,
+  payload: Flags.string({
+    char: 'p',
+    description: 'Specify a CSV file for dynamic data'
+  }),
+  count: Flags.string({
+    // locally defaults to number of CPUs with mode = distribute
+    default: '1'
+  }),
+  architecture: Flags.string({
+    description: 'Architecture of the Lambda function',
+    default: 'arm64',
+    options: ['arm64', 'x86_64']
+  }),
+  'memory-size': Flags.string({
+    description: 'Memory size of the Lambda function',
+    default: '4096'
+  }),
+  region: Flags.string({
+    description: 'AWS region to run the test in',
+    default: 'us-east-1'
+  }),
+  'lambda-role-arn': Flags.string({
+    description: 'ARN of the IAM role to use for the Lambda function'
+  }),
+  'security-group-ids': Flags.string({
+    description:
+      'Comma-separated list of security group IDs to use for the Lambda function'
+  }),
+  'subnet-ids': Flags.string({
+    description:
+      'Comma-separated list of subnet IDs to use for the Lambda function'
+  })
+};
+
+RunLambdaCommand.args = {
+  script: Args.string({
+    name: 'script',
+    required: true
+  })
+};
+
+module.exports = RunLambdaCommand;