@loadmill/executer 0.1.52 → 0.1.53

package/src/post-script/ast-walker/type-guard.ts

@@ -1,73 +0,0 @@
-import {
-  AssignmentExpression,
-  ExpressionStatement,
-  Identifier,
-  Node,
-  ObjectPattern,
-  RestElement,
-  SequenceExpression,
-  VariableDeclaration,
-} from 'estree';
-import { isNonEmptyString } from '@loadmill/universal/dist/string-utils';
-import {
-  ArrayPattern,
-  Declarations,
-  Expressions,
-  FunctionDeclaration,
-  Patterns,
-  Statements,
-} from './types';
-import './types';
-
-export const isFunctionDeclaration = (node: Node) => {
-  return isOfType(node, Declarations, Declarations.FunctionDeclaration) && hasId(node as FunctionDeclaration);
-};
-const hasId = (node: FunctionDeclaration) => !!node.id;
-
-export const isVariableDeclaration = (node: Node) => {
-  return isOfType(node, Declarations, Declarations.VariableDeclaration) && hasDeclarations(node as VariableDeclaration);
-};
-const hasDeclarations = (node: VariableDeclaration) => Array.isArray(node.declarations);
-
-export const isExpressionStatement = (node: Node) => {
-  return isOfType(node, Statements, Statements.ExpressionStatement) && hasExpression(node as ExpressionStatement);
-};
-const hasExpression = (node: ExpressionStatement) => !!node.expression;
-
-export const isAssignmentExpression = (node: Node) => {
-  return isOfType(node, Expressions, Expressions.AssignmentExpression) && hasLeft(node as AssignmentExpression);
-};
-const hasLeft = (node: AssignmentExpression) => !!node.left;
-
-export const isSequenceExpression = (node: Node) => {
-  return isOfType(node, Expressions, Expressions.SequenceExpression) && hasExpressions(node as SequenceExpression);
-};
-const hasExpressions = (node: SequenceExpression) => Array.isArray(node.expressions);
-
-export const isIdentifier = (node: Node) => {
-  return isOfType(node, Patterns, Patterns.Identifier) && hasName(node as Identifier);
-};
-const hasName = (id: Identifier) => isNonEmptyString(id.name);
-
-export const isArray = (node: Node) => {
-  return isOfType(node, Patterns, Patterns.ArrayPattern) && hasElements(node as ArrayPattern);
-};
-const hasElements = (node: ArrayPattern) => Array.isArray(node.elements);
-
-export const isObject = (node: Node) => {
-  return isOfType(node, Patterns, Patterns.ObjectPattern) && hasProperties(node as ObjectPattern);
-};
-const hasProperties = (node: ObjectPattern) => Array.isArray(node.properties);
-
-export const isRestElement = (node: Node) => {
-  return isOfType(node, Patterns, Patterns.RestElement) && hasArgument(node as RestElement);
-};
-const hasArgument = (rest: RestElement) => !!rest.argument;
-
-const isOfType = (
-  node: Node,
-  enumerator: any, // can't type an enum for some reason
-  type: Expressions | Patterns | Statements | Declarations
-) => {
-  return node.type === enumerator[type];
-};

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

@@ -1,35 +0,0 @@
-import {
-  ArrayPattern as ESTArrayPattern,
-  FunctionDeclaration as ESTFunctionDeclaration,
-  Identifier,
-  Pattern,
-} from 'estree';
-
-export interface ArrayPattern extends ESTArrayPattern {
-  elements: Array<Pattern>;
-}
-
-export interface FunctionDeclaration extends ESTFunctionDeclaration {
-  id: Identifier;
-}
-
-export enum Declarations {
-  FunctionDeclaration = 'FunctionDeclaration',
-  VariableDeclaration = 'VariableDeclaration',
-}
-
-export enum Expressions {
-  AssignmentExpression = 'AssignmentExpression',
-  SequenceExpression = 'SequenceExpression',
-}
-
-export enum Patterns {
-  ObjectPattern = 'ObjectPattern',
-  ArrayPattern = 'ArrayPattern',
-  RestElement = 'RestElement',
-  Identifier = 'Identifier',
-}
-
-export enum Statements {
-  ExpressionStatement = 'ExpressionStatement',
-}

