@nsshunt/stsappframework 3.1.214 → 3.1.215

package/src/testertesting/workerManager.ts

@@ -1,511 +0,0 @@
-/* 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 { IAsyncRunnerContext, IIWMessagePayload, IIWMessagePayloadContentBase, 
-    IIWMessageCommand, eIWMessageCommands, IWorkerState, IRunnerState,
-    ISTSAgentWorkerMessagePort, IWorkerEx, IRunner, IRunnerEx,
-    ITestRunnerTelemetryPayload, IRunnerOptions, IRunnerTelemetry,
-    IWorkerManagerOptions, IWorkerFactory, IRunnerEvent,
-    IWorkerOptions
-} from './commonTypes'
-
-import { ModelDelimeter } from '@nsshunt/stsutils'
-
-import { Sleep } from '@nsshunt/stsutils';
-
-import { PublishInstrumentController } from '@nsshunt/stsobservability'
-
-import chalk from 'chalk';
-import { TelemetryProcessor } from './telemetryProcessor'
-chalk.level = 3;
-
-import isNode from 'detect-node'
-
-export class STSWorkerManager {
-    //#agentSession: string = null;
-    #workersEx: Record<string, IWorkerEx> = { };
-    #runner = 0;
-    #workerId = 0;
-    #options: IWorkerManagerOptions;
-    #STSInstrumentController: PublishInstrumentController
-    #telemetryProcessor: TelemetryProcessor
-     
-    constructor(options?: IWorkerManagerOptions) {
-        if (options) {
-            this.#options = options;
-        } else {
-            this.#options = { } as IWorkerManagerOptions;
-        }
-
-        this.#STSInstrumentController = this.#options.publishInstrumentController;
-        this.#telemetryProcessor = new TelemetryProcessor();
-    }
-    
-    #debug = (message: string) => {
-        console.log(chalk.cyan(`pid: [${process.pid}] STSWorkerManager::${message}`));
-    }
-
-    get WorkersEx(): Record<string, IWorkerEx> {
-        return this.#workersEx;
-    }
-
-    get runnerId(): number {
-        return this.#runner;
-    }
-
-    set runnerId(id: number) {
-        this.#runner = id;
-    }
-
-    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 workerId = this.#workerId++;
-        const stsWorkerEx: IWorkerEx = {
-            id: workerId,
-            worker: workerFactory.createWorkerThreadWorker(),
-            state: IWorkerState.starting,
-            workerThreadWorkerOptions: workerFactory.workerThreadWorkerOptions,
-            runnersEx: { } as Record<string, IRunnerEx>,
-            runnersEvents: { } as Record<string, IRunnerEvent[]>,
-
-            GetRunner: (id: string): IRunnerEx | null => this.#workersEx[workerId].GetRunner(id),
-
-            // Commands to execute on individual runners
-            AddRunner: (runnerOptions: IRunnerOptions): IRunnerEx => this.AddRunnerToWorker(stsWorkerEx, runnerOptions),
-            StartRunner: (runner: IRunnerEx): Promise<boolean> => this.#StartRunner(stsWorkerEx, runner),
-            StopRunner: (runner: IRunnerEx): Promise<boolean> => this.#StopRunner(stsWorkerEx, runner),
-            PauseRunner: (runner: IRunnerEx): Promise<boolean> => this.#PauseRunner(stsWorkerEx, runner),
-            ResumeRunner: (runner: IRunnerEx): Promise<boolean> => this.#ResumeRunner(stsWorkerEx, runner),
-            TerminateRunner: (runner: IRunnerEx): Promise<boolean> => this.#TerminateRunner(stsWorkerEx, runner),
-            ResetRunner: (runner: IRunnerEx): Promise<boolean> => this.#ResetRunner(stsWorkerEx, runner),
-            ExecuteRunner: (runner: IRunnerEx): Promise<boolean> => this.#ExecuteRunner(stsWorkerEx, runner),
-            UpdateOptionsRunner: (runner: IRunnerEx, options: IRunnerOptions): Promise<boolean> => this.#UpdateOptions(stsWorkerEx, runner, options),
-
-            // Commands to execute on all runners
-            Start: async (): Promise<boolean> => this.#StartWorker(stsWorkerEx),
-            Stop: async (): Promise<boolean> => this.#StopWorker(stsWorkerEx),
-            Pause: async (): Promise<boolean> => this.#PauseWorker(stsWorkerEx),
-            Resume: async (): Promise<boolean> => this.#ResumeWorker(stsWorkerEx),
-            Terminate: async (): Promise<boolean> => this.#TerminateWorker(stsWorkerEx),
-            Reset: async (): Promise<boolean> => this.#ResetWorker(stsWorkerEx),
-            Execute: async (): Promise<boolean> => this.#ExecuteWorker(stsWorkerEx),
-            UpdateOptions: async (options: IRunnerOptions): Promise<boolean> => this.#UpdateOptionsWorker(stsWorkerEx, options)
-        }
-        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: [${stsWorkerEx.workerThreadWorkerOptions.id}]`);
-
-        this.#PostMessageToWorker(stsWorkerEx, eIWMessageCommands.MessagePort, {
-            port: port2,
-            //applicationStoreState: stateCopy,
-            options: {
-                ...stsWorkerEx.workerThreadWorkerOptions
-            } as IWorkerOptions
-        } as ISTSAgentWorkerMessagePort, port2);
-    
-        // Process messages received back from the worker
-        //workerPort.onmessage = async (data: MessageEvent) => {
-        workerPort.on('message', (data: any) => {
-            let publishMessagePayload: IIWMessagePayload;
-            if (isNode) {
-                publishMessagePayload = data as IIWMessagePayload;
-            } else {
-                // const publishMessagePayload: IIWMessagePayload = data.data as IIWMessagePayload; browser version
-                publishMessagePayload = data.data as IIWMessagePayload; // browser version
-            }
-            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;
-            case eIWMessageCommands.Completed :
-                //this.#debug(`AddWorker::eIWMessageCommands.InstrumentTelemetry`);
-                this.#ProcessCompleted(stsWorkerEx, publishMessagePayload.payload as ITestRunnerTelemetryPayload);
-                break;
-            default :
-                this.#debug(`AddWorker::default`);
-            }
-        });
-
-        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 },
-            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.AddRunner, 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];
-
-            // Copy telemetry
-            runnerEx.instrumentData = { ...runner.instrumentData };
-
-            if (runner.instrumentData.message) {
-                runnerEx.instrumentData.message = [...runner.instrumentData.message];
-            } else {
-                runnerEx.instrumentData.message = [ ];
-            }
-
-            const update = this.#telemetryProcessor.ProcessTelemetry(runnerEx.publishInstrumentController, runnerEx.instrumentData);
-
-            if (update) {
-                //store.Update(workerEx, runnerEx);
-            }
-        }
-    }
-
-    #ProcessCompleted = (workerEx: IWorkerEx, payloadContents: ITestRunnerTelemetryPayload): void => {
-        const { runner } = payloadContents;
-        if (workerEx.runnersEvents[runner.id]) {
-            const runnersEvents: IRunnerEvent[] = workerEx.runnersEvents[runner.id];
-            runnersEvents.forEach(ev => {
-                if (ev.eventName.localeCompare('Completed') === 0) {
-                    ev.cb();
-                }
-            })
-        }
-        console.log(chalk.green(`ProcessCompleted: [${JSON.stringify(runner)}]`));
-    }
-
-    #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.AddPublishInstrumentController(asyncRunnerContext),
-            asyncRunnerContext: asyncRunnerContext,
-            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,
-            Start: async (): Promise<boolean> => this.#StartRunner(workerEx, runnerEx),
-            Stop: async (): Promise<boolean> => this.#StopRunner(workerEx, runnerEx),
-            Pause: async (): Promise<boolean> => this.#PauseRunner(workerEx, runnerEx),
-            Resume: async (): Promise<boolean> => this.#ResumeRunner(workerEx, runnerEx),
-            Reset: async (): Promise<boolean> => this.#ResetRunner(workerEx, runnerEx),
-            Execute: async (): Promise<boolean> => this.#ExecuteRunner(workerEx, runnerEx),
-            Terminate: async (): Promise<boolean> => this.#TerminateRunner(workerEx, runnerEx),
-            UpdateOptions: async (options: IRunnerOptions): Promise<boolean> => this.#UpdateOptions(workerEx, runnerEx, options),
-            on: (eventName: string, cb: () => void): IRunnerEx => {
-                if (!workerEx.runnersEvents[runnerEx.id]) {
-                    workerEx.runnersEvents[runnerEx.id] = [ ];
-                }
-                workerEx.runnersEvents[runnerEx.id].push({
-                    eventName,
-                    cb
-                });
-                return 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 });
-        }
-    }
-
-    #StartRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
-        this.#PostMessageToWorker(workerEx, eIWMessageCommands.StartRunner, {
-            runner: this.#CreateRunnerCopy(runnerEx)
-        } as ITestRunnerTelemetryPayload);
-        return true;
-    }
-
-    #ResetRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
-        this.#PostMessageToWorker(workerEx, eIWMessageCommands.ResetRunner, {
-            runner: this.#CreateRunnerCopy(runnerEx)
-        } as ITestRunnerTelemetryPayload);
-        return true;
-    }
-
-    #ExecuteRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
-        this.#PostMessageToWorker(workerEx, eIWMessageCommands.ExecuteRunner, {
-            runner: this.#CreateRunnerCopy(runnerEx)
-        } as ITestRunnerTelemetryPayload);
-        return true;
-    }
-
-    #StopRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
-        this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopRunner, {
-            runner: this.#CreateRunnerCopy(runnerEx)
-        } as ITestRunnerTelemetryPayload);
-        return true;
-    }
-
-    #TerminateRunner = 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.TerminateRunner, {
-                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;
-    }
-
-    #PauseRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
-        this.#PostMessageToWorker(workerEx, eIWMessageCommands.PauseRunner, {
-            runner: this.#CreateRunnerCopy(runnerEx)
-        } as ITestRunnerTelemetryPayload);
-        return true;
-    }
-
-    #ResumeRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
-        this.#PostMessageToWorker(workerEx, eIWMessageCommands.ResumeRunner, {
-            runner: this.#CreateRunnerCopy(runnerEx)
-        } as ITestRunnerTelemetryPayload);
-        return true;
-    }
-
-    #WorkerCommand = async (workerEx: IWorkerEx, command: any, options?: IRunnerOptions): Promise<boolean> => {
-        try {
-            if (workerEx.state !== IWorkerState.stopped) {
-                console.log(`Stop 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];
-                    if (options) {
-                        promArray.push(command(workerEx, runnerEx, options));
-                    } else {
-                        promArray.push(command(workerEx, runnerEx));
-                    }
-                });
-                await Promise.all(promArray);
-            }
-            return true;
-        } catch (error) {
-            console.log(`Error in STSTestWorker:WorkerCommand: [${error}]`);
-            return false;
-        }
-    }
-
-    #PauseWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
-        return this.#WorkerCommand(workerEx, this.#PauseRunner);
-    }
-
-    #ResumeWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
-        return this.#WorkerCommand(workerEx, this.#ResumeRunner);
-    }
-
-    #StopWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
-        return this.#WorkerCommand(workerEx, this.#StopRunner);
-    }
-
-    #StartWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
-        return this.#WorkerCommand(workerEx, this.#StartRunner);
-    }
-
-    #ResetWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
-        return this.#WorkerCommand(workerEx, this.#ResetRunner);
-    }
-
-    #ExecuteWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
-        return this.#WorkerCommand(workerEx, this.#ExecuteRunner);
-    }
-
-    #UpdateOptionsWorker = async (workerEx: IWorkerEx, options: IRunnerOptions): Promise<boolean> => {
-        return this.#WorkerCommand(workerEx, this.#UpdateOptions, options);
-    }
-
-    #TerminateWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
-        try {
-            if (workerEx.state !== IWorkerState.stopped) {
-                await this.#WorkerCommand(workerEx, this.#TerminateRunner);
-
-                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`);
-                }
-            }
-            return true;
-        } catch (error) {
-            console.log(`Error in STSTestWorker:TerminateWorker: [${error}]`);
-            return false;
-        }
-    }
-
-    #UpdateOptions = async (workerEx: IWorkerEx, runnerEx: IRunnerEx, options: IRunnerOptions): Promise<boolean> => {
-        runnerEx.options = { ...options };
-        this.#PostMessageToWorker(workerEx, eIWMessageCommands.UpdateOptions, {
-            runner: this.#CreateRunnerCopy(runnerEx)
-        } as ITestRunnerTelemetryPayload);
-        return true;
-    }
-
-    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/workerWorkerTestRunner01.ts

@@ -1,34 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: 0,  @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { IRunnerInstance, ITestRunnerTelemetryPayload } from './commonTypes'
-import { WorkerInstance } from './workerInstance'
-import { TestCase01 } from './testCase01'
-
-import isNode from 'detect-node'
-
-import { parentPort } from 'worker_threads';
-
-export class WorkerTestCases extends WorkerInstance {
-    constructor() {
-        super()
-    }
-
-    override CreateAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunnerInstance | null => {
-        const { runner } = testRunnerTelemetryPayload;
-        switch (runner.options.testType) {
-        case 'TestCase01' :
-            return new TestCase01(this, runner)
-        }
-        return null;
-    }
-}
-
-const worker = new WorkerTestCases();
-
-parentPort?.on('message', (data: any) => {
-    if (isNode) {
-        worker.ProcessMessage(data);
-    } else {
-        // const payloadMessage: IIWMessagePayload = data.data as IIWMessagePayload; // browser version
-        worker.ProcessMessage(data.data); // browser version
-    }
-});

package/src/testing/app.ts

@@ -1,14 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { ServiceConfigOptions } from './appConfig'
-import { MasterProcessBase } from './..'
-import { WorkerProcess } from './appWorkerWSS'
-
-import cluster from 'node:cluster';
-
-
-if (cluster.isPrimary) {
-    new MasterProcessBase(ServiceConfigOptions(true, cluster.isPrimary)).SetupServer();
-} else {
-    const worker = new WorkerProcess(ServiceConfigOptions(true, cluster.isPrimary));
-    worker.SetupServer();
-}

package/src/testing/appConfig.ts

@@ -1,110 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import express from 'express';
-
-import { goptions } from '@nsshunt/stsconfig'
-
-import { ProcessOptions, IProcessBase, STSServerType } from './..'
-
-import { STSExpressRouteFactory } from './server'
-
-import winston from 'winston'
-
-/*
-// nid: `${goptions.rest01servicename} @ ${goptions.rest01serviceversion}  |  ${this.options.globalServiceData.serviceInstanceId} @ ${os.hostname()}   ^   ${process.pid} @ ${(cluster.isMaster ? process.pid : process.ppid)}`,
-//                        <serviceId>                                                                 <serviceInstanceId>                                                       <serviceInstanceProcessId>
-//              <serviceName>                    <serviceVersion>                                  <sid>                              <hostName>               <pid>                                     <ppid>
-//                                                  << ............... Static Nid ............... >>                                                                    << ............... Dynamic Nid ............... >>
-// Note: The final nid will NOT contain the NID_SEPERATOR character. This will be replaced with the SEPERATOR character.
-const Context = (isMaster, serviceInstanceId) => {
-    return {
-        nid: `\
-${goptions.rest01servicename}${ModelDelimeter.COMPONENT_SEPERATOR}${goptions.rest01serviceversion}\
-${ModelDelimeter.SEPERATOR}\
-${serviceInstanceId}${ModelDelimeter.COMPONENT_SEPERATOR}${os.hostname()}\
-${ModelDelimeter.NID_SEPERATOR}\
-${process.pid}${ModelDelimeter.COMPONENT_SEPERATOR}${(isMaster ? process.pid : process.ppid)}`
-    }
-}
-*/
-
-export function ServiceConfigOptions(clusterMode: boolean, isMaster: boolean): ProcessOptions {
-    winston.format.combine(
-        winston.format.colorize(),
-        winston.format.simple()
-    );
-
-    const logger = winston.createLogger({
-        level: 'debug',
-        format: winston.format.combine(
-            winston.format.colorize(),
-            winston.format.simple()
-        ),
-        transports: [
-            new winston.transports.Console()
-        ]
-    });
-
-    const publisherLogger = winston.createLogger({
-        level: 'info',
-        format: winston.format.combine(
-            winston.format.colorize(),
-            winston.format.simple()
-        ),
-        transports: [
-            new winston.transports.Console()
-        ]
-    });
-
-    if (isMaster === true) {
-        const serviceInstanceId = uuidv4();
-        const data: ProcessOptions = {
-            serverType: STSServerType.EXPRESS_TLS,
-            clusterMode: clusterMode,
-            wssServer: true,
-            useLatency: true,
-            httpsServerKeyPath: goptions.httpsserverkeypath,
-            httpsServerCertificatePath: goptions.httpsservercertpath,
-            processExitOnTerminate: true,
-            serviceInstanceId: serviceInstanceId,
-            useDatabase: false,
-
-            isMaster: isMaster,
-            endpoint: goptions.rest01endpoint,
-            apiRoot: goptions.rest01apiroot,
-            listenPort: goptions.rest01hostport,
-            port: goptions.rest01port,
-            prometheusSupport: goptions.rest01prometheussupport,
-            prometheusClusterPort: goptions.rest01prometheusclusterport,
-            serviceName: goptions.rest01servicename,
-            serviceVersion: goptions.rest01serviceversion,
-            consoleLogging: true,
-            instrumentLogging: true,
-
-            instrumentationObservationInterval: goptions.instrumentationObservationInterval,
-            instrumentationTimeWindow: goptions.instrumentationTimeWindow,
-
-            useSocketIoRedisAdaptor: false,
-            //workerExec: './dist/testing/app.js',
-
-            logger: logger,
-            publisherLogger: publisherLogger,
-            publishInterval: goptions.publishinterval
-        }
-
-        if (!clusterMode) {
-            data.expressServerRouteFactory = (app: express.Express, stsApp: IProcessBase) => {
-                return new STSExpressRouteFactory(app, stsApp);
-            }
-        }
-    
-        return data;
-    } else {
-        const data: ProcessOptions = JSON.parse(process.env['STS_GSD_SII'] as string) as ProcessOptions;
-        data.expressServerRouteFactory = (app: express.Express, stsApp: IProcessBase) => {
-            return new STSExpressRouteFactory(app, stsApp);
-        }
-        data.logger = logger;
-        data.publisherLogger = publisherLogger;
-        return data;
-    }
-}