@nsshunt/stsappframework 3.1.160 → 3.1.161

package/src/testertesting/workerManager.ts

@@ -0,0 +1,478 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+//import MyWorker from './sts-worker?worker' // https://vitejs.dev/guide/features.html#web-workers
+import { type IAsyncRunnerContext, IIWMessagePayload, IIWMessagePayloadContentBase, 
+    type IIWMessageCommand, eIWMessageCommands } from './commonTypes'
+    
+import { Gauge, InstrumentGaugeTelemetry } from '@nsshunt/stsobservability'
+
+import { ModelDelimeter } from '@nsshunt/stsutils'
+
+import type { ISTSAgentWorkerMessagePort, IWorkerEx, IRunner, IRunnerEx,
+    ITestRunnerTelemetryPayload, IRunnerOptions, IRunnerTelemetry,
+    IWorkerManagerOptions, IWorkerFactory } from './stsTestWorkerDefinitions'
+
+import { IWorkerState, IRunnerState } from './stsTestWorkerDefinitions'
+import { Sleep } from '@nsshunt/stsutils';
+
+import { AgentInstrumentController, PublishInstrumentController } from '@nsshunt/stsobservability'
+
+import chalk from 'chalk';
+chalk.level = 3;
+
+export class STSWorkerManager {
+    //#agentSession: string = null;
+    #workersEx: Record<string, IWorkerEx> = { };
+    #runner = 0;
+    #workerId = 0;
+    #options: IWorkerManagerOptions;
+    #STSInstrumentController: PublishInstrumentController
+     
+    #app: any
+
+     
+    constructor(app: any, options?: IWorkerManagerOptions) {
+        this.#app = app;
+        if (options) {
+            this.#options = options;
+        } else {
+            this.#options = { } as IWorkerManagerOptions;
+        }
+
+        this.#STSInstrumentController = this.#options.publishInstrumentController;
+    }
+    
+    #debug = (message: string) => {
+        console.log(chalk.cyan(`pid: [${process.pid}] STSWorkerManager::${message}`));
+    }
+
+    get WorkersEx(): Record<string, IWorkerEx> {
+        return this.#workersEx;
+    }
+
+    AddWorker = async (useWorkerFactory?: IWorkerFactory): Promise<IWorkerEx> => {
+        let workerFactory: IWorkerFactory;
+        if (useWorkerFactory) {
+            // Use the supplied workFactory
+            workerFactory = useWorkerFactory;
+        } else {
+            // Use the default workFactory
+            workerFactory = this.#options.workerFactory
+        }
+        const stsWorkerEx: IWorkerEx = {
+            id: this.#workerId++, // uuidv4()
+            worker: workerFactory.createWorkerThreadWorker(),
+            primaryWorker: workerFactory.createPrimaryThreadWorker(this.#app, workerFactory.primaryThreadWorkerOptions),
+            state: IWorkerState.starting,
+            workerThreadWorkerOptions: workerFactory.workerThreadWorkerOptions,
+            primaryThreadWorkerOptions: workerFactory.primaryThreadWorkerOptions,
+            runnersEx: { } as Record<string, IRunnerEx>,
+            AddRunner: (runnerOptions: IRunnerOptions): IRunnerEx => this.AddRunnerToWorker(stsWorkerEx, runnerOptions),
+            StopRunner: (runner: IRunnerEx): Promise<boolean> => this.#StopRunner(stsWorkerEx, runner),
+            Stop: async (): Promise<boolean> => this.#StopWorker(stsWorkerEx)
+        }
+        this.#STSInstrumentController.LogEx(chalk.yellow(`pid: [${process.pid}] Creating new worker: [${stsWorkerEx.id}]`));
+        this.#debug(`Adding worker: [${stsWorkerEx.id}]`);
+
+        /*
+        stsWorkerEx.worker.onmessage = function(data: MessageEvent) {
+            console.log(data.data);
+        }
+
+        stsWorkerEx.worker.onerror = function(error) {
+            console.log(error);
+        };
+        */
+
+        const { 
+            port1, // process message port
+            port2  // collector message port
+        } = new MessageChannel();
+
+        const workerPort = port1;
+        
+        this.#debug(`AddWorker::workerThreadWorkerOptions: [${JSON.stringify(stsWorkerEx.workerThreadWorkerOptions)}]`);
+
+        this.#PostMessageToWorker(stsWorkerEx, eIWMessageCommands.MessagePort, {
+            port: port2,
+            //applicationStoreState: stateCopy,
+            options: { ...stsWorkerEx.workerThreadWorkerOptions }
+        } as ISTSAgentWorkerMessagePort, port2);
+    
+        // Process messages received back from the worker
+        //workerPort.onmessage = async (data: MessageEvent) => {
+        workerPort.on('message', (data: any) => {
+            // const publishMessagePayload: IIWMessagePayload = data.data as IIWMessagePayload; browser version
+            const publishMessagePayload: IIWMessagePayload = data as IIWMessagePayload;
+            switch (publishMessagePayload.command) {
+            case eIWMessageCommands.MessagePortResponse : 
+                this.#debug(`AddWorker::eIWMessageCommands.MessagePortResponse`);
+                stsWorkerEx.state = IWorkerState.started;
+                break;
+            case eIWMessageCommands.InstrumentTelemetry :
+                this.#debug(`AddWorker::eIWMessageCommands.InstrumentTelemetry`);
+                this.#ProcessTelemetry(stsWorkerEx, publishMessagePayload.payload as ITestRunnerTelemetryPayload);
+                break;
+            default :
+                this.#debug(`AddWorker::default`);
+                stsWorkerEx.primaryWorker.ProcessMessageFromWorker(workerPort, publishMessagePayload);
+            }
+        });
+
+        this.#workersEx[stsWorkerEx.id] = stsWorkerEx;
+
+        this.#debug(`Added worker: [${stsWorkerEx.id}]`);
+
+        return stsWorkerEx;
+    }
+
+    AddRunnerToWorker = (stsWorkerEx: IWorkerEx, runnerOptions: IRunnerOptions): IRunnerEx => {
+        const runnerEx: IRunnerEx = this.#CreateAsyncRunner(stsWorkerEx, runnerOptions);
+        stsWorkerEx.runnersEx[runnerEx.id] = runnerEx;
+        this.#SetRunnerIntoWorker(stsWorkerEx, runnerEx);
+        runnerEx.publishInstrumentController.LogEx(chalk.green(`Added runner: [${runnerEx.id}] into worker: [${stsWorkerEx.id}]`));
+        return runnerEx;
+    }
+
+    #CreateRunnerCopy(runnerEx: IRunnerEx): IRunner {
+        return {
+            id: runnerEx.id,
+            asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
+            options: { ...runnerEx.options },
+            state: runnerEx.state,
+            instrumentData: { ...runnerEx.instrumentData }
+        } as IRunner
+    }
+
+    #SetRunnerIntoWorker = (workerEx: IWorkerEx, runnerEx: IRunnerEx): void => {
+        // Now that the worker is setup, send the options
+        //@@ wait until worker in running state
+        const payload: ITestRunnerTelemetryPayload = {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        }
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.AddAsyncRunner, payload);
+    }
+
+    #ProcessTelemetry = (workerEx: IWorkerEx, payloadContents: ITestRunnerTelemetryPayload): void => {
+        //const store = TelemetryStore();
+
+        const { runner } = payloadContents;
+
+        if (workerEx.runnersEx[runner.id]) {
+            const runnerEx: IRunnerEx = workerEx.runnersEx[runner.id];
+            let update = false;
+
+            // Copy telemetry
+            runnerEx.instrumentData = { ...runner.instrumentData };
+
+            this.#debug(JSON.stringify(runnerEx.instrumentData));
+
+            if (runner.instrumentData.message) {
+                runnerEx.instrumentData.message = [...runner.instrumentData.message];
+            } else {
+                runnerEx.instrumentData.message = [ ];
+            }
+
+            if (runner.instrumentData.message) {
+                runner.instrumentData.message.forEach((message) => {
+                    runnerEx.publishInstrumentController.LogEx(message);
+                });
+                update = true;
+            }
+
+            if (runner.instrumentData.requestCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
+                    val: runnerEx.instrumentData.requestCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.errorCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.ERROR_COUNT_GAUGE, {
+                    val: runnerEx.instrumentData.errorCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.retryCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.RETRY_COUNT_GAUGE, {
+                    val: runnerEx.instrumentData.retryCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.authenticationCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_COUNT_GAUGE, {
+                    val: runnerEx.instrumentData.authenticationCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.authenticationErrorCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
+                    val: runnerEx.instrumentData.authenticationCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.authenticationRetryCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
+                    val: runnerEx.instrumentData.authenticationCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.coreCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
+                    val: runnerEx.instrumentData.coreCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.timer) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.TIMER_GAUGE, {
+                    val: runnerEx.instrumentData.timer
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.activeRequestCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
+                    val: runnerEx.instrumentData.activeRequestCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.velocity) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
+                    Inc: runnerEx.instrumentData.velocity
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.duration) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.DURATION_GAUGE, {
+                    val: runnerEx.instrumentData.duration
+                } as InstrumentGaugeTelemetry);
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
+                    val: runnerEx.instrumentData.duration
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.latency) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.LATENCY_GAUGE, {
+                    val: runnerEx.instrumentData.latency
+                } as InstrumentGaugeTelemetry);
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
+                    val: runnerEx.instrumentData.latency
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.childCount) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.CHILD_COUNT, {
+                    val: runnerEx.instrumentData.childCount
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.rx) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
+                    Inc: runnerEx.instrumentData.rx
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (runner.instrumentData.tx) {
+                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
+                    Inc: runnerEx.instrumentData.tx
+                } as InstrumentGaugeTelemetry);
+                update = true;
+            }
+
+            if (update) {
+                //store.Update(workerEx, runnerEx);
+            }
+        }
+    }
+
+    #CreateAsyncRunner = (workerEx: IWorkerEx, runnerOptions: IRunnerOptions): IRunnerEx => {
+        //const applicationStore = ApplicationStore();
+        this.#runner++; // The runner number always increases
+        this.#STSInstrumentController.LogEx(chalk.yellow(`Creating new async runner: [${this.#runner}]`));
+        const asyncRunnerContext: IAsyncRunnerContext = {
+            nid: `\
+${workerEx.workerThreadWorkerOptions.hostName}${ModelDelimeter.COMPONENT_SEPERATOR}${workerEx.workerThreadWorkerOptions.agentId}-${workerEx.workerThreadWorkerOptions.userAgent}\
+${ModelDelimeter.NID_SEPERATOR}\
+worker${workerEx.id}\
+${ModelDelimeter.SEPERATOR}\
+${this.#runner}`,
+            id: this.#runner.toString(),
+            hostName: (workerEx.workerThreadWorkerOptions.hostName ? workerEx.workerThreadWorkerOptions.hostName : 'host'),
+            agentName: `${workerEx.workerThreadWorkerOptions.agentId}-${workerEx.workerThreadWorkerOptions.userAgent}`,
+            threadId: `worker${workerEx.id}`,
+            asyncRunnerId: this.#runner
+        }
+        const runnerEx: IRunnerEx = {
+            id: this.#runner,
+            publishInstrumentController: (this.#STSInstrumentController as AgentInstrumentController).AddPublishInstrumentController(asyncRunnerContext),
+            asyncRunnerContext: asyncRunnerContext,
+            state: IRunnerState.created,
+            options: runnerOptions,
+            instrumentData: {
+                requestCount: 0,
+                errorCount: 0,
+                retryCount: 0,
+                authenticationCount: 0,
+                authenticationErrorCount: 0,
+                authenticationRetryCount: 0,
+                velocity: 0,
+                coreCount: 0,
+                timer: 0,
+                duration: 0,
+                latency: 0,
+                activeRequestCount: 0,
+                message: [ ],
+                childCount: 0,
+                rx: 0,
+                tx: 0
+            } as IRunnerTelemetry,
+            Stop: async (): Promise<boolean> => this.#StopRunner(workerEx, runnerEx)
+        }
+        return runnerEx;
+    }
+
+     
+    #PostMessageToWorker = (workerEx: IWorkerEx, command: IIWMessageCommand, payload: IIWMessagePayloadContentBase | null, transferObject?: any) => {
+        if (transferObject) {
+            this.#debug(`#PostMessageToWorker with transfer object`);
+            workerEx.worker.postMessage({ command, payload }, [transferObject]);
+            this.#debug(`#PostMessageToWorker with transfer object - done...`);
+        } else {
+            this.#debug(`#PostMessageToWorker`);
+            workerEx.worker.postMessage({ command, payload });
+        }
+    }
+
+    #TerminateWorker = (workerEx: IWorkerEx) => {
+        if (workerEx.worker) {
+            //const store = TelemetryStore();
+            workerEx.worker.terminate();
+            this.#debug(`Terminated worker: [${workerEx.id}]`);
+            //store.RemoveWorker(workerEx);
+            delete this.#workersEx[workerEx.id];
+        } else {
+            // Some other runner has already removed the parent worker, do nothing
+            // console.log(`WORKER ALREADY NULL`);
+        }
+    }
+
+    #StopRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx | null = null): Promise<boolean> => {
+        // If runnerEx not provided, Remove the first runner in the collection
+        if (runnerEx === null) {
+            const ids: string[] = Object.keys(workerEx.runnersEx);
+            if (ids.length > 0) {
+                const id = ids[0];
+                runnerEx = workerEx.runnersEx[id];
+            }
+        }
+        if (runnerEx !== null) {
+            this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopAllAsyncRunners, {
+                runner: this.#CreateRunnerCopy(runnerEx)
+            } as ITestRunnerTelemetryPayload);
+
+            runnerEx.publishInstrumentController.LogEx(`Terminating runner: [${runnerEx.id}]`);
+            
+            const promArray: Promise<boolean>[] = [ ];
+
+            promArray.push((async (): Promise<boolean> => {
+                await Sleep(100);
+                return runnerEx.publishInstrumentController.EndPublish() as Promise<boolean>
+            })());
+
+            //const store = TelemetryStore();
+            //store.RemoveRunner(workerEx, runnerEx);
+
+            delete workerEx.runnersEx[runnerEx.id];
+
+            const retVal = await Promise.all(promArray);
+            console.log(`Removed instrument workers: [${retVal}]`);
+        }
+        return true;
+    }
+
+    #StopWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
+        try {
+            if (workerEx.state !== IWorkerState.stopped) {
+                this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopAllAsyncRunners, null);
+    
+                //@@ Now wait until we get an ack back from the worker
+                // This is because we may be trying to stop BEFORE the worker has had a chance to startup ...
+    
+                console.log(`Terminating worker: [${workerEx.id}]`);
+                const promArray: Promise<boolean>[] = [ ];
+    
+                // Terminate only those that are currently running...
+                const ids: string[] = Object.keys(workerEx.runnersEx);
+
+                ids.forEach((id) => {
+                    const runnerEx: IRunnerEx = workerEx.runnersEx[id];
+                    promArray.push(this.#StopRunner(workerEx, runnerEx));
+                });
+                await Promise.all(promArray);
+
+                this.#TerminateWorker(workerEx);
+            }
+            return true;
+        } catch (error) {
+            console.log(`Error in STSTestWorker:StopWorker: [${error}]`);
+            return false;
+        }
+    }
+
+    GetNextAvailableWorker = (): IWorkerEx | null => {
+        // Calculate the worker with the least runners
+        let leastRunnerWorker: IWorkerEx | null = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            if (leastRunnerWorker) {
+                if (Object.keys(stsWorker.runnersEx).length < Object.keys(leastRunnerWorker.runnersEx).length) {
+                    leastRunnerWorker = stsWorker;
+                }
+            } else {
+                leastRunnerWorker = stsWorker;
+            }
+        }
+        return leastRunnerWorker;
+    }
+
+    GetBusyWorker = (): IWorkerEx | null => {
+        // Calculate the worker with the least runners
+        let busyWorker: IWorkerEx | null = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            if (busyWorker) {
+                if (Object.keys(stsWorker.runnersEx).length > Object.keys(busyWorker.runnersEx).length) {
+                    busyWorker = stsWorker;
+                }
+            } else {
+                busyWorker = stsWorker;
+            }
+        }
+        return busyWorker;
+    }
+
+    get Options(): IWorkerManagerOptions {
+        return this.#options;
+    }
+
+    set Options(options: IWorkerManagerOptions) {
+        this.#options = options;
+    }
+
+    StopAllWorkers = async () => {
+        const promArray = [ ];
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            promArray.push(stsWorker.Stop());
+        }
+        await Promise.all(promArray);
+    }
+}

