@api-client/core 0.3.4 → 0.3.7

package/src/models/SerializableError.ts

@@ -0,0 +1,80 @@
+interface IErrorOptions {
+  cause?: Error;
+}
+
+export interface ISerializedError {
+  message: string;
+  stack?: string;
+  code?: string | number;
+}
+
+/**
+ * An error that serializes!
+ * It is a copy of the normal definition of an error but allows 
+ * to serialize the value via the toJSON() function and restore previous values 
+ * with the `new()` function.
+ */
+export class SerializableError {
+  message: string;
+  code?: number | string;
+  private stackValue?: string;
+  get stack(): string | undefined {
+    return this.stackValue;
+  }
+
+  get name(): string {
+    return 'SerializableError';
+  }
+
+  constructor();
+  constructor(error: Error);
+  constructor(message: string);
+  constructor(message: string, options: IErrorOptions);
+  constructor(message: string, code?: number | string);
+
+  constructor(message?: string | Error, options: IErrorOptions | number | string = {}) {
+    if (typeof message === 'string') {
+      this.message = message;
+    } else if (message) {
+      this.message = message.message;
+      this.stackValue = message.stack;
+    } else {
+      this.message = '';
+    }
+    if (typeof options === 'string' || typeof options === 'number') {
+      this.code = options;
+    } else if (options.cause && options.cause.stack) {
+      this.stackValue = options.cause.stack;
+    }
+  }
+
+  new(values: ISerializedError): void {
+    if (values.message) {
+      this.message = values.message;
+    }
+    if (values.stack) {
+      this.stackValue = values.stack;
+    }
+    if (values.code || values.code === 0) {
+      this.code = values.code;
+    }
+  }
+
+  toJSON(): ISerializedError {
+    const { message, stackValue: stack, code } = this;
+    const result: ISerializedError = {
+      message,
+    };
+    if (stack) {
+      result.stack = stack;
+    }
+    if (code || code === 0) {
+      result.code = code;
+    }
+    return result;
+  }
+
+  toString(): string {
+    return this.message;
+  }
+}

package/src/runtime/http-engine/ArcEngine.ts

@@ -6,10 +6,10 @@ import { HttpEngine, HttpEngineOptions, HeadersReceivedDetail } from './HttpEngi
 import { IRequestLog } from 'src/models/RequestLog.js';
 import { IHttpRequest } from '../../models/HttpRequest.js';
 import { ArcResponse } from '../../models/ArcResponse.js';
+import { SerializableError } from '../../models/SerializableError.js';
 import { Headers } from '../../lib/headers/Headers.js';
 import { PayloadSupport } from './PayloadSupport.js';
 import { addContentLength, getPort } from './RequestUtils.js';
-import { NetError } from './Errors.js';
 import { INtlmAuthorization } from '../../models/Authorization.js';
 import { NtlmAuth, INtlmAuthConfig } from './ntlm/NtlmAuth.js';
 import { PayloadSerializer } from '../../lib/transformers/PayloadSerializer.js';
