@loadmill/executer 0.1.51 → 0.1.54

package/src/mill-info.ts

@@ -1,81 +0,0 @@
-export interface MillInfo {
-  /**
-   * The mill socket IP address (or addresses in case IP is forwarded).
-   */
-  IPs: string[];
-
-  /**
-   * True if and only if this mill is a spy.
-   */
-  spy: boolean;
-
-  /**
-   * True if and only if this mill is a simulator.
-   */
-  sim: boolean;
-
-  /**
-   * True if and only if this mill restricted to using SSL.
-   */
-  onlySsl: boolean;
-
-  /**
-   * True if and only if this mill has cookie support.
-   */
-  cookieAble: boolean;
-
-  /**
-   * True if and only if this mill runs through a proxy.
-   */
-  proxyAble: boolean;
-
-  /**
-   * Number of loads capable of running (Angie)
-   */
-  loadsCapacity: number;
-
-  /**
-   * The location resolved from the first mill IP or an empty string.
-   */
-  location: string;
-
-  /**
-   * The country code provided by Cloudflare or empty string.
-   */
-  countryCode: string;
-
-  /**
-   * The mill user-agent string or an empty string.
-   */
-  userAgent: string;
-
-  /**
-   * The mill browser and version (parsed from user-agent string).
-   */
-  browserVersion: string;
-
-  /**
-   * The full affiliate id.
-   */
-  affiliateId: string;
-
-  /**
-   * The owner of the agent.
-   */
-  userId?: string;
-
-  /**
-   * The agent's owner's team.
-   */
-  teamId?: string;
-
-  /**
-   * Agent pool(if the user supplied)
-   */
-  pool?: string;
-
-  /**
-   * If the agent can't handle API tests
-   */
-  noApi: boolean;
-}

package/src/mill-version.ts

@@ -1,7 +0,0 @@
-export const millVersion = {
-  major: 9,
-  minor: 55,
-  patch: 0,
-};
-
-export const millVersionString = `${millVersion.major}.${millVersion.minor}.${millVersion.patch}`;

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

@@ -1,160 +0,0 @@
-import {
-  AssignmentExpression,
-  AssignmentProperty,
-  ExpressionStatement,
-  Identifier,
-  ObjectPattern,
-  Pattern,
-  RestElement,
-  SequenceExpression,
-  VariableDeclaration,
-} from 'estree';
-import { ESTree } from '../parser/js-parser';
-import { AcornJSParser } from '../parser/acorn-js-parser';
-import { ArrayPattern, FunctionDeclaration } from './types';
-import {
-  isArray,
-  isAssignmentExpression,
-  isExpressionStatement,
-  isFunctionDeclaration,
-  isIdentifier,
-  isObject,
-  isRestElement,
-  isSequenceExpression,
-  isVariableDeclaration,
-} from './type-guard';
-
-export class ASTWalker {
-  private ast: ESTree;
-  private untouchables: string[];
-  private detected: Set<string>;
-
-  constructor(script: string) {
-    this.ast = new AcornJSParser().parse(script);
-    this.untouchables = [];
-    this.detected = new Set();
-  }
-
-  public detectDeclarations = (untouchables: string[]): string[] => {
-    this.untouchables = untouchables;
-
-    for (const node of this.ast.body) {
-      if (isFunctionDeclaration(node)) {
-        this.addDeclaredFunction(node as FunctionDeclaration);
-      }
-      else if (isVariableDeclaration(node)) {
-        this.addDeclaredVariables(node as VariableDeclaration);
-      }
-      else if (isExpressionStatement(node)) {
-        this.addImplicitDeclarations(node as ExpressionStatement);
-      }
-    }
-    return Array.from(this.detected);
-  };
-
-  private addDeclaredFunction = (node: FunctionDeclaration) => {
-    this.addIdentifier(node.id);
-  };
-
-  private getIdentifierName = (id: Identifier) => id.name;
-
-  private addNestedDeclaredProps = ({ properties }: ObjectPattern) => {
-    for (const prop of properties) {
-      if (isRestElement(prop)) {
-        this.addRestElement(prop as RestElement);
-      }
-      else {
-        this.addAssignmentProperty(prop as AssignmentProperty);
-      }
-    }
-  };
-
-  private addAssignmentProperty = ({ value }: AssignmentProperty) => {
-    if (isIdentifier(value)) {
-      this.addIdentifier(value as Identifier);
-    }
-    else if (isObject(value)) {
-      this.addNestedDeclaredProps(value as ObjectPattern);
-    }
-    else if (isArray(value)) {
-      this.addDestructuredArrayElements(value as ArrayPattern);
-    }
-  };
-
-  private addRestElement = ({ argument }: RestElement) => {
-    if (isIdentifier(argument)) {
-      this.addIdentifier(argument as Identifier);
-    }
-    else if (isObject(argument)) {
-      this.addNestedDeclaredProps(argument as ObjectPattern);
-    }
-  };
-
-  private addDestructuredArrayElements = ({ elements }: ArrayPattern) => {
-    for (const element of elements) {
-      if (isIdentifier(element)) {
-        this.addIdentifier(element as Identifier);
-      }
-      else if (isRestElement(element)) {
-        this.addRestElement(element as RestElement);
-      }
-      else if (isObject(element)) {
-        this.addNestedDeclaredProps(element as ObjectPattern);
-      }
-      else if (isArray(element)) {
-        this.addDestructuredArrayElements(element as ArrayPattern);
-      }
-    }
-  };
-
-  private addDeclaredVariables = (node: VariableDeclaration) => {
-    for (const declaration of node.declarations) {
-      const pattern: Pattern = declaration.id;
-      if (isIdentifier(pattern)) {
-        this.addIdentifier(pattern as Identifier);
-      }
-      else if (isObject(pattern)) {
-        this.addNestedDeclaredProps(pattern as ObjectPattern);
-      }
-      else if (isArray(pattern)) {
-        this.addDestructuredArrayElements(pattern as ArrayPattern);
-      }
-    }
-  };
-
-  private addImplicitDeclarations = ({ expression }: ExpressionStatement) => {
-    if (isAssignmentExpression(expression)) {
-      this.addSingleImplicitVar(expression as AssignmentExpression);
-    }
-    else if (isSequenceExpression(expression)) {
-      this.addMultipleImplicitVar(expression as SequenceExpression);
-    }
-  };
-
-  private addSingleImplicitVar = (expression: AssignmentExpression) => {
-    if (isIdentifier(expression.left)) {
-      const assignedName = this.getIdentifierName(expression.left as Identifier);
-      if (!this.untouchables.includes(assignedName)) {
-        this.addIdentifier(expression.left as Identifier);
-      }
-    }
-    else if (isObject(expression.left)) {
-      this.addNestedDeclaredProps(expression.left as ObjectPattern);
-    }
-    else if (isArray(expression.left)) {
-      this.addDestructuredArrayElements(expression.left as ArrayPattern);
-    }
-  };
-
-  private addMultipleImplicitVar = ({ expressions }: SequenceExpression) => {
-    for (const expression of expressions) {
-      if (isAssignmentExpression(expression)) {
-        this.addSingleImplicitVar(expression as AssignmentExpression);
-      }
-    }
-  };
-
-  private addIdentifier(id: Identifier) {
-    this.detected.add(this.getIdentifierName(id));
-  }
-}

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)
-  );
-}