@nestia/e2e 0.4.3 → 0.5.0-dev.20240617-2

package/src/ArrayUtil.ts

@@ -1,98 +1,98 @@
-/**
- * Utility functions for arrays.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace ArrayUtil {
-  export const asyncFilter =
-    <Input>(elements: readonly Input[]) =>
-    async (
-      pred: (
-        elem: Input,
-        index: number,
-        array: readonly Input[],
-      ) => Promise<boolean>,
-    ): Promise<Input[]> => {
-      const ret: Input[] = [];
-      await asyncForEach(elements)(async (elem, index, array) => {
-        const flag: boolean = await pred(elem, index, array);
-        if (flag === true) ret.push(elem);
-      });
-      return ret;
-    };
-
-  export const asyncForEach =
-    <Input>(elements: readonly Input[]) =>
-    async (
-      closure: (
-        elem: Input,
-        index: number,
-        array: readonly Input[],
-      ) => Promise<any>,
-    ): Promise<void> => {
-      await asyncRepeat(elements.length)((index) =>
-        closure(elements[index], index, elements),
-      );
-    };
-
-  export const asyncMap =
-    <Input>(elements: readonly Input[]) =>
-    async <Output>(
-      closure: (
-        elem: Input,
-        index: number,
-        array: readonly Input[],
-      ) => Promise<Output>,
-    ): Promise<Output[]> => {
-      const ret: Output[] = [];
-      await asyncForEach(elements)(async (elem, index, array) => {
-        const output: Output = await closure(elem, index, array);
-        ret.push(output);
-      });
-      return ret;
-    };
-
-  export const asyncRepeat =
-    (count: number) =>
-    async <T>(closure: (index: number) => Promise<T>): Promise<T[]> => {
-      const indexes: number[] = new Array(count)
-        .fill(1)
-        .map((_, index) => index);
-
-      const output: T[] = [];
-      for (const index of indexes) output.push(await closure(index));
-
-      return output;
-    };
-
-  export const has =
-    <T>(elements: readonly T[]) =>
-    (pred: (elem: T) => boolean): boolean =>
-      elements.find(pred) !== undefined;
-
-  export const repeat =
-    (count: number) =>
-    <T>(closure: (index: number) => T): T[] =>
-      new Array(count).fill("").map((_, index) => closure(index));
-
-  export const flat = <T>(matrix: T[][]): T[] => ([] as T[]).concat(...matrix);
-
-  export const subsets = <T>(array: T[]): T[][] => {
-    const check: boolean[] = new Array(array.length).fill(false);
-    const output: T[][] = [];
-
-    const dfs = (depth: number): void => {
-      if (depth === check.length)
-        output.push(array.filter((_v, idx) => check[idx]));
-      else {
-        check[depth] = true;
-        dfs(depth + 1);
-
-        check[depth] = false;
-        dfs(depth + 1);
-      }
-    };
-    dfs(0);
-    return output;
-  };
-}
+/**
+ * Utility functions for arrays.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace ArrayUtil {
+  export const asyncFilter =
+    <Input>(elements: readonly Input[]) =>
+    async (
+      pred: (
+        elem: Input,
+        index: number,
+        array: readonly Input[],
+      ) => Promise<boolean>,
+    ): Promise<Input[]> => {
+      const ret: Input[] = [];
+      await asyncForEach(elements)(async (elem, index, array) => {
+        const flag: boolean = await pred(elem, index, array);
+        if (flag === true) ret.push(elem);
+      });
+      return ret;
+    };
+
+  export const asyncForEach =
+    <Input>(elements: readonly Input[]) =>
+    async (
+      closure: (
+        elem: Input,
+        index: number,
+        array: readonly Input[],
+      ) => Promise<any>,
+    ): Promise<void> => {
+      await asyncRepeat(elements.length)((index) =>
+        closure(elements[index], index, elements),
+      );
+    };
+
+  export const asyncMap =
+    <Input>(elements: readonly Input[]) =>
+    async <Output>(
+      closure: (
+        elem: Input,
+        index: number,
+        array: readonly Input[],
+      ) => Promise<Output>,
+    ): Promise<Output[]> => {
+      const ret: Output[] = [];
+      await asyncForEach(elements)(async (elem, index, array) => {
+        const output: Output = await closure(elem, index, array);
+        ret.push(output);
+      });
+      return ret;
+    };
+
+  export const asyncRepeat =
+    (count: number) =>
+    async <T>(closure: (index: number) => Promise<T>): Promise<T[]> => {
+      const indexes: number[] = new Array(count)
+        .fill(1)
+        .map((_, index) => index);
+
+      const output: T[] = [];
+      for (const index of indexes) output.push(await closure(index));
+
+      return output;
+    };
+
+  export const has =
+    <T>(elements: readonly T[]) =>
+    (pred: (elem: T) => boolean): boolean =>
+      elements.find(pred) !== undefined;
+
+  export const repeat =
+    (count: number) =>
+    <T>(closure: (index: number) => T): T[] =>
+      new Array(count).fill("").map((_, index) => closure(index));
+
+  export const flat = <T>(matrix: T[][]): T[] => ([] as T[]).concat(...matrix);
+
+  export const subsets = <T>(array: T[]): T[][] => {
+    const check: boolean[] = new Array(array.length).fill(false);
+    const output: T[][] = [];
+
+    const dfs = (depth: number): void => {
+      if (depth === check.length)
+        output.push(array.filter((_v, idx) => check[idx]));
+      else {
+        check[depth] = true;
+        dfs(depth + 1);
+
+        check[depth] = false;
+        dfs(depth + 1);
+      }
+    };
+    dfs(0);
+    return output;
+  };
+}

package/src/DynamicBenchmarker.ts

@@ -0,0 +1,328 @@
+import { IConnection } from "@nestia/fetcher";
+import fs from "fs";
+import { Driver, WorkerConnector, WorkerServer } from "tgrid";
+import { HashMap, hash } from "tstl";
+
+import { IBenchmarkEvent } from "./structures/IBenchmarkEvent";
+import { IBenchmarkMaster } from "./structures/IBenchmarkMaster";
+import { IBenchmarkServant } from "./structures/IBenchmarkServant";
+
+export namespace DynamicBenchmarker {
+  /**
+   * Properties of the master program.
+   */
+  export interface IMasterProps {
+    /**
+     * Total count of the requests.
+     */
+    count: number;
+
+    /**
+     * Number of threads.
+     *
+     * The number of threads to be executed as parallel servant.
+     */
+    threads: number;
+
+    /**
+     * Number of simultaneous requests.
+     *
+     * The number of requests to be executed simultaneously.
+     *
+     * This property value would be divided by the {@link threads} in the servants.
+     */
+    simultaneous: number;
+
+    /**
+     * Path of the servant program.
+     *
+     * The path of the servant program executing the
+     * {@link DynamicBenchmarker.servant} function.
+     */
+    servant: string;
+
+    /**
+     * Filter function.
+     *
+     * The filter function to determine whether to execute the function in
+     * the servant or not.
+     *
+     * @param name Function name
+     * @returns Whether to execute the function or not.
+     */
+    filter?: (name: string) => boolean;
+
+    /**
+     * Progress callback function.
+     *
+     * @param complete The number of completed requests.
+     */
+    progress?: (complete: number) => void;
+
+    /**
+     * Standard I/O option.
+     *
+     * The standard I/O option for the servant programs.
+     */
+    stdio?: undefined | "overlapped" | "pipe" | "ignore" | "inherit";
+  }
+
+  /**
+   * Properties of the servant progrma.
+   */
+  export interface IServantProps<Parameters extends any[]> {
+    /**
+     * Default connection.
+     *
+     * Default connection to be used in the servant.
+     */
+    connection: IConnection;
+
+    /**
+     * Location of the benchmark functions.
+     */
+    location: string;
+
+    /**
+     * Prefix of the benchmark functions.
+     *
+     * Every prefixed function will be executed in the servant.
+     *
+     * In other words, if a function name doesn't start with the prefix,
+     * then it would never be executed.
+     */
+    prefix: string;
+
+    /**
+     * Get parameters of a function.
+     *
+     * When composing the parameters, never forget to copy the
+     * {@link IConnection.logger} property of default connection to the
+     * returning parameters.
+     *
+     * @param name Function name
+     * @param connection Default connection instance
+     */
+    parameters: (name: string, connection: IConnection) => Parameters;
+  }
+  export interface IReport {
+    time: number;
+    statistics: IReport.IStatistics;
+    endpoints: Array<IReport.IEndpoint & IReport.IStatistics>;
+  }
+  export namespace IReport {
+    export interface IEndpoint {
+      method: string;
+      path: string;
+    }
+    export interface IStatistics {
+      count: number;
+      success: number;
+      mean: number | null;
+      stdev: number | null;
+      minimum: number | null;
+      maximum: number | null;
+    }
+  }
+
+  export const master = async (props: IMasterProps): Promise<IReport> => {
+    const completes: number[] = new Array(props.threads).fill(0);
+    const servants: WorkerConnector<
+      null,
+      IBenchmarkMaster,
+      IBenchmarkServant
+    >[] = await Promise.all(
+      new Array(props.threads).fill(null).map(async (i) => {
+        const connector: WorkerConnector<
+          null,
+          IBenchmarkMaster,
+          IBenchmarkServant
+        > = new WorkerConnector(
+          null,
+          {
+            filter: props.filter ?? (() => true),
+            progress: (current) => {
+              completes[i] = current;
+              if (props.progress)
+                props.progress(completes.reduce((a, b) => a + b, 0));
+            },
+          },
+          "process",
+        );
+        await connector.connect(props.servant, { stdio: props.stdio });
+        return connector;
+      }),
+    );
+    const started_at: Date = new Date();
+    const events: IBenchmarkEvent[] = (
+      await Promise.all(
+        servants.map((connector) =>
+          connector.getDriver().execute({
+            count: Math.ceil(props.count / props.threads),
+            simultaneous: Math.ceil(props.simultaneous / props.threads),
+          }),
+        ),
+      )
+    ).flat();
+    const time: number = Date.now() - started_at.getTime();
+    await Promise.all(servants.map((connector) => connector.close()));
+    if (props.progress) props.progress(props.count);
+
+    const endpoints: HashMap<IReport.IEndpoint, IBenchmarkEvent[]> =
+      new HashMap(
+        (key) => hash(key.method, key.path),
+        (x, y) => x.method === y.method && x.path === y.path,
+      );
+    for (const e of events)
+      endpoints
+        .take(
+          {
+            method: e.metadata.method,
+            path: e.metadata.template ?? e.metadata.path,
+          },
+          () => [],
+        )
+        .push(e);
+    return {
+      time,
+      statistics: statistics(events),
+      endpoints: [...endpoints].map((it) => ({
+        ...statistics(it.second),
+        ...it.first,
+      })),
+    };
+  };
+
+  export const servant = async <Parameters extends any[]>(
+    props: IServantProps<Parameters>,
+  ): Promise<WorkerServer<null, IBenchmarkServant, IBenchmarkMaster>> => {
+    const server: WorkerServer<null, IBenchmarkServant, IBenchmarkMaster> =
+      new WorkerServer();
+    await server.open({
+      execute: execute({
+        driver: server.getDriver(),
+        props,
+      }),
+    });
+    return server;
+  };
+
+  const execute =
+    <Parameters extends any[]>(ctx: {
+      driver: Driver<IBenchmarkMaster>;
+      props: IServantProps<Parameters>;
+    }) =>
+    async (mass: {
+      count: number;
+      simultaneous: number;
+    }): Promise<IBenchmarkEvent[]> => {
+      const functions: IFunction<Parameters>[] = [];
+      await iterate({
+        collection: functions,
+        driver: ctx.driver,
+        props: ctx.props,
+      })(ctx.props.location);
+      const events: IBenchmarkEvent[] = [];
+
+      ctx.props.connection.logger = async (e): Promise<void> => {
+        events.push({
+          metadata: e.route,
+          status: e.status,
+          started_at: e.started_at.toISOString(),
+          repond_at: e.respond_at?.toISOString() ?? null,
+          completed_at: e.completed_at.toISOString(),
+        });
+      };
+
+      await Promise.all(
+        new Array(mass.simultaneous).fill(null).map(async () => {
+          while (events.length < mass.count) {
+            const prev: number = events.length;
+            const func: IFunction<Parameters> =
+              functions[Math.floor(Math.random() * functions.length)];
+            try {
+              await func.value(
+                ...ctx.props.parameters(func.key, ctx.props.connection),
+              );
+              const current: number = events.length;
+              if (current !== prev)
+                ctx.driver.progress(current).catch(() => {});
+            } catch {}
+          }
+        }),
+      );
+      await ctx.driver.progress(events.length);
+      return events;
+    };
+
+  const statistics = (events: IBenchmarkEvent[]): IReport.IStatistics => {
+    const successes: IBenchmarkEvent[] = events.filter(
+      (event) => event.status === 200 || event.status === 201,
+    );
+    return {
+      count: events.length,
+      success: successes.length,
+      ...average(events),
+    };
+  };
+
+  const average = (
+    events: IBenchmarkEvent[],
+  ): Pick<IReport.IStatistics, "mean" | "stdev" | "minimum" | "maximum"> => {
+    if (events.length === 0)
+      return {
+        mean: null,
+        stdev: null,
+        minimum: null,
+        maximum: null,
+      };
+    let mean: number = 0;
+    let stdev: number = 0;
+    let minimum: number = Number.MAX_SAFE_INTEGER;
+    let maximum: number = Number.MIN_SAFE_INTEGER;
+    for (const event of events) {
+      const elapsed: number =
+        new Date(event.completed_at).getTime() -
+        new Date(event.started_at).getTime();
+      mean += elapsed;
+      stdev += elapsed * elapsed;
+      minimum = Math.min(minimum, elapsed);
+      maximum = Math.max(maximum, elapsed);
+    }
+    mean /= events.length;
+    stdev = Math.sqrt(stdev / events.length - mean * mean);
+    return { mean, stdev, minimum, maximum };
+  };
+}
+
+interface IFunction<Parameters extends any[]> {
+  key: string;
+  value: (...args: Parameters) => Promise<void>;
+}
+
+const iterate =
+  <Parameters extends any[]>(ctx: {
+    collection: IFunction<Parameters>[];
+    driver: Driver<IBenchmarkMaster>;
+    props: DynamicBenchmarker.IServantProps<Parameters>;
+  }) =>
+  async (path: string): Promise<void> => {
+    const directory: string[] = await fs.promises.readdir(path);
+    for (const file of directory) {
+      const location: string = `${path}/${file}`;
+      const stat: fs.Stats = await fs.promises.stat(location);
+      if (stat.isDirectory() === true) await iterate(ctx)(location);
+      else if (file.endsWith(".js") === true) {
+        const modulo = await import(location);
+        for (const [key, value] of Object.entries(modulo)) {
+          if (typeof value !== "function") continue;
+          else if (key.startsWith(ctx.props.prefix) === false) continue;
+          else if ((await ctx.driver.filter(key)) === false) continue;
+          ctx.collection.push({
+            key,
+            value: value as (...args: Parameters) => Promise<any>,
+          });
+        }
+      }
+    }
+  };