@loadmill/executer 0.1.51 → 0.1.54

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

package/src/sampler.ts

@@ -1,133 +0,0 @@
-import log from '@loadmill/universal/dist/log';
-import * as mathUtils from '@loadmill/universal/dist/math-utils';
-import * as promiseUtils from '@loadmill/universal/dist/promise-utils';
-import { minimalRemainingDuration, reportDelay } from '@loadmill/core/dist/conf';
-import { runSingleIteration } from './single-runner';
-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;
-
-export interface SamplerFaja {
-  cancelWork(finished: boolean);
-  send(obj: string);
-  reportIntervalId;
-  isStopped: boolean;
-  keeper;
-}
-
-export class Sampler {
-  avgResTime = 0;
-  expired = false;
-  successfulHits = 0;
-  failedIterations = 0;
-  startedIterations = 0;
-  failures: Failures = {};
-  successfulIterations = 0;
-  requestStats: PerRequestStats = {};
-
-  constructor(private samplerMill: SamplerFaja, private work: Work) {}
-
-  startSampling = () => {
-    this.samplerMill.cancelWork(false);
-
-    promiseUtils.delay(this.work.duration || DEFAULT_DURATION).then(
-      () => {
-        if (!this.samplerMill.isStopped) {
-          log.debug('Time\'s up!');
-          this.expired = true;
-          this.sendReport();
-        }
-      }
-    );
-
-    const requests = this.work.requests;
-    const iterationDelay = this.work.iterationDelay || DEFAULT_ITERATION_DELAY;
-
-    const reportDelayy = reportDelay(iterationDelay, requests);
-    this.samplerMill.reportIntervalId = setInterval(
-      this.sendReport,
-      reportDelayy
-    );
-
-    this.samplerMill.isStopped = false;
-    this.runAll();
-  };
-
-  runAll = async () => {
-    while (!this.isDone()) {
-      ++this.startedIterations;
-      log.trace('Executing iteration: ', this.startedIterations);
-
-      const res = await runSingleIteration(this.work);
-      this.samplerMill.keeper.keepIfNeeded(res, RES_KEEP_TIME);
-
-      const resFailures = res.failures;
-
-      if (!resFailures || Object.keys(resFailures).length === 0) {
-        ++this.successfulIterations;
-      } else {
-        ++this.failedIterations;
-        mergeFailures(this.failures, resFailures);
-      }
-
-      this.avgResTime = mathUtils.calcAvg(
-        this.avgResTime,
-        this.successfulHits,
-        res.avgResTime,
-        res.successfulHits
-      );
-      this.successfulHits += res.successfulHits;
-
-      Object.keys(res.requestStats).forEach(index => {
-        setReqStats(this.requestStats, index, ...res.requestStats[index].resTimes);
-      });
-
-
-      if (!this.isDone()) {
-        // We count only the delay of the requests that were NOT ATTEMPTED.
-        // Note that the first request delay is always ignored:
-        const skipCount = res.lastStartedIndex + 1;
-        await promiseUtils.delay(
-          minimalRemainingDuration(
-            this.work.iterationDelay || DEFAULT_ITERATION_DELAY,
-            this.work.requests,
-            skipCount
-          )
-        );
-      }
-    }
-
-    if (!this.samplerMill.isStopped) {
-      log.debug('Finished last iteration:', this.startedIterations);
-      this.sendReport();
-      this.samplerMill.cancelWork(true);
-    }
-  };
-
-  isDone = () => {
-    return this.samplerMill.isStopped || this.expired || this.startedIterations >= this.work.iterations;
-  };
-
-  sendReport = () => {
-    const report = {
-      failures: this.failures,
-      hits: this.successfulHits,
-      avgResTime: this.avgResTime,
-      requestStats: this.requestStats,
-      failedIterations: this.failedIterations,
-      successfulIterations: this.successfulIterations,
-    };
-
-    log.trace('Sending report:', report);
-    this.samplerMill.send(messageCreators.report(report));
-
-    this.failures = {};
-    this.requestStats = {};
-    this.successfulIterations = this.successfulHits = this.failedIterations = this.avgResTime = 0;
-  };
-}