@loadmill/executer 0.1.34 → 0.1.38

package/dist/ws.js

@@ -0,0 +1,435 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSSequenceHandler = exports.WSRequest = void 0;
+var ws_1 = __importDefault(require("ws")); // todo should be picked with other option (socketio or non in browser)
+var promise_utils_1 = require("@loadmill/universal/dist/promise-utils");
+var log_1 = __importDefault(require("@loadmill/universal/dist/log"));
+var errors_1 = require("./errors");
+var WSState;
+(function (WSState) {
+    WSState[WSState["CONNECTING"] = 0] = "CONNECTING";
+    WSState[WSState["OPEN"] = 1] = "OPEN";
+    WSState[WSState["CLOSING"] = 2] = "CLOSING";
+    WSState[WSState["CLOSED"] = 3] = "CLOSED";
+})(WSState || (WSState = {}));
+var SWITCHING_PROTOCOLS = 'Switching Protocols';
+var WS_CONNECTION_TIMEOUT_MS = 10000;
+var WSRequest = /** @class */ (function () {
+    function WSRequest(wsRequestArgs, wsHandler, onError) {
+        var _this = this;
+        Object.defineProperty(this, "wsRequestArgs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: wsRequestArgs
+        });
+        Object.defineProperty(this, "wsHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: wsHandler
+        });
+        Object.defineProperty(this, "onError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: onError
+        });
+        Object.defineProperty(this, "hasErrorOccured", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // need this otherwise we have race condition between verifyConnectedAndOpen and onError
+        Object.defineProperty(this, "ws", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // need this for isExpectedStatus function
+        Object.defineProperty(this, "expectedStatus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // need this for isExpectedStatus function
+        /**
+         * Waiting for WS connection to go out of CONNECTING state
+         * @param socket The ws connection object
+         * @param timeout The timeout in milliseconds for the waiting procedure
+         * @returns WSState
+         */
+        Object.defineProperty(this, "waitForConnectedState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (timeout) {
+                if (timeout === void 0) { timeout = WS_CONNECTION_TIMEOUT_MS; }
+                return __awaiter(_this, void 0, void 0, function () {
+                    var WS_CONNECTION_INTERVAL_MS, maxIterations, i;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                WS_CONNECTION_INTERVAL_MS = 100;
+                                if (!(this.ws.readyState !== ws_1.default.CONNECTING)) return [3 /*break*/, 1];
+                                return [2 /*return*/, this.ws.readyState];
+                            case 1:
+                                maxIterations = timeout / WS_CONNECTION_INTERVAL_MS;
+                                i = 0;
+                                _a.label = 2;
+                            case 2:
+                                if (!(this.ws.readyState === ws_1.default.CONNECTING && i < maxIterations)) return [3 /*break*/, 4];
+                                return [4 /*yield*/, promise_utils_1.delay(WS_CONNECTION_INTERVAL_MS)];
+                            case 3:
+                                _a.sent();
+                                i++;
+                                return [3 /*break*/, 2];
+                            case 4: return [2 /*return*/, this.ws.readyState];
+                        }
+                    });
+                });
+            }
+        });
+        this.url = wsRequestArgs.url;
+        this.expectedStatus = wsRequestArgs.expectedStatus;
+    }
+    /**
+     * This function is executed when we are ready to send the ws request
+     * @param cb This callback is being executed after we successfully connected to ws and sent a ws message if there was any
+     */
+    Object.defineProperty(WSRequest.prototype, "ok", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (cb) {
+            return __awaiter(this, void 0, void 0, function () {
+                var response, existingWS;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            response = {
+                                status: 101,
+                                res: {
+                                    statusMessage: SWITCHING_PROTOCOLS,
+                                },
+                                header: {},
+                                req: {},
+                            };
+                            existingWS = this.wsHandler.getConnection(this.wsRequestArgs.url);
+                            log_1.default.debug("Connection state " + getConnectionState(existingWS));
+                            if (!(!existingWS || (existingWS && existingWS.readyState !== WSState.OPEN))) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.addConnection(response)];
+                        case 1:
+                            _a.sent();
+                            return [3 /*break*/, 3];
+                        case 2:
+                            this.ws = existingWS;
+                            log_1.default.debug('Reusing existing ws connection', this.ws.url);
+                            _a.label = 3;
+                        case 3:
+                            try {
+                                this.sendMessage();
+                            }
+                            catch (e) {
+                                log_1.default.error('Failed to send a ws message', e);
+                            }
+                            cb(response);
+                            return [2 /*return*/, {}];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "addConnection", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (response) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            this.ws = new ws_1.default(this.wsRequestArgs.url, undefined, { headers: this.wsRequestArgs.headers });
+                            this.addEventListeners(response);
+                            _a = !this.hasErrorOccured;
+                            if (!_a) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.verifyOpen()];
+                        case 1:
+                            _a = (_b.sent());
+                            _b.label = 2;
+                        case 2:
+                            _a;
+                            this.wsHandler.storeConnection(this.wsRequestArgs.url, this.ws);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "addEventListeners", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (response) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    this.addOnErrorListener();
+                    this.addOnUpgradeListener(response);
+                    this.addOnOpenListener();
+                    this.addOnMessageListener();
+                    return [2 /*return*/];
+                });
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "addOnErrorListener", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            this.ws.on('error', function (e) {
+                try {
+                    log_1.default.debug('inside on error', e);
+                    _this.onError(e);
+                    _this.hasErrorOccured = true;
+                }
+                catch (e) {
+                    log_1.default.warn('Failed to handle a ws error', e);
+                }
+                try {
+                    log_1.default.debug('closing ws');
+                    _this.ws.close();
+                }
+                catch (e) {
+                    log_1.default.warn('Failed to close a ws connection', e);
+                }
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "addOnUpgradeListener", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (response) {
+            this.ws.on('upgrade', function (event) {
+                try {
+                    var statusCode = event.statusCode, statusMessage = event.statusMessage, headers = event.headers;
+                    log_1.default.debug('inside upgrade event', { statusCode: statusCode, statusMessage: statusMessage, headers: headers });
+                    response.status = statusCode || 101;
+                    response.res.statusMessage = statusMessage || SWITCHING_PROTOCOLS;
+                    response.header = headers;
+                }
+                catch (e) {
+                    log_1.default.debug('upgrade event err', e);
+                }
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "addOnOpenListener", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this.ws.on('open', function () {
+                log_1.default.debug('inside on open, currently doing nothing here.');
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "addOnMessageListener", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            this.ws.on('message', function (message) {
+                try {
+                    log_1.default.debug('got incoming message', message);
+                    _this.wsHandler.addMessage(message);
+                }
+                catch (e) {
+                    log_1.default.debug('error getting message', e);
+                }
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "verifyOpen", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var readyState;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.waitForConnectedState(this.wsRequestArgs.timeout)];
+                        case 1:
+                            readyState = _a.sent();
+                            log_1.default.debug("Connection state " + WSState[readyState]);
+                            if (readyState !== ws_1.default.OPEN && !this.hasErrorOccured) {
+                                log_1.default.error('Could not connect to WebSocket address', { connectionState: WSState[readyState], url: this.ws.url });
+                                throw new errors_1.RequestFailuresError('Could not connect to WebSocket address');
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(WSRequest.prototype, "sendMessage", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            log_1.default.debug('about to send message', { readyState: WSState[this.ws.readyState] });
+            if (this.ws.readyState === WSState.OPEN && this.wsRequestArgs.message) {
+                log_1.default.debug('sending message', this.wsRequestArgs.message);
+                this.ws.send(this.wsRequestArgs.message);
+            }
+        }
+    });
+    // need this because the SequenceExecutor expectes a request obj with on func prop
+    Object.defineProperty(WSRequest.prototype, "on", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_eventName, _cb) {
+            //do nothing
+        }
+    });
+    return WSRequest;
+}());
+exports.WSRequest = WSRequest;
+var WSSequenceHandler = /** @class */ (function () {
+    function WSSequenceHandler() {
+        Object.defineProperty(this, "_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._connections = {};
+        this.clearMessages();
+    }
+    Object.defineProperty(WSSequenceHandler.prototype, "getConnection", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (url) {
+            return this._connections[url];
+        }
+    });
+    Object.defineProperty(WSSequenceHandler.prototype, "storeConnection", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (url, wsConnection) {
+            this._connections[url] = wsConnection;
+        }
+    });
+    Object.defineProperty(WSSequenceHandler.prototype, "closeAllConnections", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _i, _a, connection;
+                return __generator(this, function (_b) {
+                    try {
+                        log_1.default.debug('Closing all ws connections');
+                        for (_i = 0, _a = Object.values(this._connections); _i < _a.length; _i++) {
+                            connection = _a[_i];
+                            connection.close();
+                        }
+                    }
+                    catch (e) {
+                        log_1.default.warn('Failed to close all connections', e, { connections: this._connections });
+                    }
+                    return [2 /*return*/];
+                });
+            });
+        }
+    });
+    Object.defineProperty(WSSequenceHandler.prototype, "getMessages", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return this.messages;
+        }
+    });
+    Object.defineProperty(WSSequenceHandler.prototype, "addMessage", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (message) {
+            this.messages.push(message);
+        }
+    });
+    Object.defineProperty(WSSequenceHandler.prototype, "clearMessages", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this.messages = [];
+        }
+    });
+    return WSSequenceHandler;
+}());
+exports.WSSequenceHandler = WSSequenceHandler;
+function getConnectionState(existingWS) {
+    return existingWS ? WSState[existingWS.readyState] : null;
+}
+//# sourceMappingURL=ws.js.map

