@nsshunt/stsappframework 3.1.159 → 3.1.161

package/src/testertesting/workerInstance.ts

@@ -0,0 +1,154 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import { MessagePort } from 'worker_threads';
+
+import { IIWMessagePayload, eIWMessageCommands, IIWMessagePayloadContentBase } from './commonTypes'
+
+import type { ISTSAgentWorkerMessagePort, IRunner, ITestRunnerTelemetryPayload } from './stsTestWorkerDefinitions'
+import { IRunnerState } from './stsTestWorkerDefinitions'
+
+import { RequestResponseHelper } from './requestResponseHelper'
+
+import chalk from 'chalk';
+// Force chalk level
+chalk.level = 3;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface IWorkerInstanceOptions {
+
+}
+
+export abstract class WorkerInstance {
+    #collectorCollectorPort: MessagePort | null = null;
+    #requestResponseHelper: RequestResponseHelper | null = null;
+    #runners: Record<string, IRunner> = { };
+    #options: IWorkerInstanceOptions | null = null;
+
+    #debug = (message: string) => {
+        console.log(chalk.green(`pid: [${process.pid}] WorkerInstance::${message}`));
+    }
+
+
+    constructor() {
+        this.#debug(`constructor`)
+    }
+
+    GetRandomInt = (max: number) => {
+        this.#debug(`GetRandomInt`)
+        return Math.floor(Math.random() * Math.floor(max));
+    };
+
+     
+    StartWork = async (runner: IRunner): Promise<void> => {
+        this.#debug(`StartWork`)
+        return;
+    }
+
+    PostTelemetry = (runner: IRunner) => {
+        //debug(`WorkerInstance::PostTelemetry`)
+        if (this.#collectorCollectorPort) {
+            const message: IIWMessagePayload = {
+                command: eIWMessageCommands.InstrumentTelemetry,
+                payload: {
+                    runner
+                } as ITestRunnerTelemetryPayload
+            }
+            this.#collectorCollectorPort.postMessage(message);
+        }
+    }
+
+    get RequestResponseHelper(): RequestResponseHelper | null {
+        return this.#requestResponseHelper;
+    }
+
+    get CollectorCollectorPort(): MessagePort | null {
+        return this.#collectorCollectorPort;
+    }
+
+    get Options(): IWorkerInstanceOptions | null {
+        return this.#options;
+    }
+
+    #SetMessagePort = (workerMessagePort: ISTSAgentWorkerMessagePort) => {
+        this.#debug(`SetMessagePort`)
+        this.#collectorCollectorPort = workerMessagePort.port as MessagePort;
+
+        // NodeJS version
+        this.#collectorCollectorPort.on('message', (data: any) => {
+            this.#debug(`collectorCollectorPort onmessage: ${data.data}`);
+        });
+
+        // Browser Version
+        /*
+        this.#collectorCollectorPort.onmessage = function(data: MessageEvent) {
+            console.log(`collectorCollectorPort onmessage: ${data.data}`);
+        }
+        */
+
+        this.#requestResponseHelper = new RequestResponseHelper(this.#collectorCollectorPort);
+
+        const response: IIWMessagePayload = {
+            command: eIWMessageCommands.MessagePortResponse,
+            payload: { } as IIWMessagePayloadContentBase
+        }
+
+        this.#collectorCollectorPort.postMessage(response);
+    }
+
+    StartRunner = async (runner: IRunner) => {
+        this.#debug(`StartRunner`)
+        this.#debug(`StartTests: [${JSON.stringify(runner)}]`);
+        runner.state = IRunnerState.running;
+        this.StartWork(runner);
+    }
+
+    #AddAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`AddAsyncRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id] = runner;
+        this.StartRunner(runner);
+    }
+
+    #StopRunners = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`StopRunners`)
+        if (testRunnerTelemetryPayload === null) {
+            for (const [, testRunner] of Object.entries(this.#runners)) {
+                testRunner.state = IRunnerState.stopped;
+            }
+        } else {
+            const runner: IRunner = this.#runners[testRunnerTelemetryPayload.runner.id];
+            if (runner) {
+                runner.state = IRunnerState.stopped;
+            }
+        }
+    }
+
+    // ProcessMessage = async(data: MessageEvent) => { // Browser version
+    ProcessMessage = async(data: any) => {
+        this.#debug(`ProcessMessage: data: [${JSON.stringify(data)}]`)
+        try {
+            // const payloadMessage: IIWMessagePayload = data.data as IIWMessagePayload; // browser version
+            const payloadMessage: IIWMessagePayload = data as IIWMessagePayload;
+            switch (payloadMessage.command) {
+            case eIWMessageCommands.MessagePort :
+                this.#debug(`ProcessMessage::MessagePort`)
+                this.#SetMessagePort(payloadMessage.payload as ISTSAgentWorkerMessagePort);
+                this.#options = (payloadMessage.payload as ISTSAgentWorkerMessagePort).options;
+                this.#debug(`ProcessMessage::#options: [${JSON.stringify(this.#options)}]`)
+                break;
+            case eIWMessageCommands.AddAsyncRunner :
+                this.#debug(`ProcessMessage::AddAsyncRunner`)
+                this.#AddAsyncRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;
+            case eIWMessageCommands.StopAllAsyncRunners :
+                this.#debug(`ProcessMessage::StopAllAsyncRunners`)
+                this.#StopRunners(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;
+            default :
+                this.#debug(`ProcessMessage::default`)
+                this.#debug(`Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
+            }
+        } catch (error) {
+            console.log(error);
+        }
+    }
+}

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