@depup/artillery 2.0.30-depup.0

package/lib/platform/aws-ecs/legacy/create-test.js

@@ -0,0 +1,247 @@
+
+
+const A = require('async');
+const debug = require('debug')('commands:create-test');
+
+const { getBucketName } = require('./util');
+const createS3Client = require('./create-s3-client');
+
+const path = require('node:path');
+
+const fs = require('node:fs');
+
+const { createBOM, prettyPrint } = require('./bom');
+
+const { PutObjectCommand } = require('@aws-sdk/client-s3');
+
+function tryCreateTest(scriptPath, options) {
+  createTest(scriptPath, options);
+}
+
+async function createTest(scriptPath, options, callback) {
+  const absoluteScriptPath = path.resolve(process.cwd(), scriptPath);
+
+  const contextPath = options.context
+    ? path.resolve(options.context)
+    : path.dirname(absoluteScriptPath);
+
+  debug('script:', absoluteScriptPath);
+  debug('root:', contextPath);
+
+  const context = {
+    contextDir: contextPath,
+    scriptPath: absoluteScriptPath,
+    originalScriptPath: scriptPath,
+    name: options.name, // test name, eg simple-bom or aht_$UUID
+    manifestPath: options.manifestPath,
+    packageJsonPath: options.packageJsonPath,
+    flags: options.flags
+  };
+
+  if (typeof options.config === 'string') {
+    const absoluteConfigPath = path.resolve(process.cwd(), options.config);
+    context.configPath = absoluteConfigPath;
+  }
+
+  if (options.customSyncClient) {
+    context.customSyncClient = options.customSyncClient;
+  }
+
+  return new Promise((resolve, reject) => {
+    A.waterfall(
+      [
+        A.constant(context),
+        async (context) => {
+          if (!context.customSyncClient) {
+            context.s3Bucket = await getBucketName();
+            return context;
+          } else {
+            context.s3Bucket = 'S3_BUCKET_ARGUMENT_NOT_USED_ON_AZURE';
+            return context;
+          }
+        },
+        prepareManifest,
+        printManifest,
+        syncS3,
+        writeTestMetadata
+      ],
+      (err, context) => {
+        if (err) {
+          console.log(err);
+          return;
+        }
+
+        if (callback) {
+          callback(err, context);
+        } else if (err) {
+          reject(err);
+        } else {
+          resolve(context);
+        }
+      }
+    );
+  });
+}
+
+function prepareManifest(context, callback) {
+  let fileToAnalyse = context.scriptPath;
+  const extraFiles = [];
+  if (context.configPath) {
+    debug('context has been provided; extraFiles =', extraFiles);
+    fileToAnalyse = context.configPath;
+    extraFiles.push(context.scriptPath);
+  }
+
+  createBOM(
+    fileToAnalyse,
+    extraFiles,
+    {
+      packageJsonPath: context.packageJsonPath,
+      flags: context.flags,
+      scenarioPath: context.scriptPath
+    },
+    (err, bom) => {
+      debug(err);
+      debug(bom);
+      context.manifest = bom;
+      return callback(err, context);
+    }
+  );
+}
+
+function printManifest(context, callback) {
+  prettyPrint(context.manifest);
+  return callback(null, context);
+}
+
+async function syncS3(context) {
+  let s3;
+  if (context.customSyncClient) {
+    s3 = context.customSyncClient;
+  } else {
+    s3 = createS3Client();
+  }
+
+  const prefix = `tests/${context.name}`;
+
+  context.s3Prefix = prefix;
+
+  debug('Will try syncing to:', context.s3Bucket);
+
+  debug('Manifest: ', context.manifest);
+
+  // Iterate through manifest, for each element: has orig (local source) and noPrefix (S3
+  // destination) properties
+  return new Promise((resolve, reject) => {
+    A.eachLimit(
+      context.manifest.files,
+      3,
+      async (item, eachDone) => {
+        // If we can't read the file, it may have been specified with a
+        // template in its name, e.g. a payload file like:
+        // {{ $environment }}-users.csv
+        // If so, ignore it, hope config.includeFiles was used, and let
+        // "artillery run" in the worker deal with it.
+        let body;
+        try {
+          body = fs.readFileSync(item.orig);
+        } catch (fsErr) {
+          debug(fsErr);
+        }
+
+        if (!body) {
+          return eachDone(null, context);
+        }
+
+        // Filter bundled packages from package.json before upload
+        if (item.noPrefix === 'package.json') {
+          const pkg = JSON.parse(body.toString());
+          const filterBundled = (deps) => {
+            if (!deps) return deps;
+            const filtered = {};
+            for (const [name, version] of Object.entries(deps)) {
+              if (
+                name !== 'artillery' &&
+                name !== 'playwright' &&
+                !name.startsWith('@playwright/')
+              ) {
+                filtered[name] = version;
+              }
+            }
+            return filtered;
+          };
+          pkg.dependencies = filterBundled(pkg.dependencies);
+          pkg.devDependencies = filterBundled(pkg.devDependencies);
+          body = Buffer.from(JSON.stringify(pkg, null, 2));
+        }
+
+        const key = `${context.s3Prefix}/${item.noPrefixPosix}`;
+        await s3.send(
+          new PutObjectCommand({
+            Bucket: context.s3Bucket,
+            Key: key,
+            Body: body
+          })
+        );
+      },
+      (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(context);
+        }
+      }
+    );
+  });
+}
+
+// create just overwrites an existing test for now
+async function writeTestMetadata(context) {
+  const metadata = {
+    createdOn: Date.now(),
+    name: context.name,
+    modules: context.manifest.modules
+  };
+
+  // Here we need to provide config information (if given) -- so that the worker knows how to load it
+  if (context.configPath) {
+    const res = context.manifest.files.filter((o) => {
+      return o.orig === context.configPath;
+    });
+    const newConfigPath = res[0].noPrefixPosix; // if we have been given a config, we must have an entry
+    metadata.configPath = newConfigPath;
+  }
+
+  const newScriptPath = context.manifest.files.filter((o) => {
+    return o.orig === context.scriptPath;
+  })[0].noPrefixPosix;
+  metadata.scriptPath = newScriptPath;
+
+  debug('metadata', metadata);
+
+  let s3 = null;
+  if (context.customSyncClient) {
+    s3 = context.customSyncClient;
+  } else {
+    s3 = createS3Client();
+  }
+
+  const key = `${context.s3Prefix}/metadata.json`; // TODO: Rename to something less likely to clash
+  debug('metadata location:', `${context.s3Bucket}/${key}`);
+  await s3.send(
+    new PutObjectCommand({
+      Body: JSON.stringify(metadata),
+      Bucket: context.s3Bucket,
+      Key: key
+    })
+  );
+
+  return context;
+}
+
+module.exports = {
+  tryCreateTest,
+  createTest,
+  syncS3,
+  prepareManifest
+};

