@nsshunt/stsappframework 3.1.231 → 3.1.233

package/src/vitesttesting/appSingleWSS.ts

@@ -1,79 +1,142 @@
 /* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
 import chalk from 'chalk';
 
-import { SingleProcessBase, STSNamespace, STSRoom, STSSocketIONamespace, ProcessOptions } from './../index'
-import { SocketIoServerHelper } from '@nsshunt/stsobservability'
+import { SingleProcessBase, ProcessOptions } from './../index'
+import { SocketIoServerHelper, STSNamespace, STSRoom, InterServerEvents } from '@nsshunt/stssocketioutils'
 
-import { Socket } from "socket.io";
-
-import { InterServerEvents } from './../commonTypes'
+import { Namespace, Socket } from "socket.io";
 
 import { ClientToServerEvents, ServerToClientEvents } from './wsevents'
+import { JSONObject } from '@nsshunt/stsutils';
 
 export class AppSingleWSS extends SingleProcessBase
 {
-    constructor(options: ProcessOptions)
-    {
+    constructor(options: ProcessOptions) {
         super(options);
-        this.socketIoServerHelper = new SocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>({
-            logger: this.options.logger
-        });
     }
 
     #LogInfoMessage(message: any) {
         this.options.logger.info(message);
     }
 
-    override ProcessStarted() {
-        super.ProcessStarted();
-        
-        if (this.socketIoServerHelper) {
-            this.socketIoServerHelper.SetupNamespace(this.io as any, STSNamespace.STSMonitor, 
-                // Auto joinn room list
-                [ 
-                    STSRoom.STSInstrumentDataRoom,
-                    STSRoom.STSRunnerRoom,
-                    'room3'
-                ], 
-                true, // Make any connecting client automatically join the room list above
-
-                // Connect call back when a client connects
-                (socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => {
-                    this.#LogInfoMessage(chalk.gray(`WorkerProcess.#SendIPCMessageToMaster: Id: [${socket.id}] eventName: [connect]`));
-                },
-
-                // Custom client to server events
-                (socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => {
-                    socket.on('subscribe', (data: any) => {
-                        socket.emit('subscribeAck', data);
-                    });
-                    socket.on('unsubscribe', (data: any) => {
-                        socket.emit('unsubscribeAck', data);
-                    });
-                    socket.on('subscribeKeepAlive', (data: any) => {
-                        socket.emit('subscribeKeepAliveAck', data);
-                    });
-                    socket.on('done', () => {
-                        socket.emit('doneAck');
-                    });
-                    socket.on('compute', (arg: number, cb) => {
-                        const res = arg * 2;
-                        cb(res.toString());
-                    });
-                    socket.on('compute2', (arg, cb) => {
-                        cb({data: arg*2});
+    #SetupWSSServer = (namespace: STSNamespace) => {
+
+
+
+        this.socketIoServerHelper = new SocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>({
+            logger: this.options.logger
+        });
+
+
+        //this.io?.of('/stsinstrumentmanager/stsmonitor/');
+        //return;
+
+        //this.socketIoServerHelper.SetupNamespaceEx(this.io as any, '/stsinstrumentmanager/stsmonitor/' as any);
+        //return;
+
+
+        this.socketIoServerHelper.SetupNamespace(this.io as any, namespace, 
+            // Auto joinn room list
+            [ 
+                STSRoom.STSInstrumentDataRoom,
+                STSRoom.STSRunnerRoom,
+                'room3'
+            ], 
+            true, // Make any connecting client automatically join the room list above
+
+            // Connect call back when a client connects
+            (socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => {
+                this.#LogInfoMessage(chalk.gray(`AppSingleWSS.#SetupWSSServer: Id: [${socket.id}] eventName: [connect]`));
+            },
+
+            // Custom client to server events
+            (socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => {
+                socket.on('subscribe', (data: any) => {
+                    socket.emit('subscribeAck', data);
+                });
+                socket.on('unsubscribe', (data: any) => {
+                    socket.emit('unsubscribeAck', data);
+                });
+                socket.on('subscribeKeepAlive', (data: any) => {
+                    socket.emit('subscribeKeepAliveAck', data);
+                });
+                socket.on('done', () => {
+                    socket.emit('doneAck');
+                });
+                socket.on('compute', (arg: number, cb) => {
+                    const res = arg * 2;
+                    cb(res.toString());
+                });
+                socket.on('compute2', (arg, cb) => {
+                    cb({data: arg*2});
+                });
+                socket.on('broadcast', () => {
+
+                    if (this.socketIoServerHelper) {
+                        const namespaceIo = this.socketIoServerHelper
+                            .GetSTSSocketIONamespace(namespace).socketionamespace as Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>
+
+                        namespaceIo.to("room3").timeout(5000).emit("compute3", 10, (err: Error, data: JSONObject[]) => {
+                            if (err) {
+                                console.log(`room3 broadcast: [${chalk.red(JSON.stringify(err))}]`)
+                            } else {
+                                console.log(`room3 broadcast: [${chalk.blue(JSON.stringify(data))}]`)
+                            }
+                        });
+                    }
+                });
+
+                socket.on('__STSsendToRoomWithCB', (rooms: string[], payload: { command: string, payload: JSONObject }): void => {
+                    rooms.forEach((room) => {
+                        //this.LogMessage(namespace, `${namespace.socketionamespace.name}:socket.on:sendToRoom: __STSsendToRoom: Sending to room [${room}], ID: [${socket.id}]`);
+                            
+                        if (this.socketIoServerHelper) {
+                            const namespaceIo = this.socketIoServerHelper
+                                .GetSTSSocketIONamespace(namespace).socketionamespace as Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>
+
+                            namespaceIo.to(room).timeout(5000).emit(payload.command as any, payload, (err: Error, data: JSONObject[]) => {
+                                if (err) {
+                                    console.error(err);
+                                    console.log(`__STSsendToRoomWithCB broadcast: [${chalk.red(JSON.stringify(err))}]`)
+                                } else {
+                                    console.log(`__STSsendToRoomWithCB broadcast: [${chalk.blue(JSON.stringify(data))}]`)
+                                }
+                            });
+                        }
                     });
-                })
-        } else {
-            throw new Error('WorkerProcess:WorkerStarted(): this.socketIoHelper is null')
-        }
-        return null;
+                });
+
+                socket.on('GetThreadDetails', (inputThreaddata: JSONObject, cb: (data: JSONObject) => void) => {
+                    if (this.socketIoServerHelper) {
+                        const namespaceIo = this.socketIoServerHelper
+                            .GetSTSSocketIONamespace(namespace).socketionamespace as Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>
+
+                        namespaceIo.to(inputThreaddata.room).timeout(5000).emit('GetThreadDetailsFromService', { data: inputThreaddata }, (err: Error, data: JSONObject[]) => {
+                            if (err) {
+                                console.error(err);
+                                console.log(`__STSsendToRoomWithCB broadcast: [${chalk.red(JSON.stringify(err))}]`)
+                            } else {
+                                console.log(`__STSsendToRoomWithCB broadcast: [${chalk.blue(JSON.stringify(data))}]`)
+                                cb(data);
+                            }
+                        });
+                    }
+                });
+            })
     }
+    
+    override ProcessStarted() {
+        super.ProcessStarted();
+
+        /*
+        const nsp = this.io?.of('/stsinstrumentmanager/stsmonitor');
+        nsp?.on("connection", socket => {
+
+        });
+        this.#SetupConnectionMiddleware(nsp);
+        */
 