package/src/post-script/console-log.ts

@@ -1,24 +0,0 @@
-export const LINE_LIMIT = 1000;
-export const CONSOLE_LOG_LIMIT = 100;
-
-const isPassedTheLimit = (line) => line.length > LINE_LIMIT;
-
-export const myConsole = {
-  stdout: [] as string[],
-  log: (...args) => {
-    if (myConsole.stdout.length >= CONSOLE_LOG_LIMIT) {
-      return;
-    }
-    let line = '';
-    for (const item of args) {
-      line += typeof item === 'object' ? JSON.stringify(item, undefined, 2) : item;
-      if (isPassedTheLimit(line)) {
-        line = line.substring(0, LINE_LIMIT) + '\n...';
-        break;
-      }
-      line += ' ';
-    }
-    !!line && myConsole.stdout.push(line);
-  },
-  setStdout: (newStdout) => myConsole.stdout = newStdout,
-};

package/src/post-script/parser/acorn-js-parser.ts

@@ -1,8 +0,0 @@
-import { parse, Options } from 'acorn';
-import { ESTree, JSParser } from './js-parser';
-
-export class AcornJSParser implements JSParser {
-  parse(script: string, options: Options = { ecmaVersion: 2020 }): ESTree {
-    return parse(script, options) as ESTree;
-  }
-}

package/src/post-script/parser/js-parser.ts

@@ -1,22 +0,0 @@
-import { Node, Program } from 'estree';
-import { Parser } from './parser';
-
-interface JSParser extends Parser {
-  parse(script: string, options?: JSParserOptions): ESTree;
-}
-
-type ExtendNode<T> = {
-  [K in keyof T]: T[K] extends object ? ExtendNode<T[K]> : T[K];
-} & (T extends Node ? {
-  start: number;
-  end: number;
-} : {});
-
-type ESTree = ExtendNode<Program>;
-type JSParserOptions = { ecmaVersion: number | string }
-
-export {
-  ESTree,
-  JSParser,
-  JSParserOptions,
-};

package/src/post-script/parser/parser.ts

@@ -1,5 +0,0 @@
-export interface Parser {
-  parse(script: string): AbstractSyntaxTree;
-}
-
-export type AbstractSyntaxTree = { [name: string]: any };

package/src/post-script/post-script-executor.ts

