@loadmill/executer 0.1.36 → 0.1.40

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,16 @@ import {
   ALLOWED_RESPONSE_STATUSES,
   LoopConf,
   DEFAULT_REQUEST_TIMEOUT,
-  CachePenetrationModes
+  CachePenetrationModes,
+  RequestPostData,
+  PostFormData
 } 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 +130,7 @@ class SequenceExecutor {
   resolvedRequests: ResolvedRequest[] = [];
   keepaliveHTTPSAgent;
   keepaliveHTTPAgent;
+  wsHandler: WSSequenceHandler;
 
   constructor(
     private httpAgent,
@@ -143,6 +147,7 @@ class SequenceExecutor {
       freeSocketTimeout: SOCKET_TIMEOUT / 2
     });
     this.postScriptRunner = new PostScriptRunner();
+    this.wsHandler = new WSSequenceHandler();
   }
 
   startAndPass(requests: LoadmillRequest[]) {
@@ -213,9 +218,11 @@ class SequenceExecutor {
           log.info('Unexpected error info:', unexpectedError);
         }
 
+        this.wsHandler.closeAllConnections();
         throw error;
       }
     }
+    this.wsHandler.closeAllConnections();
   }
 
   shouldStop(request: LoadmillRequest) {
@@ -309,12 +316,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 +334,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 +512,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 - ')
       )
     );
@@ -520,7 +541,7 @@ class SequenceExecutor {
 
     const url = urlObj.toString();
     this.resolvedRequests[reqIndex].url = url;
- 
+
     this.validateDomain(uriUtils.getDomain(url));
 
     const method = requestConf.method.toLowerCase();
@@ -546,8 +567,11 @@ class SequenceExecutor {
       request.auth(auth.user || '', auth.password || '');
     }
 
-    const postData = requestConf.postData;
-    if (postData) {
+    const { postData, postFormData } = requestConf;
+    if (postFormData) {
+      this.preparePostFormData(postFormData, request, reqIndex);
+    }
+    else if (postData) {
       // It is CRUCIAL that the type is set before the body:
       const mimeType = postData.mimeType;
       if (mimeType && request._header['content-type'] == null) {
@@ -637,7 +661,7 @@ class SequenceExecutor {
       // This makes superagent populate res.text regardless of the response's content type:
       request.buffer();
 
-      // Otherwise we expose superagent and its version - 
+      // Otherwise we expose superagent and its version -
       // better have something more general (in case the user didnt set one):
       const uaHeader = request.get('User-Agent');
       if (!uaHeader || uaHeader.startsWith('node-superagent')) {
@@ -654,6 +678,94 @@ class SequenceExecutor {
     return request;
   }
 
+  private preparePostFormData(postFormData: PostFormData, request: any, reqIndex: number) {
+    const resolvedPostFormData: PostFormData = [];
+    let size = 0;
+    const MAX_BODY_SIZE = getMaxRequestBodySize();
+    for (const entry of postFormData) {
+      const { name, value, fileName } = entry;
+      const resolvedName = this.resolve(name, (err) => setParameterErrorHistogram(err, 'Failed to resolve form-data key - '));
+      size += resolvedName.length;
+      if (fileName) {
+        const resolvedFileName = this.resolve(fileName, (err) => setParameterErrorHistogram(err, 'Failed to resolve form-data fileName - '));
+        size += (resolvedFileName.length + value.length);
+        const buffer = Buffer.from(value, 'binary');
+        request.attach(resolvedName, buffer, resolvedFileName);
+        resolvedPostFormData.push({ name: resolvedName, value, fileName: resolvedFileName });
+      } else {
+        const resolvedValue = this.resolve(value, (err) => setParameterErrorHistogram(err, 'Failed to resolve form-data value - '));
+        size += resolvedValue.length;
+        request.field(resolvedName, resolvedValue);
+        resolvedPostFormData.push({ name: resolvedName, value: resolvedValue });
+      }
+      if (size > MAX_BODY_SIZE) {
+        throw new RequestFailuresError('Form Data size is too large');
+      }
+    }
+
+    this.resolvedRequests[reqIndex].postFormData = resolvedPostFormData;
+  }
+
+  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,
@@ -668,7 +780,7 @@ class SequenceExecutor {
   };
 
   private validateDomain(domain: string) {
-    if (isEmpty(domain)){
+    if (isEmpty(domain)) {
       const message = 'HTTP request domain name is empty';
       throw new RequestFailuresError(message, { [message]: 1 });
     }
@@ -715,9 +827,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 +857,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 +1005,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 +1022,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 +1058,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,273 @@
+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';
+import { ClientRequest, IncomingMessage, IncomingHttpHeaders } from 'http';
+import { Socket } from 'net';
+
+declare class WS extends WebSocket {
+  _req: WSClientRequest | null;
+}
+declare class WSClientRequest extends ClientRequest {
+  socket: Socket & { parser: ParserIncomingMessage };
+}
+declare class ParserIncomingMessage {
+  incoming: IncomingMessage;
+}
+
+
+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: WSResponse = {
+      status: undefined,
+      res: {
+        statusMessage: undefined,
+      },
+      header: {},
+      req: {},
+    };
+
+    const existingWS = this.wsHandler.getConnection(this.wsRequestArgs.url);
+
+    existingWS && log.debug(`Existing 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(response);
+    this.addOnUpgradeListener(response);
+    this.addOnOpenListener();
+    this.addOnMessageListener();
+  }
+
+  private addOnErrorListener(response: WSResponse) {
+    this.ws.addEventListener('error', event => {
+      log.debug('inside addEventListener error');
+      try {
+        const target = event.target as WS;
+        this.updateResponseOnError(target, response);
+      } catch (e) {
+        log.error('Got an error inside addEventListener error', e);
+      }
+    });
+
+    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 updateResponseOnError(ws: WS, response: WSResponse) {
+    if (ws._req) {
+      const { statusCode, statusMessage, headers } = ws._req.socket.parser.incoming;
+      log.debug('Got incoming incoming request', { statusCode, statusMessage, headers });
+      response.status = statusCode;
+      response.res.statusMessage = statusMessage;
+      response.header = headers;
+    }
+  }
+
+  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);
+    const connectionDebugMsg = `Connection ${WSState[readyState]}`;
+    log.debug(connectionDebugMsg);
+    if (readyState !== WebSocket.OPEN && !this.hasErrorOccured) {
+      let msg = 'Could not connect to WebSocket address: ';
+      log.debug(msg, { connectionState: WSState[readyState], url: this.ws.url });
+      if (readyState === WSState.CONNECTING) {
+        msg += 'request timeout';
+      } else { // CLOSING or CLOSED state
+        msg += connectionDebugMsg;
+      }
+      throw new RequestFailuresError(msg);
+    }
+  }
+
+  /**
+   * 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 != null && 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 | IncomingHttpHeaders;
+  req: {};
+}