@depup/artillery 2.0.30-depup.0

package/lib/create-bom/create-bom.js

@@ -0,0 +1,301 @@
+/* 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/. */
+
+// TODO: async-ify this
+
+const path = require('node:path');
+const fs = require('node:fs');
+const A = require('async');
+const debug = require('debug')('bom');
+const _ = require('lodash');
+const Table = require('cli-table3');
+const { getCustomJsDependencies } = require('../platform/aws-ecs/legacy/bom');
+
+const { readScript, parseScript } = require('../util');
+
+const BUILTIN_PLUGINS = require('./built-in-plugins');
+
+// NOTE: Presumes ALL paths are absolute.
+async function createBOM(absoluteScriptPath, extraFiles, opts, callback) {
+  A.waterfall(
+    [
+      A.constant(absoluteScriptPath),
+      readScript,
+      parseScript,
+      (scriptData, next) => {
+        return next(null, {
+          opts: {
+            scriptData,
+            absoluteScriptPath
+          },
+          localFilePaths: [absoluteScriptPath],
+          npmModules: []
+        });
+      },
+      getPlugins,
+      getCustomEngines,
+      getCustomJsDependencies,
+      getVariableDataFiles,
+      // getFileUploadPluginFiles,
+      getExtraFiles
+      // expandDirectories
+    ],
+
+    (err, context) => {
+      if (err) {
+        return callback(err, null);
+      }
+
+      context.localFilePaths = context.localFilePaths.concat(extraFiles);
+
+      // TODO: Entries in localFilePaths may be directories
+
+      // Handle case with only one entry, where the string itself
+      // will be the common prefix, meaning that when we substring() on it later, we'll
+      // get an empty string, ending up with a manifest like:
+      // { files:
+      //   [ { orig: '/Users/h/tmp/artillery/hello.yaml', noPrefix: '' } ],
+      //   modules: [] }
+      //
+      let prefix = '';
+      if (context.localFilePaths.length === 1) {
+        prefix = context.localFilePaths[0].substring(
+          0,
+          context.localFilePaths[0].length -
+            path.basename(context.localFilePaths[0]).length
+        );
+
+        // This may still be an empty string if the script path is just 'hello.yml':
+        prefix = prefix.length === 0 ? context.localFilePaths[0] : prefix;
+      } else {
+        prefix = commonPrefix(context.localFilePaths);
+      }
+
+      debug('prefix', prefix);
+
+      //
+      // include package.json / package-lock.json / yarn.lock
+      //
+      let packageDescriptionFiles = ['.npmrc'];
+      if (opts.packageJsonPath) {
+        packageDescriptionFiles.push(opts.packageJsonPath);
+      } else {
+        packageDescriptionFiles = packageDescriptionFiles.concat([
+          'package.json',
+          'package-lock.json',
+          'yarn.lock'
+        ]);
+      }
+      const dependencyFiles = packageDescriptionFiles.map((s) =>
+        path.join(prefix, s)
+      );
+
+      debug(dependencyFiles);
+
+      dependencyFiles.forEach((p) => {
+        try {
+          if (fs.statSync(p)) {
+            context.localFilePaths.push(p);
+          }
+        } catch (_ignoredErr) {}
+      });
+
+      const files = context.localFilePaths.map((p) => {
+        return { orig: p, noPrefix: p.substring(prefix.length, p.length) };
+      });
+
+      const pkgPath = _.find(files, (f) => {
+        return f.noPrefix === 'package.json';
+      });
+
+      if (pkgPath) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath.orig, 'utf8'));
+        const pkgDeps = [].concat(
+          Object.keys(pkg.dependencies || {}),
+          Object.keys(pkg.devDependencies || {})
+        );
+        context.pkgDeps = pkgDeps;
+        context.npmModules = _.uniq(context.npmModules.concat(pkgDeps)).sort();
+      } else {
+        context.pkgDeps = [];
+      }
+
+      return callback(null, {
+        files: _.uniqWith(files, _.isEqual),
+        modules: _.uniq(context.npmModules).filter(
+          (m) =>
+            m !== 'artillery' &&
+            m !== 'playwright' &&
+            !m.startsWith('@playwright/')
+        ),
+        pkgDeps: context.pkgDeps
+      });
+    }
+  );
+}
+
+function getPlugins(context, next) {
+  const environmentPlugins = _.reduce(
+    _.get(context, 'opts.scriptData.config.environments', {}),
+    function getEnvironmentPlugins(acc, envSpec, _envName) {
+      acc = acc.concat(Object.keys(envSpec.plugins || []));
+      return acc;
+    },
+    []
+  );
+  const pluginNames = Object.keys(
+    _.get(context, 'opts.scriptData.config.plugins', {})
+  ).concat(environmentPlugins);
+
+  const pluginPackages = _.uniq(
+    pluginNames
+      .filter((p) => BUILTIN_PLUGINS.indexOf(p) === -1)
+      .map((p) => `artillery-plugin-${p}`)
+  );
+
+  debug(pluginPackages);
+  context.npmModules = context.npmModules.concat(pluginPackages);
+
+  return next(null, context);
+}
+
+function getCustomEngines(context, next) {
+  // TODO: Environment-specific engines (see getPlugins())
+  const engineNames = _.uniq(
+    Object.keys(_.get(context, 'opts.scriptData.config.engines', {}))
+  );
+  const enginePackages = engineNames.map((x) => `artillery-engine-${x}`);
+  context.npmModules = context.npmModules.concat(enginePackages);
+
+  return next(null, context);
+}
+
+function getVariableDataFiles(context, next) {
+  // NOTE: Presuming that the script has been run through the functions
+  // that normalize the config.payload definition (presume it's an array).
+  // Also assuming that context.opts.scriptData contains both the config and
+  // the scenarios section.
+
+  // Iterate over environments
+
+  function resolvePayloadPaths(obj) {
+    const result = [];
+    if (obj.payload) {
+      if (_.isArray(obj.payload)) {
+        obj.payload.forEach((payloadSpec) => {
+          result.push(
+            path.resolve(
+              path.dirname(context.opts.absoluteScriptPath),
+              payloadSpec.path
+            )
+          );
+        });
+      } else if (_.isObject(obj.payload)) {
+        // NOTE: isObject returns true for arrays, so this branch must
+        // come second.
+        result.push(
+          path.resolve(
+            path.dirname(context.opts.absoluteScriptPath),
+            obj.payload.path
+          )
+        );
+      }
+    }
+    return result;
+  }
+
+  context.localFilePaths = context.localFilePaths.concat(
+    resolvePayloadPaths(context.opts.scriptData.config)
+  );
+  context.opts.scriptData.config.environments =
+    context.opts.scriptData.config.environments || {};
+  Object.keys(context.opts.scriptData.config.environments).forEach(
+    (envName) => {
+      const envSpec = context.opts.scriptData.config.environments[envName];
+      context.localFilePaths = context.localFilePaths.concat(
+        resolvePayloadPaths(envSpec)
+      );
+    }
+  );
+  return next(null, context);
+}
+
+function getExtraFiles(context, next) {
+  if (
+    context.opts.scriptData.config?.includeFiles
+  ) {
+    const absPaths = _.map(context.opts.scriptData.config.includeFiles, (p) => {
+      const includePath = path.resolve(
+        path.dirname(context.opts.absoluteScriptPath),
+        p
+      );
+      debug('includeFile:', includePath);
+      return includePath;
+    });
+    context.localFilePaths = context.localFilePaths.concat(absPaths);
+    return next(null, context);
+  } else {
+    return next(null, context);
+  }
+}
+
+function commonPrefix(paths, separator) {
+  if (
+    !paths ||
+    paths.length === 0 ||
+    paths.filter((s) => typeof s !== 'string').length > 0
+  ) {
+    return '';
+  }
+
+  if (paths.includes('/')) {
+    return '/';
+  }
+
+  const sep = separator ? separator : path.sep;
+
+  const splitPaths = paths.map((p) => p.split(sep));
+  const shortestPath = splitPaths.reduce((a, b) => {
+    return a.length < b.length ? a : b;
+  }, splitPaths[0]);
+
+  let furthestIndex = shortestPath.length;
+
+  for (const p of splitPaths) {
+    for (let i = 0; i < furthestIndex; i++) {
+      if (p[i] !== shortestPath[i]) {
+        furthestIndex = i;
+        break;
+      }
+    }
+  }
+
+  const joined = shortestPath.slice(0, furthestIndex).join(sep);
+
+  if (joined.length > 0) {
+    // Check if joined path already ends with separator which
+    // will happen when input is a root drive on Windows, e.g. "C:\"
+    return joined.endsWith(sep) ? joined : joined + sep;
+  } else {
+    return '';
+  }
+}
+
+function prettyPrint(manifest) {
+  const t = new Table({ head: ['Name', 'Type', 'Notes'] });
+  for (const f of manifest.files) {
+    t.push([f.noPrefix, 'file']);
+  }
+  for (const m of manifest.modules) {
+    t.push([
+      m,
+      'package',
+      manifest.pkgDeps.indexOf(m) === -1 ? 'not in package.json' : ''
+    ]);
+  }
+  artillery.log(t.toString());
+  artillery.log();
+}
+
+module.exports = { createBOM, commonPrefix, prettyPrint };