@@ -1,93 +0,0 @@
-import { strict as assert } from 'assert';
-import { SequenceExecutorParameters } from '@loadmill/core/dist/parameters';
-import { ParameterFunctionOperations } from '@loadmill/core/dist/parameters/parameter-functions/parameter-functions';
-import { ASTWalker } from './ast-walker';
-import { VM2VirtualMachine } from './virtual-machine/vm2-virtual-machine';
-import { myConsole } from './console-log';
-
-export class PostScriptRunner {
-  public run = (
-    staticContext: OuterStaticContext = { staticContext: { $: {}, __: {} } },
-    dynamicContext: SequenceExecutorParameters = {},
-    userCode: string = ''
-  ): SequenceExecutorParameters => {
-    const newVariables = new ASTWalker(userCode).detectDeclarations(Object.keys(staticContext));
-    const wrappedUserCode = this.wrapUserCode(dynamicContext, userCode, newVariables);
-    const stdout = [];
-    myConsole.setStdout(stdout);
-
-    const vm = new VM2VirtualMachine();
-    vm.create({
-      globalObject: { assert, ...dynamicContext, console: myConsole },
-      staticObject: staticContext,
-    });
-
-    const modifiedDynamicContext = vm.run(wrappedUserCode);
-    this.validateCircularDependency(modifiedDynamicContext);
-    this.removeAssertModule(modifiedDynamicContext);
-    return { result: modifiedDynamicContext, stdout: myConsole.stdout };
-  };
-
-  private wrapUserCode = (
-    dynamicContext: SequenceExecutorParameters = {},
-    userCode: string = '',
-    newVariables: string[] = []
-  ) => {
-    const prefix =
-    `
-      Buffer = {};
-      global = { assert: global.assert, console: global.console };
-      const $ = staticContext.$;
-      const __ = staticContext.__;
-    `;
-
-    const suffix =
-    `
-      exports = {
-        ${[...Object.keys(dynamicContext), ...newVariables].join()}
-      };
-    `;
-
-    return prefix + userCode + suffix;
-  }
-
-  validateCircularDependency = (obj: SequenceExecutorParameters) => {
-    function circularError (propName: string) {
-      return new TypeError(`Cyclic object value. Circular reference in property ${propName}`);
-    }
-
-    findCircular(obj);
-
-    function findCircular(
-      obj: SequenceExecutorParameters,
-      _refs: WeakSet<SequenceExecutorParameters> = new WeakSet()
-    ) {
-      if (typeof obj === 'object' && obj !== null) {
-        _refs.add(obj);
-        for (const key in obj) {
-          if (_refs.has(obj[key])) {
-            throw circularError(key);
-          }
-          findCircular(obj[key], _refs);
-        }
-        _refs.delete(obj);
-      }
-    }
-  };
-
-  private removeAssertModule(context: SequenceExecutorParameters) {
-    Object.keys(context).forEach(key => {
-      if (context[key]?.assert?.name === 'strict') {
-        context[key] = {};
-      }
-    });
-  }
-}
-type OuterStaticContext = {
-  staticContext: StaticContext;
-};
-
-type StaticContext = {
-  $: SequenceExecutorParameters;
-  __: ParameterFunctionOperations;
-};

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

@@ -1,15 +0,0 @@
-export interface VirtualMachine {
-  engine: Engine;
-  create(options: VirtualMachineOptions): Engine;
-  run(code: string): object;
-}
-
-export interface VirtualMachineOptions {
-  globalObject?: object;
-  staticObject?: object;
-  timeout?: number;
-  memoryLimit?: number;
-  async?: boolean;
-}
-
-export type Engine = any;

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

@@ -1,45 +0,0 @@
-import { VM } from 'vm2';
-import { SequenceExecutorParameters } from '../../../../core/dist/parameters';
-
-import { Engine, VirtualMachine, VirtualMachineOptions } from './virtual-machine';
-
-export class VM2VirtualMachine implements VirtualMachine {
-  public engine: VM;
-  private DEFAULT_TIMOUT_MS = Number(process.env.POSTSCRIPT_TIMEOUT_MS) || 1000;
-
-  create(options: VirtualMachineOptions): Engine {
-    const { timeout, globalObject, async, staticObject } = options;
-    this.engine = new VM({
-      timeout: timeout || this.DEFAULT_TIMOUT_MS,
-      fixAsync: !async,
-      eval: false,
-      wasm: false,
-    });
-
-    this.makeStatic(staticObject);
-
-    this.setGlobals(globalObject);
-  }
-
-  makeStatic(obj: object = {}) {
-    this.deepFreeze(obj);
-  }
-
-  deepFreeze = (obj: object) => {
-    for (const key of Object.keys(obj)) {
-      if (typeof obj[key] === 'object' && obj[key] !== null) {
-        this.engine.freeze(obj[key], key); // freeze me
-        this.deepFreeze(obj[key]); // freeze my childrens
-      }
-    }
-    return this.engine.freeze(obj); // freeze root
-  };
-
-  setGlobals = (globalObject: SequenceExecutorParameters = {}) => {
-    this.engine.setGlobals(globalObject);
-  }
-
-  run(code: string): SequenceExecutorParameters {
-    return this.engine.run(code);
-  }
-}