package/lib/platform/aws-ecs/legacy/errors.js

@@ -0,0 +1,34 @@
+class TestNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'TestNotFoundError';
+  }
+}
+
+class NoAvailableQueueError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'NoAvailableQueueError';
+  }
+}
+
+class ClientServerVersionMismatchError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'ClientServerMismatchError';
+  }
+}
+
+class ConsoleOutputSerializeError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'OutputSerializeError';
+  }
+}
+
+module.exports = {
+  TestNotFoundError,
+  NoAvailableQueueError,
+  ClientServerVersionMismatchError,
+  ConsoleOutputSerializeError
+};

package/lib/platform/aws-ecs/legacy/find-public-subnets.js

@@ -0,0 +1,149 @@
+const assert = require('node:assert').strict;
+const {
+  EC2Client,
+  DescribeRouteTablesCommand,
+  DescribeVpcsCommand,
+  DescribeSubnetsCommand
+} = require('@aws-sdk/client-ec2');
+
+class VPCSubnetFinder {
+  constructor(opts) {
+    this.ec2 = new EC2Client(opts);
+  }
+
+  async getRouteTables(vpcId) {
+      const rts = await this.ec2.send(
+        new DescribeRouteTablesCommand({
+          Filters: [
+            {
+              Name: 'vpc-id',
+              Values: [vpcId]
+            }
+          ]
+        })
+      );
+
+      return rts.RouteTables;
+  }
+
+  async findDefaultVpc() {
+      const vpcRes = await this.ec2.send(
+        new DescribeVpcsCommand({
+          Filters: [
+            {
+              Name: 'isDefault',
+              Values: ['true']
+            }
+          ]
+        })
+      );
+
+      assert.ok(vpcRes.Vpcs.length <= 1);
+
+      if (vpcRes.Vpcs.length !== 1) {
+        return null;
+      } else {
+        return vpcRes.Vpcs[0].VpcId;
+      }
+  }
+
+  async getSubnets(vpcId) {
+      const subRes = await this.ec2.send(
+        new DescribeSubnetsCommand({
+          Filters: [
+            {
+              Name: 'vpc-id',
+              Values: [vpcId]
+            }
+          ]
+        })
+      );
+
+      return subRes.Subnets;
+  }
+
+  isSubnetPublic(routeTables, subnetId) {
+    //
+    // Inspect associations of each route table (of a specific VPC). A route
+    // table record has an Associations field, which is a list of association
+    // objects. There are two types of those:
+    //
+    // 1. An implicit association, which is indicated by field Main set to
+    //    true and no explicit subnet id.
+    // 2. An explicit association, which is indicated by field Main set to
+    //    false, and a SubnetId field containing a subnet id.
+    //
+
+    // Route table for the subnet - can there only be one?
+    let subnetTable = routeTables.filter((rt) => {
+      const explicitAssoc = rt.Associations.filter((assoc) => {
+        return assoc.SubnetId && assoc.SubnetId === subnetId;
+      });
+
+      assert.ok(explicitAssoc.length <= 1);
+
+      return explicitAssoc.length === 1;
+    });
+
+    if (subnetTable.length === 0) {
+      // There is no explicit association for this subnet so it will be implicitly
+      // associated with the VPC's main routing table.
+      subnetTable = routeTables.filter((rt) => {
+        const implicitAssoc = rt.Associations.filter((assoc) => {
+          return assoc.Main === true;
+        });
+
+        assert.ok(implicitAssoc.length <= 1);
+
+        return implicitAssoc.length === 1;
+      });
+    }
+
+    if (subnetTable.length !== 1) {
+      throw new Error(
+        `Could not locate routing table for subnet: subnet id: ${subnetId}`
+      );
+    }
+
+    const igwRoutes = subnetTable[0].Routes.filter((route) => {
+      // NOTE: there may be no IGW attached to route
+      return route.GatewayId?.startsWith('igw-');
+    });
+
+    return igwRoutes.length > 0;
+  }
+
+  // TODO: Distinguish between there being no default VPC,
+  // or being given an invalid VPC ID, and no public subnets
+  // existing in a VPC that definitely exists.
+  async findPublicSubnets(vpcId) {
+    if (!vpcId) {
+      vpcId = await this.findDefaultVpc();
+    }
+    const rts = await this.getRouteTables(vpcId);
+    const subnets = await this.getSubnets(vpcId);
+
+    const publicSubnets = subnets.filter((subnet) => {
+      return this.isSubnetPublic(rts, subnet.SubnetId);
+    });
+
+    return publicSubnets;
+  }
+}
+
+async function main() {
+  const f = new VPCSubnetFinder({ region: process.env.REGION });
+
+  try {
+    const publicSubnets = await f.findPublicSubnets(process.env.VPC_ID);
+    console.log(publicSubnets.map((s) => s.SubnetId).join('\n'));
+  } catch (err) {
+    console.log(err);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { VPCSubnetFinder };

package/lib/platform/aws-ecs/legacy/plugins/artillery-plugin-inspect-script/index.js

@@ -0,0 +1,27 @@
+/* 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/. */
+
+
+
+module.exports.Plugin = ArtilleryInspectScriptPlugin;
+
+const { btoa } = require('../../util');
+
+function ArtilleryInspectScriptPlugin(script, events) {
+  this.script = script;
+  this.events = events;
+
+  const checksConfig = script.config?.ensure || script.config?.plugins?.ensure;
+
+  if (checksConfig) {
+    console.log(
+      `inspect-script.config.ensure=${btoa(JSON.stringify(checksConfig))}`
+    );
+  }
+
+  return this;
+}
+ArtilleryInspectScriptPlugin.prototype.cleanup = (done) => {
+  done(null);
+};

package/lib/platform/aws-ecs/legacy/plugins/artillery-plugin-sqs-reporter/azure-aqs.js

@@ -0,0 +1,80 @@
+// Copyright (c) Artillery Software Inc.
+// SPDX-License-Identifier: BUSL-1.1
+//
+// Non-evaluation use of Artillery on Azure requires a commercial license
+
+const { QueueClient } = require('@azure/storage-queue');
+const { BlobServiceClient } = require('@azure/storage-blob');
+const { DefaultAzureCredential } = require('@azure/identity');
+const { randomUUID } = require('node:crypto');
+
+function getAQS() {
+  return new QueueClient(
+    process.env.AZURE_STORAGE_QUEUE_URL,
+    new DefaultAzureCredential()
+  );
+}
+
+// Azure Queue Storage has a 64KB message limit
+// Use 60KB threshold to leave margin for encoding overhead
+const AQS_SIZE_LIMIT = 60 * 1024;
+
+let blobContainerClient = null;
+
+function getBlobClient() {
+  if (!blobContainerClient) {
+    const storageAccount = process.env.AZURE_STORAGE_ACCOUNT;
+    const containerName = process.env.AZURE_STORAGE_BLOB_CONTAINER;
+    if (!storageAccount || !containerName) {
+      throw new Error(
+        'AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_BLOB_CONTAINER must be set'
+      );
+    }
+    const blobServiceClient = new BlobServiceClient(
+      `https://${storageAccount}.blob.core.windows.net`,
+      new DefaultAzureCredential()
+    );
+    blobContainerClient = blobServiceClient.getContainerClient(containerName);
+  }
+  return blobContainerClient;
+}
+
+async function sendMessage(queue, body, tags) {
+  const payload = JSON.stringify({
+    payload: body,
+    attributes: tags.reduce((acc, tag) => {
+      acc[tag.key] = tag.value;
+      return acc;
+    }, {})
+  });
+
+  // Check if payload exceeds Azure Queue Storage limit
+  if (Buffer.byteLength(payload, 'utf8') > AQS_SIZE_LIMIT) {
+    // Upload to blob storage and send reference
+    const testId = tags.find((t) => t.key === 'testId')?.value;
+    const workerId = tags.find((t) => t.key === 'workerId')?.value;
+    const messageId = randomUUID();
+    const blobName = `tests/${testId}/overflow/${workerId}/${messageId}.json`;
+
+    const blobClient = getBlobClient().getBlockBlobClient(blobName);
+    await blobClient.upload(payload, Buffer.byteLength(payload, 'utf8'));
+
+    // Send reference message
+    const refPayload = JSON.stringify({
+      payload: {
+        _overflowRef: blobName,
+        event: body.event
+      },
+      attributes: tags.reduce((acc, tag) => {
+        acc[tag.key] = tag.value;
+        return acc;
+      }, {})
+    });
+
+    return queue.sendMessage(refPayload);
+  }
+
+  return queue.sendMessage(payload);
+}
+
+module.exports = { getAQS, sendMessage };