package/lib/dispatcher.js

@@ -0,0 +1,9 @@
+/* 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 core = require('@artilleryio/int-core');
+
+module.exports = core;

package/lib/dist.js

@@ -0,0 +1,222 @@
+/* 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 assert = require('node:assert');
+const L = require('lodash');
+const isIdlePhase = require('@artilleryio/int-core').isIdlePhase;
+
+module.exports = divideWork;
+
+/**
+ *
+ * Create a number of scripts for workers from the script given to use by user.
+ *
+ * @param {Script} script
+ * @param {number} numWorkers
+ * @returns {Script[]} array of scripts distributed representing the work for each worker
+ *
+ * @todo: Distribute payload data to workers
+ */
+function divideWork(script, numWorkers) {
+  const workerScripts = createWorkerScriptBases(numWorkers, script);
+  for (const phase of script.config.phases) {
+    //  switching on phase type to determine how to distribute work
+    switch (true) {
+      case !!phase.rampTo: {
+        handleRampToPhase(phase, numWorkers, workerScripts);
+        break;
+      }
+      case !!phase.arrivalRate: {
+        handleArrivalRatePhase(phase, numWorkers, workerScripts);
+        break;
+      }
+      case !!phase.arrivalCount: {
+        // arrivalCount is executed in the first worker
+        // and replaced with a `pause` phase in the others
+        handleArrivalCountPhase(workerScripts, phase, numWorkers);
+        break;
+      }
+      case !!phase.pause: {
+        // nothing to adjust here, pause is executed in all workers
+        for (let i = 0; i < numWorkers; i++) {
+          workerScripts[i].config.phases.push(L.cloneDeep(phase));
+        }
+        break;
+      }
+      default: {
+        console.log(
+          'Unknown phase spec definition, skipping.\n%j\n' +
+            'This should not happen',
+          phase
+        );
+      }
+    }
+  }
+
+  // Filter out scripts which have only idle phases
+  const result = workerScripts.filter(
+    (workerScript) => !workerScript.config.phases.every(isIdlePhase)
+  );
+
+  // Add worker and totalWorkers properties to phases
+  const hasPayload = scriptHasPayload(script);
+  for (let i = 0; i < result.length; i++) {
+    for (const phase of result[i].config.phases) {
+      phase.totalWorkers = result.length;
+      phase.worker = i + 1;
+    }
+
+    // Distribute payload data to workers
+    if (hasPayload) {
+      for (
+        let payloadIdx = 0;
+        payloadIdx < script.config.payload.length;
+        payloadIdx++
+      ) {
+        // If there are more workers than payload data, then we will repeat the payload data
+        const scriptPayloadData = script.config.payload[payloadIdx].data;
+        const idxToMatch = i % scriptPayloadData.length;
+        result[i].config.payload[payloadIdx].data = scriptPayloadData.filter(
+          (_, index) => index % result.length === idxToMatch
+        );
+      }
+    }
+  }
+
+  return result;
+}
+
+function scriptHasPayload(script) {
+  return script.config.payload && script.config.payload.length > 0;
+}
+
+function handleArrivalCountPhase(workerScripts, phase, numWorkers) {
+  workerScripts[0].config.phases.push(L.cloneDeep(phase));
+
+  for (let i = 1; i < numWorkers; i++) {
+    workerScripts[i].config.phases.push({
+      name: phase.name,
+      pause: phase.duration
+    });
+  }
+}
+
+function handleArrivalRatePhase(phase, numWorkers, workerScripts) {
+  const rates = distribute(phase.arrivalRate, numWorkers);
+  const activeWorkers = rates.reduce(
+    (acc, rate) => acc + (rate > 0 ? 1 : 0),
+    0
+  );
+  const maxVusers = phase.maxVusers
+    ? distribute(phase.maxVusers, activeWorkers)
+    : false;
+  for (let i = 0; i < numWorkers; i++) {
+    const newPhase = L.cloneDeep(phase);
+    newPhase.arrivalRate = rates[i];
+    if (maxVusers) {
+      newPhase.maxVusers = maxVusers[i];
+    }
+    workerScripts[i].config.phases.push(newPhase);
+  }
+}
+
+function handleRampToPhase(phase, numWorkers, workerScripts) {
+  phase.arrivalRate = phase.arrivalRate || 0;
+
+  const rate = phase.arrivalRate / numWorkers;
+  const ramp = phase.rampTo / numWorkers;
+  const activeWorkers = rate > 0 || ramp > 0 ? numWorkers : 0;
+  const maxVusers = phase.maxVusers
+    ? distribute(phase.maxVusers, activeWorkers)
+    : false;
+
+  for (let i = 0; i < numWorkers; i++) {
+    const newPhase = L.cloneDeep(phase);
+    newPhase.arrivalRate = rate;
+    newPhase.rampTo = ramp;
+    if (maxVusers) {
+      newPhase.maxVusers = maxVusers[i];
+    }
+    workerScripts[i].config.phases.push(newPhase);
+  }
+}
+
+function createWorkerScriptBases(numWorkers, script) {
+  const bases = [];
+  for (let i = 0; i < numWorkers; i++) {
+    const newScript = L.cloneDeep({
+      ...script,
+      config: {
+        ...script.config,
+        phases: [],
+        ...(scriptHasPayload(script) && {
+          payload: script.config.payload.map((payload) => {
+            return {
+              ...payload,
+              data: []
+            };
+          })
+        })
+      }
+    });
+    // 'before' and 'after' hooks are executed in the main thread
+    delete newScript.before;
+    delete newScript.after;
+
+    bases.push(newScript);
+  }
+  return bases;
+}
+
+function distribute(m, n) {
+  m = Number(m);
+  n = Number(n);
+
+  const result = [];
+
+  if (m < n) {
+    for (let i = 0; i < n; i++) {
+      result.push(i < m ? 1 : 0);
+    }
+  } else {
+    const baseCount = Math.floor(m / n);
+    let extraItems = m % n;
+    for (let i = 0; i < n; i++) {
+      result.push(baseCount);
+      if (extraItems > 0) {
+        result[i]++;
+        extraItems--;
+      }
+    }
+  }
+  assert(m === sum(result), `${m} === ${sum(result)}`);
+  return result;
+}
+
+function sum(a) {
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result += a[i];
+  }
+  return result;
+}
+
+if (require.main === module) {
+  console.log(distribute(1, 4));
+  console.log(distribute(1, 10));
+  console.log(distribute(4, 4));
+  console.log(distribute(87, 4));
+  console.log(distribute(50, 8));
+  console.log(distribute(39, 20));
+  console.log(distribute(20, 4));
+  console.log(distribute(19, 4));
+  console.log(distribute(20, 3));
+  console.log(distribute(61, 4));
+  console.log(distribute(121, 4));
+  console.log(distribute(32, 3));
+  console.log(distribute(700, 31));
+  console.log(distribute(700, 29));
+}

package/lib/index.js

@@ -0,0 +1,5 @@
+const { getStash } = require('./stash');
+
+module.exports = {
+  getStash
+};