package/src/testertesting/workerPrimaryTestRunner01.ts

@@ -0,0 +1,81 @@
+import { MessagePort } from 'worker_threads';
+
+import chalk from 'chalk';
+// Force chalk level
+chalk.level = 3;
+
+import { IPrimaryWorker, IWorkerOptions, PublishMessageCommandsTestRunner, 
+    IIWMessagePayload, IIWMessagePayloadContentBase } from './stsTestWorkerDefinitions'
+
+//import { STSOAuth2Manager, STSOAuth2ManagerPluginKey } from '@nsshunt/stsoauth2plugin'
+
+// This will execute within the primary thread context and have access to plugins and other Vue application features
+export class WorkerPrimaryTestRunner01 implements IPrimaryWorker {
+//    #STSOAuth2Manager: STSOAuth2Manager
+    #options: IWorkerOptions
+
+    #debug = (message: string) => {
+        console.log(chalk.magenta(`pid: [${process.pid}] WorkerPrimaryTestRunner01::${message}`));
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    constructor(app: any, options: IWorkerOptions) {
+        this.#debug(`constructor`)
+        this.#options = options;
+        this.#debug(`constructor::options: [${JSON.stringify(this.#options)}]`);
+        //        this.#STSOAuth2Manager = app.config.globalProperties.$sts[STSOAuth2ManagerPluginKey]
+    }
+
+    async ProcessMessageFromWorker(workerPort: MessagePort, publishMessagePayload: IIWMessagePayload) {
+        this.#debug(`ProcessMessageFromWorker`)
+        // Process messages received back from the worker
+        switch (publishMessagePayload.command as PublishMessageCommandsTestRunner) {
+        case PublishMessageCommandsTestRunner.GetAccessToken : {
+            //const access_token = await this.#GetAccessToken();
+            const access_token = '1234';
+            workerPort.postMessage({ 
+                command: PublishMessageCommandsTestRunner.GetAccessTokenResponse,
+                payload: {
+                    messageId: publishMessagePayload.payload.messageId,
+                    access_token
+                } as IIWMessagePayloadContentBase
+            })}
+            break;
+        case PublishMessageCommandsTestRunner.ExecuteRefreshToken : {
+            //const access_token = await this.#ExecuteRefreshToken();
+            const access_token = '5678';
+            workerPort.postMessage({ 
+                command: PublishMessageCommandsTestRunner.ExecuteRefreshTokenResponse,
+                payload: {
+                    messageId: publishMessagePayload.payload.messageId,
+                    access_token
+                } as IIWMessagePayloadContentBase
+            })}
+            break;
+        default :
+            throw new Error(`publishMessagePayload.command: [${publishMessagePayload.command}] not allowed`);
+        }
+    }
+
+    /*
+    #GetAccessToken = async() : Promise<string | null> => {
+        debug(`WorkerPrimaryTestRunner01::GetAccessToken`)
+        return await this.#STSOAuth2Manager.GetAccessToken();
+    }
+
+    #ExecuteRefreshToken = async (): Promise<string | null> => {
+        debug(`WorkerPrimaryTestRunner01::ExecuteRefreshToken`)
+        const retVal  = await this.#STSOAuth2Manager.ExecuteRefreshToken();
+        if (retVal) {
+            const access_token = await this.#STSOAuth2Manager.GetAccessToken();
+            if (access_token) {
+                return access_token;
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+        */
+}