package/dist/ws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws.js","sourceRoot":"","sources":["../src/ws.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@loadmill/executer",
-  "version": "0.1.34",
+  "version": "0.1.38",
   "description": "Loadmill executer library",
   "scripts": {
     "ts-watch": "rimraf dist && tsc -w -p tsconfig.json",
     "build": "rimraf dist && tsc -p tsconfig.json",
     "check-types": "tsc -p tsconfig.json --noEmit",
     "prepublish": "yarn build",
-    "unit-test": "mocha --require ts-node/register/transpile-only --ui tdd \"test/*.ts\""
+    "unit-test": "mocha --timeout 10000 --require ts-node/register/transpile-only --ui tdd \"test/*.ts\""
   },
   "engines": {
     "node": ">=12.0.0"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@loadmill/core": "0.3.33",
-    "@loadmill/universal": "0.3.26",
+    "@loadmill/core": "0.3.37",
+    "@loadmill/universal": "0.3.30",
     "@types/estree": "^0.0.50",
     "acorn": "^8.4.1",
     "agentkeepalive": "^4.1.3",
@@ -23,8 +23,8 @@
     "jsedn": "^0.4.1",
     "lodash": "^4.17.21",
     "randomstring": "^1.1.5",
-    "superagent": "^3.3.0",
+    "superagent": "^6.1.0",
     "urijs": "^1.18.1",
-    "vm2": "^3.9.3"
+    "vm2": "^3.9.4"
   }
 }