package/src/report-types.ts

@@ -1,127 +0,0 @@
-import { Failures } from './failures';
-import { MillInfo } from './mill-info';
-import { PerRequestResTime, PerRequestStats } from './request-stats';
-
-export type LoadResult = 'done' | 'aborted' | 'failed';
-
-/**
- * This report contains all the info that comes from Redis each time there is a status update.
- */
-export interface LoadStatusReport extends AggregatedStatsReport {
-  endTime?: number;
-  startTime?: number;
-  result?: LoadResult;
-  activeSessions?: number;
-}
-
-/**
- * This report contains all the aggregated stats computed from individual mill reports.
- */
-export interface AggregatedStatsReport extends BasicStatsReport {
-  /**
-   * The number of separate sessions / mills that sent at least one report.
-   */
-  reportedSessions?: number;
-
-  append?: boolean;
-  failures?: Failures;
-  browserStatsMap?: StatsMap;
-  locationStatsMap?: StatsMap;
-  serverMetrics?: ServerMetrics;
-  avgResTimeSequence?: SequenceObj;
-  requestStats?: PerRequestResTime;
-  failureReportsMap?: HashKeysToReportIds;
-}
-
-/**
- * A mapping that aggregates stats according to a certain feature, e.g. stats per browser version.
- */
-export interface StatsMap {
-  [feature: string]: BasicStatsReport & {
-    sessions: number;
-  };
-}
-
-/**
- * A sequence of stats (currently only the average response time) reported within a certain
- * interval (between `firstTime` and `lastTime`).
- */
-export interface SequenceObj {
-  append?: boolean;
-  sequence: ClientMetrics;
-}
-
-export type ClientMetrics = ClientMetricsClump[];
-
-export type ClientMetricsClump = {
-  s?: number;
-  f?: number;
-  avg: number;
-  time: number;
-  p50?: number;
-  p95?: number;
-  weight: number;
-  concurrency: number;
-};
-
-export type ServerMetrics = ServerMetricsClump[];
-
-export type ServerMetricsClump = {
-  _t: number;
-
-  uc?: number;
-  tc?: number;
-
-  tm?: number;
-  hm?: number;
-  uhm?: number;
-};
-
-export type HashKeysToReportIds = { [hashKey: string]: string };
-
-/**
- * This is the report sent to Redis every time a mill report is received.
- */
-export type ToStoreStatsReport = StatsReportWithMillInfo & {
-  timestamp: number;
-  firstReport: boolean;
-};
-
-/**
- * This report includes a single mill stats report along with additional meta data.
- */
-export type StatsReportWithMillInfo = FromMillStatsReport &
-  MillInfo & {
-    lordId: string;
-  };
-
-/**
- * The stats report sent by the mill.
- */
-export interface FromMillStatsReport extends BasicStatsReport {
-  failures?: Failures;
-  requestStats?: PerRequestStats;
-}
-
-/**
- * The basic stats we are usually interested in.
- */
-export interface BasicStatsReport {
-  hits?: number;
-  avgResTime?: number;
-  failedIterations?: number;
-  successfulIterations?: number;
-}
-
-export function isInformative({
-  hits,
-  avgResTime,
-  failedIterations,
-  successfulIterations,
-}: FromMillStatsReport) {
-  return (
-    (hits && hits > 0 && avgResTime != null && avgResTime >= 0) ||
-    (failedIterations && failedIterations > 0) ||
-    (successfulIterations && successfulIterations > 0)
-  );
-}

package/src/request-sequence-result.ts

