@nsshunt/stsappframework 3.1.161 → 3.1.163

package/src/testertesting/app.ts

@@ -1,8 +1,8 @@
 /* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
 import cluster from 'cluster';
-import { Worker, MessageChannel } from 'worker_threads';
+import { Worker } from 'worker_threads';
 
-import { IWorkerFactory, IWorkerOptions, IPrimaryWorker, IRunnerOptions } from './stsTestWorkerDefinitions'
+import { IWorkerFactory, IWorkerOptions, IPrimaryWorker, IRunnerOptions } from './commonTypes'
 
 import { WorkerPrimaryTestRunner01 } from './workerPrimaryTestRunner01'
 import { STSWorkerManager } from './workerManager';
@@ -15,11 +15,14 @@ import { IContextBase, AgentInstrumentController, IPublishInstrumentControllerOp
     InstrumentDefinitions, InstrumentLogOptions, InstrumentGaugeOptions, PublishTransportRESTServer, 
     TransportType, IPublishTransportRESTServerOptions } from '@nsshunt/stsobservability'
 
-import { ModelDelimeter, type ISTSLogger, defaultLogger } from '@nsshunt/stsutils'
+import { ModelDelimeter, type ISTSLogger, defaultLogger, JSONObject } from '@nsshunt/stsutils'
 
 import { v4 as uuidv4 } from 'uuid';
 
 import { goptions } from '@nsshunt/stsconfig'
+import { JsonWebTokenError } from 'jsonwebtoken';
+
+import { IRunnerOptionsEx } from './testCase01'
 
 declare  interface IAsyncRunnerContext extends IContextBase {
     id: string;
@@ -200,24 +203,61 @@ if (cluster.isPrimary) {
         }
     }
 
-    const xx = async () => {
+    const PerformTesting = async () => {
         const wm = new STSWorkerManager(null, { 
             workerFactory,
             publishInstrumentController: agentInstrumentController
         });
         const worker = await wm.AddWorker();
 
-        const runnerOptions: IRunnerOptions = {
-            iterations: 100000,
-            sleepDuration: 250,
+        const runnerOptions: IRunnerOptionsEx = {
+            testType: 'TestCase01',
+            executionProfile: {
+                iterations: 50,
+                delayBetweenIterations: 250
+            },
+            sleepDuration: 0,
             messageMod: 1,
             logMessageMod: 1
-        } as IRunnerOptions;
+        };
+
+        const runner1 = worker.AddRunner(runnerOptions);
+        runner1.on('Completed', () => {
+            console.log(chalk.rgb(10, 100, 250)(`Completed event handler for runner 1`));
+        });
 
-        const runner = wm.AddRunnerToWorker(worker, runnerOptions);
+        worker.StartRunner(runner1);
+
+        const runner2 = wm.AddRunnerToWorker(worker, runnerOptions);
+        runner2.Start();
+        runner2.on('Completed', () => {
+            console.log(chalk.rgb(100, 10, 250)(`Completed event handler for runner 2`));
+        });
 
+        wm.AddRunnerToWorker(worker, runnerOptions).on('Completed', () => {
+            console.log(chalk.rgb(250, 100, 25)(`Completed event handler for runner 3`));
+        }).Start();
+
+        setTimeout(() => {
+            runner2.Pause();
+            setTimeout(() => {
+                runner2.Resume();
+                setTimeout(() => {
+                    runner2.Reset();
+                    setTimeout(() => {
+                        runner2.Start();
+                        setTimeout(() => {
+                            runner2.Stop();
+                            setTimeout(() => {
+                                runner2.Terminate();
+                            }, 2000);
+                        }, 2000);
+                    }, 100);
+                }, 2000);
+            }, 2000);
+        }, 2000);
     };
-    xx();
+    PerformTesting();
     
 
     /*

package/src/testertesting/commonTypes.ts

@@ -1,3 +1,7 @@
+import { Worker, MessagePort } from 'worker_threads';
+
+import { PublishInstrumentController } from '@nsshunt/stsobservability'
+
 import { IContextBase } from '@nsshunt/stsobservability'
 
 export const URI_BASE_VUEUTILS: string = '/';
@@ -26,6 +30,13 @@ export enum eIWMessageCommands {
 	MessagePortResponse = '__STS__MessagePortResponse',
 	AddAsyncRunner = '__STS__AddAsyncRunner',
 	StopAllAsyncRunners = '__STS__StopAllAsyncRunners',
+	StartRunner = '__STS__StartRunner',
+	StopRunner = '__STS__StopRunner',
+	PauseRunner = '__STS__PauseRunner',
+	ResumeRunner = '__STS__ResumeRunner',
+	ResetRunner = '__STS__ResetRunner',
+	ExecuteRunner = '__STS__ExecuteRunner',
+	Completed = '__STS__Completed'
 }
 
 /**
@@ -48,3 +59,164 @@ export interface IObservabilitySubscriberManagerOptions {
     instrumentManagerPort: string
     instrumentManagerAPIRoot: string
 }
+
+export interface ISTSAgentWorkerMessagePort extends IIWMessagePayloadContentBase {
+    port: MessagePort
+    options: IWorkerOptions
+}
+
+export enum IRunnerState {
+	created = 'created',
+	running = 'running',
+	stopped = 'stopped',
+	paused = 'paused',
+	error = 'error',
+}
+
+export interface IRunnerTelemetry {
+	requestCount: number // requestCount
+	errorCount: number
+	retryCount: number
+	authenticationCount: number
+	authenticationErrorCount: number
+	authenticationRetryCount: number
+	velocity: number
+	coreCount: number
+	timer: number
+	duration: number
+	latency: number
+	activeRequestCount: number
+	message: string[]
+	childCount: number
+	rx: number
+	tx: number
+}
+
+export interface IRunner {
+	get id(): number
+	get asyncRunnerContext(): IAsyncRunnerContext
+	get options(): IRunnerOptions
+	set options(options: IRunnerOptions)
+	get instrumentData(): IRunnerTelemetry
+	set instrumentData(newRunnerTelemetry: IRunnerTelemetry)
+}
+
+export interface IRunnerEx extends IRunner {
+    publishInstrumentController: PublishInstrumentController
+    Start: () => Promise<boolean>
+    Pause: () => Promise<boolean>
+    Resume: () => Promise<boolean>
+	Stop: () => Promise<boolean>
+	Terminate: () => Promise<boolean>
+	Reset: () => Promise<boolean>
+	Execute: (iteration: number) => Promise<boolean> // Execute a single iteration for this test
+	on: (eventName: string, cb: () => void) => IRunnerEx
+}
+
+export interface IRunnerInstance {
+	Execute: (iteration: number) => Promise<boolean> // Execute a single iteration for this test
+}
+
+export enum IWorkerState {
+	starting = 'starting',
+	started = 'started',
+	stopped = 'stopped'
+}
+
+ 
+export interface IWorkerOptions {
+    hostName: string
+    agentId: string
+    userAgent: string
+}
+
+export type Runners = Record<string, IRunner>
+
+export interface IWorker {
+	id: number
+	state: IWorkerState
+    primaryThreadWorkerOptions: IWorkerOptions
+	workerThreadWorkerOptions: IWorkerOptions
+	runners?: Runners // Will be created by utility helper
+}
+
+export type Workers = Record<string, IWorker>
+
+export interface IPrimaryWorker {
+    ProcessMessageFromWorker(workerPort: MessagePort, publishMessagePayload: IIWMessagePayload): Promise<void>
+}
+
+export interface IExecutionProfile {
+    iterations: number
+	delayBetweenIterations: number
+}
+
+export interface IRunnerOptions {
+	testType: string
+	executionProfile: IExecutionProfile
+}
+
+export interface IRunnerEvent {
+	eventName: string
+	cb: () => void
+}
+
+export interface IWorkerEx extends IWorker {
+	worker: Worker
+    primaryWorker: IPrimaryWorker
+	runnersEx: Record<string, IRunnerEx>
+	runnersEvents: Record<string, IRunnerEvent[]>
+	GetRunner(id: string): IRunnerEx | null
+	AddRunner: (runnerOptions: IRunnerOptions) => IRunnerEx
+	StartRunner: (runner: IRunnerEx) => Promise<boolean>
+	StopRunner: (runner: IRunnerEx) => Promise<boolean>
+	PauseRunner: (runner: IRunnerEx) => Promise<boolean>
+	ResumeRunner: (runner: IRunnerEx) => Promise<boolean>
+	Stop: () => Promise<boolean>
+}
+
+export interface ISTSTestWorkerOptions {
+    messageMod: number
+    iterations: number
+}
+
+export interface ITelemetryStore {
+	workers: Workers
+}
+
+export interface ITestRunnerTelemetryPayload extends IIWMessagePayloadContentBase {
+	runner: IRunner
+}
+
+export interface IWorkerFactory {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    createPrimaryThreadWorker: (app: any, options: IWorkerOptions) => IPrimaryWorker
+	createWorkerThreadWorker: () => Worker // | wt.Worker
+    get workerThreadWorkerOptions(): IWorkerOptions // These options will be passed as a message to the thread worker once setup
+    get primaryThreadWorkerOptions(): IWorkerOptions // These options will be passed as a message to the thread worker once setup
+}
+
+export interface IWorkerManagerOptions {
+    workerFactory: IWorkerFactory
+	publishInstrumentController: PublishInstrumentController
+}
+
+export const PublishMessageCommandsTestRunner = {
+    ...eIWMessageCommands,
+    GetAccessToken: '__GetAccessToken',
+    GetAccessTokenResponse: '__GetAccessTokenResponse',
+    GetDataFromPrimary: '__GetDataFromPrimary',
+    ExecuteRefreshToken: '__ExecuteRefreshToken',
+    ExecuteRefreshTokenResponse: '__ExecuteRefreshTokenResponse'
+} as const
+
+export type PublishMessageCommandsTestRunner = typeof PublishMessageCommandsTestRunner[keyof typeof PublishMessageCommandsTestRunner];
+
+export interface IIWMessagePayloadContentBase {
+    messageId?: string;
+}
+
+export interface IIWMessagePayload {
+    command: IIWMessageCommand;
+    payload: IIWMessagePayloadContentBase;
+}

package/src/testertesting/telemetryProcessor.ts

@@ -0,0 +1,128 @@
+import { PublishInstrumentController, InstrumentGaugeTelemetry, Gauge } from "@nsshunt/stsobservability";
+import { IRunnerTelemetry } from "./commonTypes";
+
+export class TelemetryProcessor {
+    ProcessTelemetry = (publishInstrumentController: PublishInstrumentController, telemetry: IRunnerTelemetry): boolean => {
+        let update = false;
+
+        if (telemetry.message) {
+            telemetry.message.forEach((message) => {
+                publishInstrumentController.LogEx(message);
+            });
+            update = true;
+        }
+
+        if (telemetry.requestCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
+                val: telemetry.requestCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.errorCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.ERROR_COUNT_GAUGE, {
+                val: telemetry.errorCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.retryCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.RETRY_COUNT_GAUGE, {
+                val: telemetry.retryCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.authenticationCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_COUNT_GAUGE, {
+                val: telemetry.authenticationCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.authenticationErrorCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
+                val: telemetry.authenticationCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.authenticationRetryCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
+                val: telemetry.authenticationCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.coreCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
+                val: telemetry.coreCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.timer) {
+            publishInstrumentController.UpdateInstrument(Gauge.TIMER_GAUGE, {
+                val: telemetry.timer
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.activeRequestCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
+                val: telemetry.activeRequestCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.velocity) {
+            publishInstrumentController.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
+                Inc: telemetry.velocity
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.duration) {
+            publishInstrumentController.UpdateInstrument(Gauge.DURATION_GAUGE, {
+                val: telemetry.duration
+            } as InstrumentGaugeTelemetry);
+            publishInstrumentController.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
+                val: telemetry.duration
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.latency) {
+            publishInstrumentController.UpdateInstrument(Gauge.LATENCY_GAUGE, {
+                val: telemetry.latency
+            } as InstrumentGaugeTelemetry);
+            publishInstrumentController.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
+                val: telemetry.latency
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.childCount) {
+            publishInstrumentController.UpdateInstrument(Gauge.CHILD_COUNT, {
+                val: telemetry.childCount
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.rx) {
+            publishInstrumentController.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
+                Inc: telemetry.rx
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        if (telemetry.tx) {
+            publishInstrumentController.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
+                Inc: telemetry.tx
+            } as InstrumentGaugeTelemetry);
+            update = true;
+        }
+
+        return update;
+    }
+}

package/src/testertesting/testCase01.ts

@@ -0,0 +1,107 @@
+import { IRunnerInstance, IRunnerOptions, IRunner } from './commonTypes'
+
+import chalk from 'chalk';
+
+import { WorkerInstance } from './workerInstance'
+
+import { Sleep } from '@nsshunt/stsutils'
+
+declare interface LogMessageData {
+    indent: number
+    adder: number
+}
+
+declare type LogMessageDataSet = Record<string, LogMessageData>;
+
+export interface IRunnerOptionsEx extends IRunnerOptions {
+    sleepDuration: number
+    messageMod: number
+    logMessageMod: number
+}
+
+export class TestCase01 implements IRunnerInstance {
+    #runner: IRunner
+    #workerInstance: WorkerInstance;
+    #logMessageDataSet: LogMessageDataSet = { };
+
+    constructor(workerInstance: WorkerInstance, runner: IRunner) {
+        this.#workerInstance = workerInstance;
+        this.#runner = runner;
+    }
+
+    #GenLogMessage = (runner: IRunner, iteration: number) => {
+        if (!this.#logMessageDataSet[runner.id]) {
+            this.#logMessageDataSet[runner.id] = {
+                adder: 1,
+                indent: 0
+            }
+        }
+        const logMessageData = this.#logMessageDataSet[runner.id];
+
+        let message = `${' '.repeat(logMessageData.indent)}>> Hello World << ${iteration}`;
+        const colorCode = runner.asyncRunnerContext.asyncRunnerId % 4;
+        switch (colorCode) {
+        case 0:
+            message = chalk.green(`${message}`);
+            break;
+        case 1:
+            message = chalk.yellow(`${message}`);
+            break;
+        case 2:
+            message = chalk.magenta(`${message}`);
+            break;
+        case 3:
+            message = chalk.white(`${message}`);
+            break;
+        }
+
+        console.log(message);
+        runner.instrumentData.message.push(message);
+        logMessageData.indent += logMessageData.adder;
+        if (logMessageData.indent > 20) {
+            logMessageData.adder = -1;
+        } else if (logMessageData.indent === 0) {
+            logMessageData.adder = 1;
+        }
+    }
+
+    Execute = async (iteration: number): Promise<boolean> => {
+        //console.log(chalk.magenta(`Execute! [${iteration}]`));
+        //console.log(chalk.magenta(JSON.stringify(this.#runner)));
+
+        this.#runner.instrumentData.coreCount = 1;
+
+        const options = this.#runner.options as IRunnerOptionsEx;
+
+        await Sleep(options.sleepDuration);
+
+        //this.#runner.instrumentData.timer++;
+        this.#runner.instrumentData.requestCount++;
+        this.#runner.instrumentData.velocity = options.messageMod;
+
+        //runner.instrumentData.tx += 256;
+        //runner.instrumentData.rx += 6500;
+
+        if (this.#runner.instrumentData.requestCount % options.logMessageMod === 0) {
+            this.#GenLogMessage(this.#runner, iteration);
+        }
+
+        if (this.#runner.instrumentData.requestCount % options.messageMod === 0) {
+            this.#workerInstance.PostTelemetry(this.#runner);
+            this.#runner.instrumentData.message = [ ];
+            this.#runner.instrumentData.tx = 0;
+            this.#runner.instrumentData.rx = 0;
+        }
+        if (this.#runner.instrumentData.requestCount % 1000 === 0) {
+            const message = `Worker: [${this.#runner.asyncRunnerContext.threadId}], Runner: [${this.#runner.asyncRunnerContext.asyncRunnerId}] has completed: [${this.#runner.instrumentData.requestCount}] iterations of max: [${options.executionProfile.iterations}]`;
+            console.log(message);
+            this.#runner.instrumentData.message = [message]
+            this.#workerInstance.PostTelemetry(this.#runner);
+            this.#runner.instrumentData.message = [ ];
+            this.#runner.instrumentData.tx = 0;
+            this.#runner.instrumentData.rx = 0;
+        }
+
+        return true;
+    }
+}