-    get stsMonitorNamespace(): STSSocketIONamespace | null {
-        if (this.socketIoServerHelper !== null) {
-            return this.socketIoServerHelper.GetSTSSocketIONamespace(STSNamespace.STSMonitor);
-        }
-        return null;
+        this.#SetupWSSServer(STSNamespace.STSMonitor);
+        //this.#SetupWSSServer('stsinstrumentmanager/stsmonitor' as any);
     }
 }

package/src/vitesttesting/singleservertest.test.ts

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 
 import axios, { AxiosError, AxiosResponse } from 'axios';
 
-import { Sleep } from '@nsshunt/stsutils'
+import { JSONObject, Sleep } from '@nsshunt/stsutils'
 //import { SingleProcessBase, MasterProcessBase } from './..'
 
 import { AppSingleWSS } from './appSingleWSS'
@@ -14,22 +14,23 @@ import { goptions, $ResetOptions, STSAxiosConfig, AgentManager } from '@nsshunt/
 
 import { beforeAll, afterAll, test, describe, expect } from 'vitest';
 
-import { SocketIoClientHelper, ISocketIoClientHelperOptions } from '@nsshunt/stsobservability'
+import { SocketIoClientHelper, ISocketIoClientHelperOptions } from '@nsshunt/stssocketioutils'
 