@@ -80,7 +80,11 @@ export class ArcEngine extends HttpEngine {
       const message = await this.prepareMessage();
       await this.writeMessage(message);
     } catch (cause) {
-      const err = cause as NetError;
+      const e = cause as any;
+      const err = new SerializableError(e.message, { cause: e });
+      if (e.code || e.code === 0) {
+        err.code = e.code as string;
+      }
       this.abort();
       this._errorRequest({
         message: err.message,
@@ -459,7 +463,7 @@ export class ArcEngine extends HttpEngine {
         if (!this.currentResponse) {
           this.logger.error(`Connection closed without receiving any data.`);
           // The parser haven't found the end of message so there was no message!
-          const e = new NetError('Connection closed without receiving any data', 100);
+          const e = new SerializableError('Connection closed without receiving any data', 100);
           this._errorRequest(e);
         } else {
           // There is an issue with the response. Size mismatch? Anyway,
@@ -1012,7 +1016,7 @@ export class ArcEngine extends HttpEngine {
         } else if (res.statusCode !== 200) {
           this.logger.debug(`The proxy tunnel ended with ${res.statusCode} status code. Erroring request.`);
           connectRequest.destroy();
-          const e = new NetError('A tunnel connection through the proxy could not be established.', 111);
+          const e = new SerializableError('A tunnel connection through the proxy could not be established', 111);
           reject(e);
         } else {
           this.logger.debug(`Established a proxy tunnel.`);

package/src/runtime/http-engine/HttpEngine.ts

@@ -19,6 +19,7 @@ import { HttpResponse } from '../../models/HttpResponse.js';
 import { ResponseRedirect } from '../../models/ResponseRedirect.js';
 import { RequestLog, IRequestLog } from '../../models/RequestLog.js';
 import { RequestTime } from '../../models/RequestTime.js';
+import { SerializableError } from '../../models/SerializableError.js';
 import { ResponseAuthorization } from '../../models/ResponseAuthorization.js';
 import { DefaultLogger } from '../../lib/logging/DefaultLogger.js';
 import { ILogger, Logger } from '../../lib/logging/Logger.js';
@@ -26,7 +27,6 @@ import { Headers } from '../../lib/headers/Headers.js';
 import * as RequestUtils from './RequestUtils.js';
 import { Cookies } from '../../lib/cookies/Cookies.js';
 import { HttpErrorCodes } from './HttpErrorCodes.js';
-import { NetError } from './Errors.js';
 
 export interface HttpEngineOptions extends IRequestBaseConfig {
   /**
@@ -188,7 +188,7 @@ export abstract class HttpEngine extends EventEmitter {
   auth?: IRequestAuthState;
 
   protected mainResolver?: (log: IRequestLog) => void;
-  protected mainRejecter?: (err: NetError) => void;
+  protected mainRejecter?: (err: SerializableError) => void;
   [mainPromiseSymbol]?: Promise<IRequestLog>;
 
   constructor(request: IHttpRequest, opts: HttpEngineOptions = {}) {
@@ -562,7 +562,7 @@ Check your request parameters.`);
       message = opts.message;
     }
     message = message || 'Unknown error occurred';
-    const error = new NetError(message, opts.code);
+    const error = new SerializableError(message, opts.code);
     const log = RequestLog.fromRequest(this.sentRequest);
     const response = ErrorResponse.fromError(error);
     log.response = response;
@@ -855,14 +855,14 @@ Check your request parameters.`);
    * 
    * @param log Either the request execution log or an error.
    */
-  protected finalizeRequest(log: RequestLog | NetError): void {
+  protected finalizeRequest(log: RequestLog | SerializableError): void {
     const { mainRejecter, mainResolver } = this;
     if (!mainRejecter || !mainResolver) {
       // console.error(`Trying to finalize the request but the main resolver is not set.`);
       return;
     }
     
-    if (log instanceof Error) {
+    if (log instanceof SerializableError) {
       mainRejecter(log);
     } else {
       mainResolver(log.toJSON());

package/src/runtime/http-engine/NodeEngine.ts

@@ -8,10 +8,10 @@ import { HttpEngine, HttpEngineOptions, ResponseErrorInit, HeadersReceivedDetail
 import { IHttpRequest } from '../../models/HttpRequest.js';
 import { ArcResponse } from '../../models/ArcResponse.js';
 import { IRequestLog } from '../../models/RequestLog.js';
+import { SerializableError } from '../../models/SerializableError.js';
 import { Headers } from '../../lib/headers/Headers.js';
 import { PayloadSupport } from './PayloadSupport.js';
 import { addContentLength, getPort } from './RequestUtils.js';
-import { NetError } from './Errors.js';
 import { INtlmAuthorization } from '../../models/Authorization.js';
 import { NtlmAuth, INtlmAuthConfig } from './ntlm/NtlmAuth.js';
 
@@ -59,9 +59,14 @@ export class NodeEngine extends HttpEngine {
           request.setTimeout(timeout);
         }
       }
-    } catch (e) {
-      console.warn(e);
-      this.finalizeRequest(e as Error);
+    } catch (cause) {
+      console.warn(cause);
+      const e = cause as any;
+      const err = new SerializableError(e.message, { cause: e });
+      if (e.code || e.code === 0) {
+        err.code = e.code as string;
+      }
+      this.finalizeRequest(e);
     }
   }
 
@@ -593,7 +598,7 @@ export class NodeEngine extends HttpEngine {
           });
         } else {
           connectRequest.destroy();
-          const e = new NetError('A tunnel connection through the proxy could not be established.', 111);
+          const e = new SerializableError('A tunnel connection through the proxy could not be established', 111);
           reject(e);
         }
       });

package/src/runtime/http-engine/NodeEngineDirect.ts

@@ -9,6 +9,7 @@ import { IRequestLog } from 'src/models/RequestLog.js';
 import { IHttpRequest } from '../../models/HttpRequest.js';
 import { ArcResponse } from '../../models/ArcResponse.js';
 import { Headers } from '../../lib/headers/Headers.js';
+import { SerializableError } from '../../models/SerializableError.js';
 import { PayloadSupport } from './PayloadSupport.js';
 import { addContentLength, getPort } from './RequestUtils.js';
 
@@ -85,9 +86,14 @@ export class NodeEngineDirect extends HttpEngine {
       if (timeout > 0) {
         request.setTimeout(timeout);
       }
-    } catch (e) {
-      console.warn(e);
-      this.finalizeRequest(e as Error);
+    } catch (cause) {
+      console.warn(cause);
+      const e = cause as any;
+      const err = new SerializableError(e.message, { cause: e });
+      if (e.code || e.code === 0) {
+        err.code = e.code as string;
+      }
+      this.finalizeRequest(e);
     }
   }
 

package/src/runtime/node/BaseRunner.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from 'events';
+import { IProjectExecutionIteration, IProjectExecutionLog } from '../reporters/Reporter.js';
+
+export abstract class BaseRunner extends EventEmitter {
+  /**
+   * Iteration start time.
+   */
+  protected startTime?: number;
+  /**
+   * Iteration end time.
+   */
+  protected endTime?: number;
+  /**
+   * A list of already executed iterations.
+   */
+  protected executed: IProjectExecutionIteration[] = [];
+
+  /**
+   * Creates the report of the execution.
+   */
+  protected async createReport(): Promise<IProjectExecutionLog> {
+    const log: IProjectExecutionLog = {
+      started: this.startTime as number,
+      ended: this.endTime as number,
+      iterations: this.executed,
+    };
+    return log;
+  }
+}

package/src/runtime/node/ProjectParallelRunner.ts

@@ -0,0 +1,234 @@
+import cluster, { Worker } from 'cluster';
+import { cpus } from 'os';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { HttpProject, IHttpProject } from '../../models/HttpProject.js';
+import { IProjectRunnerOptions } from './ProjectRunner.js';
+import { IProjectExecutionLog, IProjectExecutionIteration } from '../reporters/Reporter.js';
+import { BaseRunner } from './BaseRunner.js';
+
+const numCPUs = cpus().length;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export type WorkerStatus = 'initializing' | 'ready' | 'running' | 'finished' | 'error';
+
+export interface IWorkerInfo {
+  /**
+   * Whether the worker is online.
+   */
+  online: boolean;
+  /**
+   * The number of iterations the worker is performing.
+   */
+  iterations: number;
+  /**
+   * The current status of the worker.
+   */
+  status: WorkerStatus;
+  /**
+   * Optional error message received from the worker.
+   */
+  message?: string;
+}
+
+interface WorkerInfoInternal extends IWorkerInfo {
+  worker: Worker;
+}
+
+export interface IWorkerMessage {
+  cmd: string;
+  data?: unknown;
+}
+
+export interface IProjectParallelRunnerOptions extends IProjectRunnerOptions {
+}
+
+export interface IProjectParallelWorkerOptions extends IProjectRunnerOptions {
+  project: IHttpProject;
+}
+
+export interface ProjectParallelRunner {
+  /**
+   * Dispatched when a status of a worker change.
+   * This can be used to render the current status.
+   */
+  on(event: 'status', listener: (info: IWorkerInfo[]) => void): this;
+  /**
+   * Dispatched when a status of a worker change.
+   * This can be used to render the current status.
+   */
+  once(event: 'status', listener: (info: IWorkerInfo[]) => void): this;
+}
+
+/**
+ * Runs a project in parallel.
+ * It creates a number of workers determined by the number of CPUs available on the current machine
+ * and the number of iterations defined in the configuration options.
+ * 
+ * When the number of iterations is greater then the number of CPUs then 
+ * the program distributes the remaining iterations among created workers.
+ * 
+ * The program dispatched the `status` event. It is dispatched each time when the worker status
+ * change. This event can be user to refresh the UI to reflect the newest state.
+ */
+export class ProjectParallelRunner extends BaseRunner {
+  project: HttpProject;
+  options: IProjectParallelRunnerOptions;
+  workers: WorkerInfoInternal[] = [];
+  private mainResolver?: (report: IProjectExecutionLog) => void;
+  private mainRejecter?: (err: Error) => void;
+
+  constructor(project: HttpProject, opts: IProjectParallelRunnerOptions = {}) {
+    super();
+    this.project = project;
+    this.options = opts || {};
+
+    this._exitHandler = this._exitHandler.bind(this);
+  }
+
+  execute(): Promise<IProjectExecutionLog> {
+    return new Promise((resolve, reject) => {
+      this.mainResolver = resolve;
+      this.mainRejecter = reject;
+      this._execute();
+    });
+  }
+
+  private _execute(): void {
+    try {
+      cluster.setupPrimary({
+        exec: join(__dirname, 'ProjectRunnerWorker.js'),
+        silent: true,
+      });
+      const { iterations = 1 } = this.options;
+      const poolSize = Math.min(iterations, numCPUs);
+      for (let i = 0; i < poolSize; i++) {
+        const worker = cluster.fork();
+        this.setupWorker(worker);
+      }
+      this.distributeIterations();
+      this.emit('status', this.getStatusWorkers());
+      cluster.on('exit', this._exitHandler);
+    } catch (e) {
+      const cause = e as Error;
+      this.mainRejecter!(cause);
+    }
+  }
+
+  private getStatusWorkers(): IWorkerInfo[] {
+    const { workers } = this;
+    const result: IWorkerInfo[] = [];
+    workers.forEach((info) => {
+      const cp = { ...info } as any;
+      delete cp.worker;
+      result.push(cp);
+    });
+    return result;
+  }
+
+  private distributeIterations(): void {
+    const workers = this.workers.length;
+    const { iterations = 1 } = this.options;
+    let iterationsRemaining = iterations - workers;
+    let currentIndex = 0;
+    while (iterationsRemaining > 0) {
+      this.workers[currentIndex].iterations += 1;
+      iterationsRemaining--;
+      currentIndex++;
+      if (currentIndex + 1 === workers) {
+        currentIndex = 0;
+      }
+    }
+  }
+
+  private setupWorker(worker: Worker): void {
+    this.workers.push({
+      worker,
+      online: false,
+      iterations: 1,
+      status: 'initializing',
+    });
+    worker.on('message', this._messageHandler.bind(this, worker));
+  }
+
+  private _messageHandler(worker: Worker, message: IWorkerMessage): void {
+    switch (message.cmd) {
+      case 'online': this.setOnline(worker); break;
+      case 'result': this.setRunResult(worker, message); break;
+      case 'error': this.setRunError(worker, message); break;
+    }
+  }
+
+  private _exitHandler(worker: Worker): void {
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    this.finishWhenReady();
+  }
+
+  private setOnline(worker: Worker): void {
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    info.online = true;
+    info.status = 'ready';
+    this.runWhenReady();
+    this.emit('status', this.getStatusWorkers());
+  }
+
+  private setRunResult(worker: Worker, message: IWorkerMessage): void {
+    const reports = message.data as IProjectExecutionIteration[];
+    this.executed = this.executed.concat(reports);
+    worker.destroy();
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    info.status = 'finished';
+    this.emit('status', this.getStatusWorkers());
+  }
+
+  private runWhenReady(): void {
+    const waiting = this.workers.some(i => !i.online);
+    if (waiting) {
+      return;
+    }
+    this.startTime = Date.now();
+    this.workers.forEach((info) => {
+      const opts: IProjectParallelWorkerOptions = { ...this.options, project: this.project.toJSON() };
+      opts.iterations = info.iterations;
+      info.status = 'running';
+      info.worker.send({
+        cmd: 'run',
+        data: opts,
+      });
+    });
+  }
+
+  private async finishWhenReady(): Promise<void> {
+    if (this.endTime) {
+      return;
+    }
+    const working = this.workers.some(i => !['finished', 'error'].includes(i.status));
+    if (working || !this.mainResolver) {
+      return;
+    }
+    this.endTime = Date.now();
+    const report = await this.createReport();
+    this.mainResolver(report);
+    cluster.off('exit', this._exitHandler);
+  }
+
+  private setRunError(worker: Worker, message: IWorkerMessage): void {
+    worker.destroy();
+    const info = this.workers.find(i => i.worker === worker);
+    if (!info) {
+      return;
+    }
+    info.status = 'error';
+    info.message = message.data as string;
+    this.emit('status', this.getStatusWorkers());
+  }
+}