@loadmill/executer 0.1.37 → 0.1.38

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,6 +1,6 @@
 {
   "name": "@loadmill/executer",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "description": "Loadmill executer library",
   "scripts": {
     "ts-watch": "rimraf dist && tsc -w -p tsconfig.json",
@@ -14,8 +14,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@loadmill/core": "0.3.36",
-    "@loadmill/universal": "0.3.29",
+    "@loadmill/core": "0.3.37",
+    "@loadmill/universal": "0.3.30",
     "@types/estree": "^0.0.50",
     "acorn": "^8.4.1",
     "agentkeepalive": "^4.1.3",
@@ -25,6 +25,6 @@
     "randomstring": "^1.1.5",
     "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: 43,
+  minor: 44,
   patch: 0,
 };
 

package/src/sequence.ts

@@ -10,7 +10,6 @@ import clamp from 'lodash/clamp';
 import find from 'lodash/find';
 import map from 'lodash/map';
 import filter from 'lodash/filter';
-import forEach from 'lodash/forEach';
 
 import { ResolvedRequest } from './request-sequence-result';
 import { Asserter } from './asserter';
@@ -52,8 +51,6 @@ const {
   DEFAULT_REQUEST_DELAY,
 } = confDefaults;
 const {
-  MAX_API_REQUEST_BODY_LENGTH,
-  MAX_LOAD_REQUEST_BODY_LENGTH,
   MAX_RESPONSE_BYTES,
   MAX_RESPONSE_COLLECT,
   MIN_REQUEST_DELAY,
@@ -71,10 +68,15 @@ import {
   ALLOWED_RESPONSE_STATUSES,
   LoopConf,
   DEFAULT_REQUEST_TIMEOUT,
-  CachePenetrationModes
+  CachePenetrationModes,
+  RequestPostData
 } from '@loadmill/core/dist/request';
 
 import { testRunEventsEmitter } from './test-run-event-emitter';
+import { WSRequest, WSRequestArguments, WSSequenceHandler } from './ws';
+import { RequestFailuresError } from './errors';
+import { getMaxRequestBodySize } from './utils';
+import { WSExtractionData } from '@loadmill/core/dist/parameters/extractors/ws-extractor';
 
 export const reqIdParamName = 'loadmill-request-id';
 
@@ -127,6 +129,7 @@ class SequenceExecutor {
   resolvedRequests: ResolvedRequest[] = [];
   keepaliveHTTPSAgent;
   keepaliveHTTPAgent;
+  wsHandler: WSSequenceHandler;
 
   constructor(
     private httpAgent,
@@ -143,6 +146,7 @@ class SequenceExecutor {
       freeSocketTimeout: SOCKET_TIMEOUT / 2
     });
     this.postScriptRunner = new PostScriptRunner();
+    this.wsHandler = new WSSequenceHandler();
   }
 
   startAndPass(requests: LoadmillRequest[]) {
@@ -213,9 +217,11 @@ class SequenceExecutor {
           log.info('Unexpected error info:', unexpectedError);
         }
 
+        this.wsHandler.closeAllConnections();
         throw error;
       }
     }
+    this.wsHandler.closeAllConnections();
   }
 
   shouldStop(request: LoadmillRequest) {
@@ -309,12 +315,14 @@ class SequenceExecutor {
     let failedAssertionsHistogram, resTime;
     let loopIteration = 0;
     const maxIterations = getLoopIterations(requestConf.loop);
+    this.wsHandler.clearMessages();
 
     while (loopIteration < maxIterations) {
       loopIteration++;
       const request = this.prepareRequest(requestConf, index);
 
       const res = await this.sendRequest(request, index);
+
       // Setting now to avoid possible user overwrite:
       resTime = Number(this.parameters.__responseTime);
 
@@ -325,7 +333,9 @@ class SequenceExecutor {
         );
       }
 
-      failedAssertionsHistogram = this.processSuccessfulResponse(
+      res.wsExtractionData = { messages: this.wsHandler.messages, timeLimit: timeout - resTime } as WSExtractionData;
+
+      failedAssertionsHistogram = await this.processSuccessfulResponse(
         index,
         requestConf,
         res
@@ -501,8 +511,18 @@ class SequenceExecutor {
   }
 
   prepareRequest(requestConf: LoadmillRequest, reqIndex: number) {
+    if (this.isWSRequest(requestConf) && !envUtils.isBrowser()) {
+      return this.prepareWSRequest(requestConf, reqIndex);
+    }
+    return this.prepareHttpRequest(requestConf, reqIndex);
+  }
+  private isWSRequest({ url }: LoadmillRequest) {
+    const resolvedUrl = this.resolve(url, (e) => setParameterErrorHistogram(e, 'Failed to compute URL - '));
+    return resolvedUrl.startsWith('ws://') || resolvedUrl.startsWith('wss://');
+  }
+  private prepareHttpRequest(requestConf: LoadmillRequest, reqIndex: number) {
     const urlObj = new URI(
-      resolveUrl(requestConf.url, this.parameters, (err) =>
+      resolveUrl(requestConf.url, this.parameters, (err: Error) =>
         setParameterErrorHistogram(err, 'Failed to compute URL - ')
       )
     );
@@ -654,6 +674,66 @@ class SequenceExecutor {
     return request;
   }
 
+  prepareWSRequest(requestConf: LoadmillRequest, reqIndex: number) {
+    const wsRequestArgs = this.resolveAndSetWSReqData(requestConf, reqIndex);
+
+    return new WSRequest(
+      wsRequestArgs,
+      this.wsHandler,
+      (e: Error) => this.setSingleFailure(reqIndex, 'Websocket error ' + e.message),
+    );
+  }
+
+  resolveAndSetWSReqData = (
+    { url, headers, postData, timeout = DEFAULT_REQUEST_TIMEOUT, expectedStatus = 'SUCCESS' }: LoadmillRequest,
+    reqIndex: number
+  ): WSRequestArguments => {
+    const preparedUrl = this.prepareWsUrl(url, reqIndex);
+    const preparedHeaders = this.prepareWsHeaders(headers, reqIndex);
+    const preparedMessage = this.prepareWsMessage(postData, reqIndex);
+    return {
+      expectedStatus,
+      headers: preparedHeaders,
+      message: preparedMessage,
+      timeout,
+      url: preparedUrl,
+    };
+  };
+
+  prepareWsUrl = (url: string, reqIndex: number) => {
+    const resolvedUrl = this.resolve(url, (e: Error) => setParameterErrorHistogram(e, 'Failed to compute URL - '));
+    this.resolvedRequests[reqIndex].url = resolvedUrl;
+    return resolvedUrl;
+  };
+
+  prepareWsHeaders = (headers: LoadmillHeaders[] | undefined, reqIndex: number) => {
+    const resolvedHeadersObj: LoadmillHeaders = {};
+    const resolvedHeaders: LoadmillHeaders[] = [];
+    if (headers && !isEmpty(headers)) {
+      resolvedHeaders.push(...this.resolveHeaders(headers));
+      resolvedHeaders.forEach(({ name, value }) => resolvedHeadersObj[name] = value);
+    }
+    this.resolvedRequests[reqIndex].headers = resolvedHeaders;
+    return resolvedHeadersObj;
+  };
+
+  prepareWsMessage = (postData: RequestPostData | undefined, reqIndex: number) => {
+    let resolvedMessage: string = '';
+    if (postData) {
+      resolvedMessage = this.resolve(postData.text, (err: Error) =>
+        setParameterErrorHistogram(err, 'Failed to compute Websocket message - ')
+      );
+      if (resolvedMessage && resolvedMessage.length > getMaxRequestBodySize()) {
+        throw new RequestFailuresError('Websocket message size is too large');
+      }
+      this.resolvedRequests[reqIndex].postData = {
+        mimeType: postData.mimeType,
+        text: resolvedMessage,
+      };
+    }
+    return resolvedMessage;
+  };
+
   checkProgressEvent = (
     requestIndex: number,
     request,
@@ -715,9 +795,9 @@ class SequenceExecutor {
       )
     );
 
-  processSuccessfulResponse(reqIndex, requestConf: LoadmillRequest, res) {
+  async processSuccessfulResponse(reqIndex, requestConf: LoadmillRequest, res) {
     // modifies parameters:
-    this.handleExtractions(requestConf, res);
+    await this.handleExtractions(requestConf, res);
 
     if (!envUtils.isBrowser()) {
       this.handlePostScript(requestConf, res);
@@ -745,33 +825,33 @@ class SequenceExecutor {
     );
   }
 
-  handleExtractions(requestConf: LoadmillRequest, res) {
-    requestConf.extract?.forEach((extractions: Extractions) =>
-      this.extractInScope(res, extractions)
-    );
+  async handleExtractions(requestConf: LoadmillRequest, res) {
+    for (const extractions of (requestConf.extract || [])) {
+      await this.extractInScope(res, extractions);
+    }
   }
 
-  extractInScope(res, extractions: Extractions) {
+  async extractInScope(res, extractions: Extractions) {
     const contextParameters = Object.assign({}, this.parameters);
-    const extractionCombiner = new ExtractionCombiner(contextParameters, res);
+    const extractionCombiner = new ExtractionCombiner(contextParameters, res, res.wsExtractionData);
 
-    forEach(extractions, (extraction: Extraction, name: string) =>
-      this.extract(name, extraction, extractionCombiner)
-    );
+    for (const [name, extraction] of Object.entries(extractions)) {
+      await this.extract(name, extraction, extractionCombiner);
+    }
   }
 
-  extract(
+  async extract(
     parameterName: string,
     extraction: Extraction,
     extractionCombiner: ExtractionCombiner
   ) {
     log.trace('Parameter extraction start: ', { parameterName, extraction });
 
-    const combinedExtractor = extractionCombiner.combine(extraction);
+    const combinedExtractor = await extractionCombiner.combine(extraction);
     let result;
 
     try {
-      result = combinedExtractor();
+      result = await combinedExtractor();
     } catch (error) {
       const genericMessage = `Failed to extract value for parameter "${parameterName}"`;
       log.debug(genericMessage, error);
@@ -893,9 +973,6 @@ function isSimpleRequest(headers) {
   );
 }
 
-const getMaxRequestBodySize = () =>
-  envUtils.isBrowser() ? MAX_LOAD_REQUEST_BODY_LENGTH : MAX_API_REQUEST_BODY_LENGTH;
-
 const getLoopIterations = (LoopConf?: LoopConf) => {
   const declared = (LoopConf && LoopConf.iterations) || 1;
   return Math.min(MAX_REQUEST_LOOPS_ITERATIONS, declared);
@@ -913,7 +990,7 @@ const extendResponseHeaders = (headers, redirectHeaders) => {
 
 const isExpectedStatus = ({ expectedStatus, url }, status: number) => {
   if (expectedStatus === ALLOWED_RESPONSE_STATUSES.SUCCESS) {
-    return 200 <= status && status < 400;
+    return (200 <= status && status < 400) || status === 101;
   }
   else if (expectedStatus === ALLOWED_RESPONSE_STATUSES.ERROR) {
     log.debug('user asked to fail this request', url);
@@ -949,12 +1026,3 @@ const setTCPReuse = (request, agent, sslAgent) => {
   };
 
 };
-
-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/utils.ts

@@ -0,0 +1,8 @@
+import {
+  MAX_API_REQUEST_BODY_LENGTH,
+  MAX_LOAD_REQUEST_BODY_LENGTH
+} from '@loadmill/core/dist/conf/extrema';
+import * as envUtils from '@loadmill/universal/dist/env-utils';
+
+export const getMaxRequestBodySize = () =>
+  envUtils.isBrowser() ? MAX_LOAD_REQUEST_BODY_LENGTH : MAX_API_REQUEST_BODY_LENGTH;

package/src/ws.ts

@@ -0,0 +1,233 @@
+import WebSocket from 'ws'; // todo should be picked with other option (socketio or non in browser)
+import { delay } from '@loadmill/universal/dist/promise-utils';
+import log from '@loadmill/universal/dist/log';
+import { HttpResponseStatus, LoadmillHeaders } from '@loadmill/core/dist/request';
+import { RequestFailuresError } from './errors';
+
+enum WSState {
+  CONNECTING,
+  OPEN,
+  CLOSING,
+  CLOSED,
+}
+
+const SWITCHING_PROTOCOLS = 'Switching Protocols';
+const WS_CONNECTION_TIMEOUT_MS = 10000;
+
+export class WSRequest {
+  private hasErrorOccured?: boolean; // need this otherwise we have race condition between verifyConnectedAndOpen and onError
+  private ws: WebSocket;
+  public url: string; // need this for isExpectedStatus function
+  public expectedStatus: HttpResponseStatus; // need this for isExpectedStatus function
+
+  constructor(
+    private readonly wsRequestArgs: WSRequestArguments,
+    private readonly wsHandler: WSSequenceHandler,
+    private readonly onError: (e: Error) => void,
+  ) {
+    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
+   */
+  async ok(cb: (response: WSResponse) => boolean) {
+    const response = {
+      status: 101,
+      res: {
+        statusMessage: SWITCHING_PROTOCOLS,
+      },
+      header: {},
+      req: {},
+    };
+
+    const existingWS = this.wsHandler.getConnection(this.wsRequestArgs.url);
+
+    log.debug(`Connection state ${getConnectionState(existingWS)}`);
+    if (!existingWS || (existingWS && existingWS.readyState !== WSState.OPEN)) {
+      await this.addConnection(response);
+    } else {
+      this.ws = existingWS;
+      log.debug('Reusing existing ws connection', this.ws.url);
+    }
+
+    try {
+      this.sendMessage();
+    } catch (e) {
+      log.error('Failed to send a ws message', e);
+    }
+    cb(response);
+    return { };
+  }
+
+  private async addConnection(response: WSResponse) {
+    this.ws = new WebSocket(this.wsRequestArgs.url, undefined, { headers: this.wsRequestArgs.headers });
+    this.addEventListeners(response);
+    !this.hasErrorOccured && await this.verifyOpen();
+    this.wsHandler.storeConnection(this.wsRequestArgs.url, this.ws);
+    // todo add some debug details for the user to know we created a new connection in this request
+  }
+
+  private async addEventListeners(response: WSResponse) {
+    this.addOnErrorListener();
+    this.addOnUpgradeListener(response);
+    this.addOnOpenListener();
+    this.addOnMessageListener();
+  }
+
+  private addOnErrorListener() {
+    this.ws.on('error', (e) => {
+      try {
+        log.debug('inside on error', e);
+        this.onError(e);
+        this.hasErrorOccured = true;
+      } catch (e) {
+        log.warn('Failed to handle a ws error', e);
+      }
+      try {
+        log.debug('closing ws');
+        this.ws.close();
+      } catch (e) {
+        log.warn('Failed to close a ws connection', e);
+      }
+    });
+  }
+
+  private addOnUpgradeListener(response: WSResponse) {
+    this.ws.on('upgrade', (event) => {
+      try {
+        const { statusCode, statusMessage, headers } = event;
+        log.debug('inside upgrade event', { statusCode, statusMessage, headers });
+        response.status = statusCode || 101;
+        response.res.statusMessage = statusMessage || SWITCHING_PROTOCOLS;
+        response.header = headers as LoadmillHeaders;
+      } catch (e) {
+        log.debug('upgrade event err', e);
+      }
+    });
+  }
+
+  private addOnOpenListener() {
+    this.ws.on('open', () => {
+      log.debug('inside on open, currently doing nothing here.');
+    });
+  }
+
+  private addOnMessageListener() {
+    this.ws.on('message', (message: string) => {
+      try {
+        log.debug('got incoming message', message);
+        this.wsHandler.addMessage(message);
+      } catch (e) {
+        log.debug('error getting message', e);
+      }
+    });
+  }
+
+  async verifyOpen() {
+    const readyState = await this.waitForConnectedState(this.wsRequestArgs.timeout);
+    log.debug(`Connection state ${WSState[readyState]}`);
+    if (readyState !== WebSocket.OPEN && !this.hasErrorOccured) {
+      log.error('Could not connect to WebSocket address', { connectionState: WSState[readyState], url: this.ws.url });
+      throw new RequestFailuresError('Could not connect to WebSocket address');
+    }
+  }
+
+  /**
+   * 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
+   */
+  waitForConnectedState = async (timeout: number = WS_CONNECTION_TIMEOUT_MS): Promise<WSState> => {
+    const WS_CONNECTION_INTERVAL_MS = 100;
+    if (this.ws.readyState !== WebSocket.CONNECTING) {
+      return this.ws.readyState;
+    }
+    else {
+      const maxIterations = timeout / WS_CONNECTION_INTERVAL_MS;
+      let i = 0;
+      while (this.ws.readyState === WebSocket.CONNECTING && i < maxIterations) {
+        await delay(WS_CONNECTION_INTERVAL_MS);
+        i++;
+      }
+      return this.ws.readyState;
+    }
+  };
+
+  private sendMessage() {
+    log.debug('about to send message', { readyState: WSState[this.ws.readyState] } );
+    if (this.ws.readyState === WSState.OPEN && this.wsRequestArgs.message) {
+      log.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
+  on(_eventName: string, _cb: Function) {
+    //do nothing
+  }
+}
+
+export class WSSequenceHandler {
+  private _connections: { [url: string]: WebSocket };
+  messages: string[];
+  constructor() {
+    this._connections = {};
+    this.clearMessages();
+  }
+
+  getConnection(url: string): WebSocket | undefined {
+    return this._connections[url];
+  }
+
+  storeConnection(url: string, wsConnection: WebSocket) {
+    this._connections[url] = wsConnection;
+  }
+
+  async closeAllConnections() {
+    try {
+      log.debug('Closing all ws connections');
+      for (const connection of Object.values(this._connections)) {
+        connection.close();
+      }
+    } catch (e) {
+      log.warn('Failed to close all connections', e, { connections: this._connections });
+    }
+  }
+
+  getMessages() {
+    return this.messages;
+  }
+
+  addMessage(message: string) {
+    this.messages.push(message);
+  }
+
+  clearMessages() {
+    this.messages = [];
+  }
+}
+
+function getConnectionState(existingWS?: WebSocket) {
+  return existingWS ? WSState[existingWS.readyState] : null;
+}
+
+export type WSRequestArguments = {
+  expectedStatus: HttpResponseStatus;
+  headers: LoadmillHeaders
+  message: string;
+  timeout: number;
+  url: string;
+};
+
+export type WSResponse = {
+  status: number;
+  res: {
+    statusMessage: string;
+  };
+  header: LoadmillHeaders;
+  req: {};
+}