-import { STSNamespace } from './../index'
+import { STSNamespace } from '@nsshunt/stssocketioutils'
 
 import { ServerToClientEvents, ClientToServerEvents } from './wsevents'
 import { Socket } from 'socket.io-client'
 
 //import { GenericContainer, Network, Wait } from "testcontainers";
-import { GenericContainer } from "testcontainers";
+import { GenericContainer, Network } from "testcontainers";
 
 describe("Single Server Test", () =>
 {
     let app: AppSingleWSS | null = null;
     let ioRedisMessageProcessorUrl = '';
     let ioRedisContainer: any = null;
-    
+    let network: any;
+
     const agentManager = new AgentManager({});
 
     const endpoint = 'https://localhost'
@@ -92,14 +93,22 @@ describe("Single Server Test", () =>
         }
     }
 
+    const StartNetwork = async () => {
+        network = await new Network().start();
+    }
+
+    const StopNetwork = async () => {
+        await network.stop();
+    }
+
     const StartRedis = async () => {
         ioRedisContainer = await new GenericContainer("redis/redis-stack-server")
             .withEnvironment({
                 REDIS_ARGS: "--save \"\" --appendonly no",
             })
             .withExposedPorts(6379)
-            //.withNetwork(this.#network)
-            //.withNetworkAliases("redisstackserver")
+            .withNetwork(network)
+            .withNetworkAliases("redisstackserver")
             //.withWaitStrategy(Wait.forLogMessage(`Ready to accept connections tcp`))
             .start();
 
@@ -109,7 +118,7 @@ describe("Single Server Test", () =>
         //expect(goptions.imRedisMessageProcessorUrl).toEqual('redis://localhost:6379');
         // IM_REDIS_MESSAGE_PROCESSOR_URL
 
-        console.log(chalk.green(`redis/redis-stack-server Started. Server Details: ioRedisMessageProcessorUrl: [${ioRedisMessageProcessorUrl}]`));
+        console.log(chalk.green(`redis/redis-stack-server Started. docker  [${ioRedisMessageProcessorUrl}]`));
     }
 
     const StopRedis = async () => {
@@ -119,10 +128,12 @@ describe("Single Server Test", () =>
 
     beforeAll(async () => {
 
+        await StartNetwork();
         await StartRedis();
 
         process.env.IM_REDIS_MESSAGE_PROCESSOR_URL = ioRedisMessageProcessorUrl;
-
+        process.env.SOCKET_IO_REDIS_ADAPTOR_URL = ioRedisMessageProcessorUrl;
+        
         $ResetOptions();
 
         const appOptions = ServiceConfigOptions(false, true);
@@ -136,10 +147,15 @@ describe("Single Server Test", () =>
         agentManager.Terminate();
         await Sleep(500);
         await app?.TerminateApplication();
-        await Sleep(1000);
+
+        await Sleep(2000);
+
         app = null;
 
         await StopRedis();
+        await StopNetwork();
+
+        await Sleep(2000);
     }, 120000);
 
     test('Testing Module', async () => {
@@ -159,77 +175,178 @@ describe("Single Server Test", () =>
     }, 10000);
 
     test('client socket testing', async () => {
-        expect.assertions(8);
-
-        let complete = false;
-
-        const socket = socketUtils.SetupClientSideSocket('STSUITerm', 
-            // The address defines the namespace to connect to (i.e. io.of('/address'))
-            instrumentManagerAddress,
-            // Connected call back
-            // eslint-disable-next-line  @typescript-eslint/no-unused-vars
-            (socket: Socket<ServerToClientEvents, ClientToServerEvents>) => {
-                LogDebugMessage(chalk.green(`connected - 1`));
-                expect(1).toEqual(1);
-            },
-            // Custom Events
-            (socket: Socket<ServerToClientEvents, ClientToServerEvents>) => {
-                socket.on('subscribeAck', (data: any) => {
-                    LogDebugMessage(chalk.yellow('subscribeAck'));
-                    expect(data.data).toMatch(/(subject01|subject02)/i);
-                });
-                socket.on('unsubscribeAck', (data: any) => {
-                    LogDebugMessage(chalk.yellow('unsubscribeAck'));
-                    expect(data.data).toMatch(/(subject02)/i);
-                });
-                socket.on('subscribeKeepAliveAck', (data: any) => {
-                    LogDebugMessage(chalk.yellow('subscribeKeepAliveAck'));
-                    expect(data.data).toMatch(/(ok)/i);
-                });
-                socket.on('doneAck', async () => {
-                    LogDebugMessage(chalk.yellow('doneAck'));
+        expect.assertions(29);
+
+        let connectCount = 0;
+        let subscribeAckCount = 0;
+        let unsubscribeAckCount = 0;
+        let subscribeKeepAliveAckCount = 0;
+        let doneAckCount = 0;
+
+        const SetupClient = async (clientName: string, joinRooms: string[]): Promise<Socket<ServerToClientEvents, ClientToServerEvents>> => {
+
+            const socket = socketUtils.SetupClientSideSocket('STSUITerm', 
+                // The address defines the namespace to connect to (i.e. io.of('/address'))
+                instrumentManagerAddress,
+                // Connected call back
+                // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+                (socket: Socket<ServerToClientEvents, ClientToServerEvents>) => {
+                    LogDebugMessage(chalk.green(`${clientName}: connected - 1`));
+                    connectCount++;
                     expect(1).toEqual(1);
-                    await Sleep(500);
-                    complete = true;
-                });
-            },
-            (error: Error) => {
-                LogErrorMessage(`SetupClientSideSocket call back: [${error}]`);
-            }
-        )
+                },
+                // Custom Events
+                (socket: Socket<ServerToClientEvents, ClientToServerEvents>) => {
+                    socket.on('subscribeAck', (data: any) => {
+                        LogDebugMessage(chalk.yellow(`${clientName}: subscribeAck`));
+                        subscribeAckCount++;
+                        expect(data.data).toMatch(/(subject01|subject02)/i);
+                    });
+                    socket.on('unsubscribeAck', (data: any) => {
+                        unsubscribeAckCount++;
+                        LogDebugMessage(chalk.yellow(`${clientName}: unsubscribeAck`));
+                        expect(data.data).toMatch(/(subject02)/i);
+                    });
+                    socket.on('subscribeKeepAliveAck', (data: any) => {
+                        subscribeKeepAliveAckCount++;
+                        LogDebugMessage(chalk.yellow(`${clientName}: subscribeKeepAliveAck`));
+                        expect(data.data).toMatch(/(ok)/i);
+                    });
+                    socket.on('doneAck', async () => {
+                        doneAckCount++;
+                        LogDebugMessage(chalk.yellow(`${clientName}: doneAck`));
+                        expect(1).toEqual(1);
+                    });
+                    socket.on('compute3', async (arg: number, cb) => {
+                        LogDebugMessage(chalk.yellow(`${clientName}: compute3`));
+                        cb({arg, clientName});
+                    });
+
+                    socket.on('ServiceCommandGetThreads', async (arg) => {
+                        LogDebugMessage(chalk.yellow(`${clientName}: ServiceCommandGetThreads: [${JSON.stringify(arg)}]`));
+                    });
+
+                    socket.on('ServiceCommandGetThreadsEx', async (arg: any, cb) => {
+                        LogDebugMessage(chalk.green(`${clientName}: ServiceCommandGetThreadsEx: [${JSON.stringify(arg)}]`));
+                        cb({arg, clientName});
+                    });
+
+                    socket.on('GetThreadDetailsFromService', async (arg: any, cb) => {
+                        LogDebugMessage(chalk.green(`${clientName}: ServiceCommandGetThreadsEx: [${JSON.stringify(arg)}]`));
+                        cb({
+                            threadData: { id: 'someid', extraData: 'someextradata' },
+                            arg, 
+                            clientName
+                        });
+                    });
+
+                },
+                (error: Error) => {
+                    LogErrorMessage(`${clientName}: SetupClientSideSocket call back: [${error}]`);
+                }
+            )
 
-        socket.emit('__STSjoinRoom', ['room1']).emit('__STSjoinRoom', ['room2']);
-    
-        socket.emit('subscribe', { data: 'subject01 '});
-        socket.emit('subscribe', { data: 'subject02 '});
+            socket.emit('__STSjoinRoom', joinRooms);
 
-        socket.emit('unsubscribe', { data: 'subject02 '});
+            socket.emit('__STSjoinRoom', ['room1']).emit('__STSjoinRoom', ['room2']);
 
-        socket.emit('subscribeKeepAlive', { data: 'ok'});
+            socket.emit('subscribe', { data: 'subject01 '});
+            socket.emit('subscribe', { data: 'subject02 '});
 
-        socket.emit('__STSsendToRoom', ['room3'], { command: 'doneAck', payload: { somedata: 1 }})
-        //socket.emit('done');
+            socket.emit('unsubscribe', { data: 'subject02 '});
 
-        socket.timeout(250).emit('compute', 10, (err, arg) => {
-            if (err) {
-                LogInfoMessage(err);
-            } else {
-                expect(arg).toEqual('20');
-            }
-        });
+            socket.emit('subscribeKeepAlive', { data: 'ok'});
 
-        socket.timeout(250).emit('compute2', 10, (err, arg) => {
-            if (err) {
-                LogInfoMessage(err);
-            } else {
-                expect(arg.data).toEqual(20);
-            }
+            socket.timeout(250).emit('compute', 10, (err, arg) => {
+                if (err) {
+                    LogInfoMessage(err);
+                } else {
+                    console.log(`${clientName}: compute: [${chalk.magenta(JSON.stringify(arg))}]`)
+                    expect(arg).toEqual('20');
+                }
+            });
+
+            socket.timeout(250).emit('compute2', 10, (err, arg) => {
+                if (err) {
+                    LogInfoMessage(err);
+                } else {
+                    console.log(`${clientName}: compute2: [${chalk.magenta(JSON.stringify(arg))}]`)
+                    expect(arg.data).toEqual(20);
+                }
+            });
+
+            return socket;
+        }
+
+        const client1 = await SetupClient('client1', [ 'service' ]);
+        const client2 = await SetupClient('client2', [ 'service', 'service_instance1' ]);
+        const client3 = await SetupClient('client3', [ 'service', 'service_instance2' ]);
+
+        await Sleep(1000);
+
+        //client1.emit('broadcast');
+
+        //client2.emit('__STSsendToRoom', ['service'], { command: 'ServiceCommandGetThreads', payload: { room: 'service', somedata: 1 }});
+
+        client2.emit('__STSsendToRoomWithCB',
+            ['service_instance1'], 
+            { command: 'ServiceCommandGetThreadsEx', payload: { room: 'service_instance1', somedata: 1 } } 
+        );
+
+        client3.emit('GetThreadDetails', {
+            room: 'service_instance1',
+            threadInput: 500
+        }, (data: JSONObject) => {
+            console.log(chalk.magenta(JSON.stringify(data)))
         });
 
-        while (!complete) {
+        const start = performance.now();
+        const promArray: Promise<JSONObject>[] = [ ];
+        for (let i=0; i < 20; i++) {
+            const prom = new Promise<JSONObject>((res, rej) => {
+                try {
+                    client1.emit('GetThreadDetails', {
+                        room: 'service',
+                        threadInput: 500,
+                        iteration: i
+                    }, (data: JSONObject) => {
+                        console.log(chalk.rgb(100, 240, 20)(JSON.stringify(data)))
+                        res(data);
+                    });
+                } catch (error) {
+                    rej(error);
+                }
+            });
+            promArray.push(prom);
+        }
+        await Promise.all(promArray);
+        const end = performance.now();
+        console.log(chalk.magenta(`Total Time: [${end-start}]`));
+
+        await Sleep(1000);
+
+        client1.emit('__STSsendToRoom', ['room3'], { command: 'doneAck', payload: { somedata: 1 }})
+
+        //while (!complete) {
+        while (doneAckCount < 3) {
             await Sleep(100);
         }
+        await Sleep(500);
+
+        console.log(chalk.green(`connectCount: [${connectCount}]`));
+        console.log(chalk.green(`subscribeAckCount: [${subscribeAckCount}]`));
+        console.log(chalk.green(`unsubscribeAckCount: [${unsubscribeAckCount}]`));
+        console.log(chalk.green(`subscribeKeepAliveAckCount: [${subscribeKeepAliveAckCount}]`));
+        console.log(chalk.green(`doneAckCount: [${doneAckCount}]`));
+
+        expect(connectCount).toEqual(3);
+        expect(subscribeAckCount).toEqual(6);
+        expect(unsubscribeAckCount).toEqual(3);
+        expect(subscribeKeepAliveAckCount).toEqual(3);
+        expect(doneAckCount).toEqual(3);
+
+        console.log(chalk.green(`All Done...`));
         
-    }, 3000);
+    }, 60000);
 });
 

package/src/vitesttesting/wsevents.ts

@@ -1,5 +1,6 @@
 /* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { STSDefaultServerToClientEvents, STSDefaultClientToServerEvents } from '@nsshunt/stsobservability'
+import { STSDefaultServerToClientEvents, STSDefaultClientToServerEvents } from '@nsshunt/stssocketioutils'
+import { JSONObject } from '@nsshunt/stsutils';
 
 // Syntax sugar from socket.io
 // https://socket.io/docs/v4/typescript/#emitting-with-a-timeout
@@ -17,6 +18,11 @@ export interface ServerToClientEvents extends STSDefaultServerToClientEvents {
     unsubscribeAck: (data: any) => void;
     subscribeKeepAliveAck: (data: any) => void;
     doneAck: () => void;
+    compute3: (arg: number, callback: (data: JSONObject) => void) => void;
+    ServiceCommandGetThreads: (data: any) => void;
+    ServiceCommandGetThreadsEx: (data: any, callback: (data: JSONObject) => void) => void;
+
+    GetThreadDetailsFromService: (data: any, callback: (data: JSONObject) => void) => void;
 }
   
 //export interface ClientToServerEvents<isSender extends boolean = false> extends STSClientToServerEvents {
@@ -30,4 +36,9 @@ export interface ClientToServerEvents extends STSDefaultClientToServerEvents {
     //compute2: (arg: number, callback: (...args: WithTimeoutAck<isSender, [{ data: any}]>) => void) => void;
     compute: (arg: number, callback: (data: string) => void) => void;
     compute2: (arg: number, callback: (data: { data: any}) => void) => void;
+    broadcast: () => void;
+
+    GetThreadDetails: (arg: JSONObject, callback: (data: JSONObject) => void) => void;
+
+    __STSsendToRoomWithCB: (rooms: string[], payload: { command: string, payload: any }) => void;
 }

package/types/commonTypes.d.ts

@@ -1,10 +1,11 @@
-import { Server, Socket, Namespace } from "socket.io";
 import express from 'express';
 import { JSONObject, ISTSLogger } from "@nsshunt/stsutils";
-import { PublishInstrumentController, InstrumentDefinitions, IContextBase, InstrumentBaseTelemetry, Gauge, STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stsobservability';
+import { PublishInstrumentController, InstrumentDefinitions, IContextBase, InstrumentBaseTelemetry, Gauge } from '@nsshunt/stsobservability';
+import { STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stssocketioutils';
 import { IDBAccessLayer } from '@nsshunt/stsdatamanagement';
 import { TinyEmitter } from "tiny-emitter";
 import { Worker, Address } from 'node:cluster';
+import { ISocketIoServerHelper } from '@nsshunt/stssocketioutils';
 export interface IServiceProcessContext extends IContextBase {
     serviceId?: string;
     serviceInstanceId?: string;
@@ -109,58 +110,6 @@ export interface IWorkerProcessBase extends IServerProcessBase {
     DeleteWorker: (workerId: string, options: any) => Promise<JSONObject>;
     GetMasterProcessOptions: () => Promise<JSONObject>;
 }
-export type ServerEventCb = (socket: any, data: any) => void;
-export interface ServerSocketEvent {
-    serverEventName: string;
-    serverEventCb: ServerEventCb;
-}
-export declare enum STSNamespace {
-    STSMonitor = "stsinstrumentmanager/stsmonitor",
-    STSControl = "stsinstrumentmanager/stscontrol"
-}
-export declare enum STSRoom {
-    STSInstrumentDataRoom = "stsinstrumentdataroom",// This room is for all instrument data messages
-    STSInstrumentDataSubscriptionRoom = "stsinstrumentdatasubscriptionroom",// This room is only for subscribed instrument data messages
-    STSRunnerRoom = "stsrunnerroom",
-    STSNodeRunnerRoom = "stsnoderunnerroom"
-}
-export declare enum STSEvent {
-    STSInstrumentData = "stsinstrumentdata",
-    STSSubInstrumentData = "stssubinstrumentdata",// sub-scribed instrument data. This only outputs the nodes that have been subscribed by the client(s).
-    STSResetInstrumentData = "stsresetinstrumentdata",
-    STSStartLoggingInstrumentData = "stsStartLoggingInstrumentData",
-    STSStopLoggingInstrumentData = "stsStopLoggingInstrumentData",
-    STSStart = "stsstart",// Start a test run with options as payload.
-    STSStop = "stsstop",// Stop test run(s).
-    STSPause = "stspause",// Pause test run(s).
-    STSResume = "stsresume",// Resume test run(s).
-    STSTerminate = "ststerminate",// Terminate runner instances and exit applications.
-    STSUpdateStaticConfig = "stsupdatestaticconfig",// Update base configuration. Options as payload.
-    STSUpdateDynamicConfig = "stsupdatedynamicconfig",// Update running configuration. This is used
-    STSSendToRoom = "sendToRoom",
-    connect = "connect"
-}
-export interface InterServerEvents {
-    ping: () => void;
-}
-export interface STSSocketIONamespace {
-    namespace: string;
-    pid: number;
-    socketionamespace: Namespace<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents, InterServerEvents>;
-}
-export type STSSocketIONamespaces = Record<string, STSSocketIONamespace>;
-export type STSServerSocket = Socket<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents, InterServerEvents>;
-export type STSClientSocket = Socket<STSDefaultServerToClientEvents, STSDefaultClientToServerEvents, InterServerEvents>;
-export interface ISocketIoServerHelper<ClientToServerEvents extends STSDefaultClientToServerEvents, ServerToClientEvents extends STSDefaultServerToClientEvents> {
-    LogMessage: (namespace: STSSocketIONamespace, message: string) => void;
-    LeaveRoom: (namespace: STSSocketIONamespace, socket: STSServerSocket, room: STSRoom) => void;
-    JoinRoom: (namespace: STSSocketIONamespace, socket: STSServerSocket, room: STSRoom) => void;
-    SetupNamespace: (io: Server, namespace: STSNamespace, rooms: string[], autoJoinRooms: boolean, socketConnectCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null, socketEventsCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null) => Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>;
-    GetSTSSocketIONamespace: (namespace: any) => STSSocketIONamespace;
-    GetSTSSocketIONamespaces: () => STSSocketIONamespaces;
-    DisconnectSockets: () => void;
-    SetupEvent(event: ClientToServerEvents, eventCb: ServerEventCb): ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>;
-}
 export declare const iss = "https://stscore.stsmda.org/oauth2/v2.0";
 export interface STSExpressServer {
     get App(): express.Express;