@artilleryio/int-core 1.0.0

package/lib/engine_ws.js

@@ -0,0 +1,366 @@
+/* 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/. */
+
+'use strict';
+
+const async = require('async');
+const _ = require('lodash');
+const WebSocket = require('ws');
+const HttpsProxyAgent = require('https-proxy-agent');
+const debug = require('debug')('ws');
+const url = require('url');
+const engineUtil = require('@artilleryio/int-commons').engine_util;
+const template = engineUtil.template;
+
+module.exports = WSEngine;
+
+function WSEngine(script) {
+  this.config = script.config;
+}
+
+WSEngine.prototype.createScenario = function (scenarioSpec, ee) {
+  const self = this;
+  const tasks = _.map(scenarioSpec.flow, function (rs) {
+    if (typeof rs.think !== 'undefined') {
+      return engineUtil.createThink(
+        rs,
+        _.get(self.config, 'defaults.think', {})
+      );
+    }
+
+    return self.step(rs, ee);
+  });
+
+  return self.compile(tasks, scenarioSpec.flow, ee);
+};
+
+function getMessageHandler(context, params, ee, timeout, callback) {
+  let done = false;
+
+  setTimeout(() => {
+    if (!done) {
+      const err = 'response timeout';
+      ee.emit('error', err);
+      return callback(err, context);
+    }
+  }, timeout * 1000);
+
+  return function messageHandler(event) {
+    ee.emit('counter', 'websocket.messages_received', 1);
+    ee.emit('rate', 'websocket.receive_rate');
+    done = true;
+    const { data } = event;
+
+    debug('WS receive: %s', data);
+
+    if (!data) {
+      return callback(new Error('Empty response from WS server'), context);
+    }
+
+    let fauxResponse;
+    try {
+      fauxResponse = { body: JSON.parse(data) };
+    } catch (err) {
+      fauxResponse = { body: event.data };
+    }
+
+    engineUtil.captureOrMatch(
+      params,
+      fauxResponse,
+      context,
+      function captured(err, result) {
+        if (err) {
+          ee.emit('error', err.message || err.code);
+          return callback(err, context);
+        }
+
+        const { captures = {}, matches = {} } = result;
+
+        debug('matches: ', matches);
+        debug('captures: ', captures);
+
+        // match and capture are strict by default:
+        const haveFailedMatches = _.some(result.matches, function (v) {
+          return !v.success && v.strict !== false;
+        });
+
+        const haveFailedCaptures = _.some(result.captures, function (v) {
+          return v.failed;
+        });
+
+        if (haveFailedMatches || haveFailedCaptures) {
+          // TODO: Emit the details of each failed capture/match
+          return callback(new Error('Failed capture or match'), context);
+        }
+
+        _.each(result.matches, function (v) {
+          ee.emit('match', v.success, {
+            expected: v.expected,
+            got: v.got,
+            expression: v.expression,
+            strict: v.strict
+          });
+        });
+
+        _.each(result.captures, function (v, k) {
+          _.set(context.vars, k, v.value);
+        });
+
+        return callback(null, context);
+      }
+    );
+  };
+}
+
+WSEngine.prototype.step = function (requestSpec, ee) {
+  const self = this;
+
+  if (requestSpec.loop) {
+    const steps = _.map(requestSpec.loop, function (rs) {
+      return self.step(rs, ee);
+    });
+
+    return engineUtil.createLoopWithCount(requestSpec.count || -1, steps, {
+      loopValue: requestSpec.loopValue || '$loopCount',
+      overValues: requestSpec.over,
+      whileTrue: self.config.processor
+        ? self.config.processor[requestSpec.whileTrue]
+        : undefined
+    });
+  }
+
+  if (requestSpec.think) {
+    return engineUtil.createThink(
+      requestSpec,
+      _.get(self.config, 'defaults.think', {})
+    );
+  }
+
+  if (requestSpec.function) {
+    return function (context, callback) {
+      const processFunc = self.config.processor[requestSpec.function];
+      if (processFunc) {
+        processFunc(context, ee, function () {
+          return callback(null, context);
+        });
+      }
+    };
+  }
+
+  if (requestSpec.log) {
+    return function (context, callback) {
+      console.log(template(requestSpec.log, context));
+      return process.nextTick(function () {
+        callback(null, context);
+      });
+    };
+  }
+
+  if (requestSpec.connect) {
+    return function (context, callback) {
+      return process.nextTick(function () {
+        callback(null, context);
+      });
+    };
+  }
+
+  const f = function (context, callback) {
+    const params = requestSpec.wait || requestSpec.send;
+
+    // match exists on a string, so check match is not a prototype
+    let captureOrMatch = _.has(params, 'capture') || _.has(params, 'match');
+
+    if (captureOrMatch) {
+      // only process response if we're capturing
+      let timeout =
+        self.config.timeout || _.get(self.config, 'ws.timeout') || 10;
+      context.ws.onmessage = getMessageHandler(
+        context,
+        params,
+        ee,
+        timeout,
+        callback
+      );
+    } else {
+      // Reset onmessage to stop steps interfering with each other
+      context.ws.onmessage = undefined;
+    }
+
+    // Backwards compatible with previous version of `send` api
+    let payload = captureOrMatch ? params.payload : params;
+
+    if (payload !== undefined) {
+      payload = template(payload, context);
+      if (typeof payload === 'object') {
+        payload = JSON.stringify(payload);
+      } else {
+        payload = _.toString(payload);
+      }
+
+      ee.emit('counter', 'websocket.messages_sent', 1);
+      ee.emit('rate', 'websocket.send_rate');
+      debug('WS send: %s', payload);
+
+      context.ws.send(payload, function (err) {
+        if (err) {
+          debug(err);
+          ee.emit('error', err);
+          return callback(err, null);
+        }
+
+        // End step if we're not capturing
+        if (!captureOrMatch) {
+          return callback(null, context);
+        }
+      });
+    } else if (captureOrMatch) {
+      debug('WS wait: %j', params);
+    } else {
+      // in the end, we could not send anything, so report it and stop
+      let err = 'invalid_step';
+      debug(err, requestSpec);
+      ee.emit('error', err);
+      return callback(err, context);
+    }
+  };
+
+  return f;
+};
+
+function getWsOptions(config) {
+  const options = getWsConfig(config);
+  const subprotocols = _.get(config, 'ws.subprotocols', []);
+  const headers = _.get(config, 'ws.headers', {});
+
+  const subprotocolHeader = _.find(headers, (value, headerName) => {
+    return headerName.toLowerCase() === 'sec-websocket-protocol';
+  });
+
+  if (typeof subprotocolHeader !== 'undefined') {
+    // NOTE: subprotocols defined via config.ws.subprotocols take precedence:
+    subprotocols.push(...subprotocolHeader.split(',').map((s) => s.trim()));
+  }
+
+  return { options, subprotocols };
+}
+
+function getWsInstance(config, scenarioSpec, context, cb) {
+  let wsArgs = {
+    ...getWsOptions(config),
+    target: config.target
+  };
+  const [{ connect }] = scenarioSpec;
+
+  if (connect) {
+    if (connect.function && config.processor[connect.function]) {
+      const processFn = config.processor[connect.function];
+
+      return processFn(wsArgs, context, (err) => {
+        if (err) {
+          debug('connect.function', err);
+          return cb(err, null);
+        }
+
+        context.wsArgs = wsArgs;
+
+        return cb(null, context);
+      });
+    } else if (_.isPlainObject(connect)) {
+      const {
+        target = config.target,
+        headers = _.get(config, 'ws.headers', {}),
+        subprotocols = _.get(config, 'ws.subprotocols', []),
+        ...instanceConfig
+      } = connect;
+
+      const opt = getWsOptions({
+        tls: config.tls,
+        ws: { subprotocols, headers, ...instanceConfig }
+      });
+
+      wsArgs = {
+        target: template(target, context),
+        ...opt
+      };
+    } else {
+      wsArgs.target = template(connect, context);
+    }
+  }
+
+  debug('new WebSocket instance:', wsArgs);
+
+  context.wsArgs = wsArgs;
+
+  return cb(null, context);
+}
+
+WSEngine.prototype.compile = function (tasks, scenarioSpec, ee) {
+  const config = this.config;
+
+  return function scenario(initialContext, callback) {
+    function zero(cb) {
+      ee.emit('started');
+
+      getWsInstance(config, scenarioSpec, initialContext, cb);
+    }
+
+    function one(context, cb) {
+      const { wsArgs, ...contextWithoutWsArgs } = context;
+      const ws = new WebSocket(
+        wsArgs.target,
+        wsArgs.subprotocols,
+        wsArgs.options
+      );
+
+      ws.on('open', function () {
+        contextWithoutWsArgs.ws = ws;
+
+        return cb(null, contextWithoutWsArgs);
+      });
+
+      ws.once('error', function (err) {
+        debug(err);
+        ee.emit('error', err.message || err.code);
+
+        return cb(err, {});
+      });
+    }
+
+    initialContext._successCount = 0;
+
+    const steps = _.flatten([zero, one, tasks]);
+
+    async.waterfall(steps, function scenarioWaterfallCb(err, context) {
+      if (err) {
+        debug(err);
+      }
+
+      if (context && context.ws) {
+        context.ws.close();
+      }
+
+      return callback(err, context);
+    });
+  };
+};
+
+function getWsConfig(config) {
+  const tls = config.tls || {};
+  const { proxy, ...options } = config.ws || {};
+
+  if (proxy) {
+    const { url: proxyUrl, ...proxyOptions } = proxy;
+
+    debug('Set proxy: %s, options: %s', proxyUrl, proxyOptions);
+
+    const agent = new HttpsProxyAgent({
+      ...url.parse(proxyUrl),
+      ...proxyOptions
+    });
+
+    options.agent = agent;
+  }
+
+  return _.extend(tls, options);
+}