package/src/errors.ts

@@ -0,0 +1,10 @@
+import { Histogram } from './failures';
+
+export class RequestFailuresError extends Error {
+  constructor(message: string, public histogram: Histogram = { [message]: 1 }) {
+    super(message);
+
+    // Workaround suggested in: https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+    Object.setPrototypeOf(this, RequestFailuresError.prototype);
+  }
+}

package/src/extraction-combiner.ts

@@ -5,12 +5,14 @@ import {
   CheerioExtractor,
   JsonPathExtractor,
   ExpressionExtractor,
-  ParametrizedExtractor
+  ParametrizedExtractor,
+  WsExtractor,
 } from '@loadmill/core/dist/parameters/extractors';
 import { Parameters } from '@loadmill/core/dist/parameters';
 import { Extraction } from '@loadmill/core/dist/request';
 import log from '@loadmill/universal/dist/log';
 import ednParser from 'jsedn';
+import { WSExtractionData } from '@loadmill/core/dist/parameters/extractors/ws-extractor';
 
 export class ExtractionCombiner {
   headerExtractor: HeaderExtractor;
@@ -19,19 +21,19 @@ export class ExtractionCombiner {
   ednPathExtractor: JsonPathExtractor;
   expressionExtractor: ExpressionExtractor;
 
-  constructor(private contextParameters: Parameters, private res: any) {
+  constructor(private contextParameters: Parameters, private res: any, private wsExtractionData: WSExtractionData) {
     this.headerExtractor = new HeaderExtractor(res, this.contextParameters);
     this.expressionExtractor = new ExpressionExtractor(this.contextParameters);
   }
 
-  combine(extraction: Extraction) {
+  async combine(extraction: Extraction) {
     let query: string | string[], extractor!: ParametrizedExtractor;
 
     if (typeof extraction === 'string') {
       query = extraction;
       extractor = this.expressionExtractor;
     } else {
-      const { header, jQuery, jsonPath, edn, regex } = extraction;
+      const { header, jQuery, jsonPath, edn, regex, ws } = extraction;
 
       if (header != null) {
         query = header;
@@ -88,6 +90,15 @@ export class ExtractionCombiner {
 
         query = regex;
       }
+
+      if (ws != null) {
+        extractor = new WsExtractor(
+          this.wsExtractionData,
+          this.contextParameters
+        );
+
+        query = ws;
+      }
     }
 
     return () => extractor.extract(query);

package/src/mill-version.ts

@@ -1,6 +1,6 @@
 export const millVersion = {
   major: 9,
-  minor: 40,
+  minor: 44,
   patch: 0,
 };
 

package/src/post-script/ast-walker/index.ts

@@ -82,7 +82,7 @@ export class ASTWalker {
   };
 
   private addRestElement = ({ argument }: RestElement) => {
-    if (isIdentifier(argument)){
+    if (isIdentifier(argument)) {
       this.addIdentifier(argument as Identifier);
     }
     else if (isObject(argument)) {

package/src/post-script/virtual-machine/vm2-virtual-machine.ts

@@ -5,7 +5,7 @@ import { Engine, VirtualMachine, VirtualMachineOptions } from './virtual-machine
 
 export class VM2VirtualMachine implements VirtualMachine {
   public engine: VM;
-  private DEFAULT_TIMOUT_MS = 1000;
+  private DEFAULT_TIMOUT_MS = Number(process.env.POSTSCRIPT_TIMEOUT_MS) || 1000;
 
   create(options: VirtualMachineOptions): Engine {
     const { timeout, globalObject, async, staticObject } = options;

package/src/sampler.ts

@@ -7,6 +7,7 @@ import { Failures, mergeFailures } from './failures';
 import { PerRequestStats, setReqStats } from './request-stats';
 import { Work } from './work';
 import { messageCreators } from './message-creators';
+import { DEFAULT_DURATION, DEFAULT_ITERATION_DELAY } from '@loadmill/core/dist/conf/defaults';
 
 // 5 minutes:
 const RES_KEEP_TIME = 5 * 60 * 1000;
@@ -34,7 +35,7 @@ export class Sampler {
   startSampling = () => {
     this.samplerMill.cancelWork(false);
 
-    promiseUtils.delay(this.work.duration).then(
+    promiseUtils.delay(this.work.duration || DEFAULT_DURATION).then(
       () => {
         if (!this.samplerMill.isStopped) {
           log.debug('Time\'s up!');
@@ -45,7 +46,7 @@ export class Sampler {
     );
 
     const requests = this.work.requests;
-    const iterationDelay = this.work.iterationDelay;
+    const iterationDelay = this.work.iterationDelay || DEFAULT_ITERATION_DELAY;
 
     const reportDelayy = reportDelay(iterationDelay, requests);
     this.samplerMill.reportIntervalId = setInterval(
@@ -93,7 +94,7 @@ export class Sampler {
         const skipCount = res.lastStartedIndex + 1;
         await promiseUtils.delay(
           minimalRemainingDuration(
-            this.work.iterationDelay,
+            this.work.iterationDelay || DEFAULT_ITERATION_DELAY,
             this.work.requests,
             skipCount
           )