@@ -1,63 +0,0 @@
-import { Failures } from './failures';
-import { PerRequestStats } from './request-stats';
-import { Parameters } from '@loadmill/core/dist/parameters';
-import {
-  LoadmillHeaders,
-  LoadmillRequest,
-  PostFormData,
-  RequestPostData,
-} from '@loadmill/core/dist/request';
-
-export function extendSequenceResult(
-  result: RequestSequenceResult,
-  requests: LoadmillRequest[]
-): ExtendedSequenceResult {
-  return {
-    ...result,
-    resolvedRequests: requests.map((request, index: number) => ({
-      ...request,
-      ...result.resolvedRequests[index],
-    })),
-  };
-}
-
-export interface ExtendedSequenceResult extends RequestSequenceResult {
-  resolvedRequests: ExtendedRequest[];
-  err?: string;
-}
-
-export interface RequestSequenceResult {
-  failures: Failures;
-  avgResTime: number;
-  successfulHits: number;
-  lastStartedIndex: number;
-  requestStats: PerRequestStats;
-  resolvedRequests: ResolvedRequest[];
-}
-
-export type ExtendedRequest = LoadmillRequest & ResolvedRequest;
-
-export interface ResolvedRequest {
-  url?: string;
-  headers?: LoadmillHeaders[];
-  postData?: RequestPostData;
-  postFormData?: PostFormData;
-
-  response?: {
-    type: string;
-    text: string;
-    status: number;
-    statusText: string;
-    headers: LoadmillHeaders[];
-  };
-
-  postParameters?: Parameters[];
-  stdout?: string[];
-  unexpectedError?: {
-    stack: string;
-    message: string;
-    properties: string;
-  };
-
-  retried?: number;
-}

package/src/request-stats.ts

@@ -1,20 +0,0 @@
-export interface PerRequestStats {
-  [index: number]: RequestStats;
-}
-
-export interface RequestStats {
-  resTimes: number[];
-}
-
-export interface PerRequestResTime {
-  [index: number]: { weight: number; avg: number };
-}
-
-export function setReqStats(
-  reqStats: PerRequestStats,
-  index,
-  ...resTimes: number[]
-) {
-  const stats = reqStats[index] || (reqStats[index] = { resTimes: [] });
-  stats.resTimes.push(...resTimes);
-}

package/src/res-keeper.ts

@@ -1,53 +0,0 @@
-import { ObjectMap } from '@loadmill/universal/dist/object-map';
-import * as promiseUtils from '@loadmill/universal/dist/promise-utils';
-import { getFailureKeys } from './failures';
-import { RequestSequenceResult } from './request-sequence-result';
-
-export class ResKeeper {
-  knownKeysToResults: { [key: string]: string } = {};
-  results = new ObjectMap<RequestSequenceResult>(this.generateResultKey);
-
-  constructor(private generateResultKey?) {}
-
-  getKnownKeys = () => Object.keys(this.knownKeysToResults);
-
-  mapToResultIds = (failureKeys) => {
-    const map: { [key: string]: string } = {};
-    failureKeys.forEach((key) => (map[key] = this.knownKeysToResults[key]));
-
-    return map;
-  };
-
-  keepIfNeeded = (result: RequestSequenceResult, keepFor?: number) => {
-    const failureKeys = getFailureKeys(result.failures);
-
-    if (failureKeys.find((key) => !this.knownKeysToResults[key])) {
-      // We keep it:
-      const id = this.results.add(result);
-      failureKeys.forEach((key) => (this.knownKeysToResults[key] = id));
-
-      if (keepFor) {
-        promiseUtils.delay(keepFor).then(() => this.results.remove(id));
-      }
-    }
-  };
-
-  popForKeys = (failureKeys: string[], withIds = false) => {
-    return failureKeys
-      .map((key) => {
-        const id = this.knownKeysToResults[key];
-
-        if (id) {
-          const res = this.results.get(id);
-          this.results.remove(id);
-
-          if (withIds && res) {
-            res['id'] = id;
-          }
-
-          return res;
-        }
-      })
-      .filter(Boolean);
-  };
-}