package/lib/is-idle-phase.js

@@ -0,0 +1,14 @@
+/* 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/. */
+
+function isIdlePhase(phase) {
+  return (
+    (phase.arrivalRate === 0 && !phase.rampTo) ||
+    phase.arrivalCount === 0 ||
+    phase.maxVusers === 0 ||
+    phase.pause > 0
+  );
+}
+
+module.exports = isIdlePhase;

package/lib/phases.js

@@ -0,0 +1,184 @@
+/* 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/. */
+
+'use strict';
+
+const EventEmitter = require('eventemitter3');
+const async = require('async');
+const _ = require('lodash');
+const isUndefined = _.isUndefined;
+const arrivals = require('arrivals');
+const debug = require('debug')('phases');
+const crypto = require('crypto');
+const driftless = require('driftless');
+
+module.exports = phaser;
+
+function phaser(phaseSpecs) {
+  let ee = new EventEmitter();
+
+  let tasks = _.map(phaseSpecs, function (spec, i) {
+    // Cast defined but non-number (eg: from ENV) values
+    [
+      'arrivalRate',
+      'arrivalCount',
+      'pause',
+      'rampTo',
+      'duration',
+      'maxVusers'
+    ].forEach(function (k) {
+      if (!isUndefined(spec[k]) && typeof spec[k] !== 'number') {
+        spec[k] = _.toNumber(spec[k]);
+      }
+    });
+
+    if (isUndefined(spec.index)) {
+      spec.index = i;
+    }
+
+    if (!isUndefined(spec.arrivalRate) && isUndefined(spec.rampTo)) {
+      spec.mode = spec.mode || 'uniform';
+    }
+
+    if (!isUndefined(spec.pause)) {
+      return createPause(spec, ee);
+    }
+
+    if (!isUndefined(spec.arrivalCount)) {
+      return createArrivalCount(spec, ee);
+    }
+
+    if (!isUndefined(spec.arrivalRate)) {
+      // If arrivalRate is zero and it's not a ramp, it's the same as a pause:
+      if (spec.arrivalRate === 0 && isUndefined(spec.rampTo)) {
+        return createPause(Object.assign(spec, { pause: spec.duration }), ee);
+      }
+
+      // If it's a ramp, create that:
+      if (!isUndefined(spec.rampTo)) {
+        return createRamp(spec, ee);
+      }
+
+      // Otherwise it's a plain arrival phase:
+      return createArrivalRate(spec, ee);
+    }
+
+    console.log('Unknown phase spec\n%j\nThis should not happen', spec);
+  });
+
+  ee.run = function () {
+    async.series(tasks, function (err) {
+      if (err) {
+        debug(err);
+      }
+
+      ee.emit('done');
+    });
+  };
+
+  return ee;
+}
+
+function createPause(spec, ee) {
+  const duration = spec.pause * 1000;
+  const task = function (callback) {
+    ee.emit('phaseStarted', spec);
+    setTimeout(function () {
+      ee.emit('phaseCompleted', spec);
+      return callback(null);
+    }, duration);
+  };
+  return task;
+}
+
+function createRamp(spec, ee) {
+  const duration = spec.duration || 1;
+  const arrivalRate = spec.arrivalRate;
+  const rampTo = spec.rampTo;
+
+  const tick = 1000 / Math.max(arrivalRate, rampTo); // smallest tick
+  const difference = rampTo - arrivalRate;
+  const periods = duration * 1000 / tick;
+
+  function arrivalProbability(currentStep) {
+    // linear function ax + b
+    // normalized to 0 <= f(t) <= 1
+    // Anything under function value should be an arrival
+
+    let t = currentStep * tick / 1000;
+    return ((difference / duration) * t + arrivalRate) / Math.max(rampTo, arrivalRate);
+  };
+
+  let probabilities = Array.from({length: periods}, () => Math.random());
+
+  debug(
+    `rampTo: tick = ${tick}; difference = ${difference}; rampTo = ${rampTo}; arrivalRate = ${arrivalRate}; periods = ${periods}`
+  );
+
+  return function rampTask(callback) {
+    ee.emit('phaseStarted', spec);
+    let currentStep = 1;
+    const timer = driftless.setDriftlessInterval(function maybeArrival() {
+      if (currentStep <= periods) {
+        let arrivalBreakpoint = arrivalProbability(currentStep);
+        let roll = probabilities[currentStep-1];
+        debug(`roll:${roll} <= breakpoint:${arrivalBreakpoint}`);
+        if (roll <= arrivalBreakpoint) {
+          ee.emit('arrival', spec);
+        }
+
+        currentStep++;
+      } else {
+        driftless.clearDriftless(timer);
+        ee.emit('phaseCompleted', spec);
+
+        return callback(null);
+      }
+    }, tick);
+  };
+}
+
+function createArrivalCount(spec, ee) {
+  const task = function (callback) {
+    ee.emit('phaseStarted', spec);
+    const duration = spec.duration * 1000;
+
+    if (spec.arrivalCount > 0) {
+      const interval = duration / spec.arrivalCount;
+      const p = arrivals.uniform.process(interval, duration);
+      p.on('arrival', function () {
+        ee.emit('arrival', spec);
+      });
+      p.on('finished', function () {
+        ee.emit('phaseCompleted', spec);
+        return callback(null);
+      });
+      p.start();
+    } else {
+      return callback(null);
+    }
+  };
+
+  return task;
+}
+
+function createArrivalRate(spec, ee) {
+  const task = function (callback) {
+    ee.emit('phaseStarted', spec);
+    const ar = 1000 / spec.arrivalRate;
+    const duration = spec.duration * 1000;
+    debug('creating a %s process for arrivalRate', spec.mode);
+    const p = arrivals[spec.mode].process(ar, duration);
+    p.on('arrival', function () {
+      ee.emit('arrival', spec);
+    });
+    p.on('finished', function () {
+      ee.emit('phaseCompleted', spec);
+      return callback(null);
+    });
+    p.start();
+  };
+
+  return task;
+}

package/lib/readers.js

@@ -0,0 +1,65 @@
+/* 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/. */
+
+'use strict';
+
+const _ = require('lodash');
+
+module.exports = createReader;
+
+function createReader(order, spec) {
+  if (order === 'sequence') {
+    return createSequencedReader();
+  } else if (typeof order === 'undefined' && (typeof spec?.name !== 'undefined') && spec?.loadAll === true) {
+    return createEverythingReader(spec);
+  } else { // random
+    return createRandomReader();
+  }
+}
+
+function createSequencedReader() {
+  let i = 0;
+  return function (data) {
+    let result = data[i];
+    if (i < data.length - 1) {
+      i++;
+    } else {
+      i = 0;
+    }
+    return result;
+  };
+}
+
+function createEverythingReader(spec) {
+  let parsedData;
+
+  return function (data) {
+    if (!parsedData) {
+      parsedData = [];
+
+      // Parse the row into an object based on the fields spec
+      if (spec.fields?.length > 0) {
+        for (const row of data) {
+          let o = {};
+            for(let i = 0; i < spec.fields.length; i++) {
+              const fieldName = spec.fields[i];
+              o[fieldName] = row[i];
+            }
+          parsedData.push(o);
+        }
+      } else {
+        // Otherwise just return the array of rows
+        parsedData = data;
+      }
+    }
+
+    return parsedData;
+  };
+}
+
+function createRandomReader() {
+  return function (data) {
+    return data[Math.max(0, _.random(0, data.length - 1))];
+  };
+}