@nsshunt/stsappframework 3.1.241 → 3.2.1

package/src/vitesttesting/appSingleWSS.ts

@@ -0,0 +1,142 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import chalk from 'chalk';
+
+import { SingleProcessBase, ProcessOptions } from './../index'
+import { SocketIoServerHelper, STSNamespace, STSRoom, InterServerEvents } from '@nsshunt/stssocketioutils'
+
+import { Namespace, Socket } from "socket.io";
+
+import { ClientToServerEvents, ServerToClientEvents } from './wsevents'
+import { JSONObject } from '@nsshunt/stsutils';
+
+export class AppSingleWSS extends SingleProcessBase
+{
+    constructor(options: ProcessOptions) {
+        super(options);
+    }
+
+    #LogInfoMessage(message: any) {
+        this.options.logger.info(message);
+    }
+
+    #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))}]`)
+                                }
+                            });
+                        }
+                    });
+                });
+
+                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);
+        */
+
+        this.#SetupWSSServer(STSNamespace.STSMonitor);
+        //this.#SetupWSSServer('stsinstrumentmanager/stsmonitor' as any);
+    }
+}

package/src/vitesttesting/server.ts

@@ -0,0 +1,17 @@
+import express from 'express';
+
+import { STSLatencyRoute, IProcessBase } from './..'
+
+import { goptions } from '@nsshunt/stsconfig'
+
+export class STSExpressRouteFactory
+{
+    constructor(app: express.Express, stsApp: IProcessBase)
+    {
+        const stslatency = new STSLatencyRoute(stsApp);
+
+        // Note: This MUST come first as the latency end point is on the same path as the reosurce path.
+        // If stsresourceRouter came first, it would think that /latency was a resource name.
+        app.use(`${goptions.rest01apiroot}`, stslatency.router);
+    }
+}

package/src/vitesttesting/singleservertest.test.ts

@@ -0,0 +1,352 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import chalk from 'chalk';
+
+import axios, { AxiosError, AxiosResponse } from 'axios';
+
+import { JSONObject, Sleep } from '@nsshunt/stsutils'
+//import { SingleProcessBase, MasterProcessBase } from './..'
+
+import { AppSingleWSS } from './appSingleWSS'
+
+import { ServiceConfigOptions } from './appConfig'
+
+import { goptions, $ResetOptions, STSAxiosConfig, AgentManager } from '@nsshunt/stsconfig'
+
+import { beforeAll, afterAll, test, describe, expect } from 'vitest';
+
+import { SocketIoClientHelper, ISocketIoClientHelperOptions } from '@nsshunt/stssocketioutils'
+
+import { STSNamespace } from '@nsshunt/stssocketioutils'
+
+import { ServerToClientEvents, ClientToServerEvents } from './wsevents'
+import { Socket } from 'socket.io-client'
+
+//import { GenericContainer, Network, Wait } 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'
+
+    const socketUtilsoptions: ISocketIoClientHelperOptions = {
+        agentOptions: {
+            keepAlive: goptions.keepAlive,
+            maxSockets: goptions.maxSockets,
+            maxTotalSockets: goptions.maxTotalSockets,
+            maxFreeSockets: goptions.maxFreeSockets,
+            timeout: 30000, //@@ config
+            rejectUnauthorized: goptions.isProduction // Allows self signed certs in non production mode(s)
+        }
+    }
+
+    const socketUtils = new SocketIoClientHelper<ServerToClientEvents, ClientToServerEvents>(socketUtilsoptions);
+
+    const instrumentManagerAddress = 
+        `${endpoint}:${goptions.rest01port}/${STSNamespace.STSMonitor}/`;
+
+    const LogInfoMessage = (message: any) => console.log(chalk.green(`info: ${message}`));
+    const LogErrorMessage = (message: any) => console.error(chalk.red(`error: ${message}`));
+    const LogDebugMessage = (message: any) => console.log(chalk.blue(`debug: ${message}`));
+
+    const HandleError = (error: any) => {
+        LogDebugMessage(chalk.red(`HandleError(): Error: [${error}]`));
+        if (axios.isAxiosError(error)) {
+            const axiosError: AxiosError = error;
+            if (axiosError.response) {
+                LogDebugMessage(chalk.red(`AXIOS Error Response.Status = [${axiosError.response.status}]`));
+                if (axiosError.response.headers) {
+                    LogInfoMessage(chalk.red(`  headers: [${JSON.stringify(axiosError.response.headers)}]`));
+                }
+                if (axiosError.response.data) {
+                    LogInfoMessage(chalk.red(`  data: [${JSON.stringify(axiosError.response.data)}]`));
+                }
+                try {
+                    if (axiosError.response.config) {
+                        LogInfoMessage(chalk.red(`  config: [${JSON.stringify(axiosError.response.config)}]`));
+                    }
+                } catch (innererror: any) {
+                    LogInfoMessage(chalk.red(`  could not get response config, error: [${innererror}]`));
+                }
+            } else {
+                LogDebugMessage(chalk.red(`HandleError(): AXIOS Error = [${axiosError}]`));
+            }
+        }
+    }
+
+    const getLatency = async (): Promise<AxiosResponse | null> => {
+        const url = `${endpoint}:${goptions.rest01port}${goptions.rest01apiroot}/latency`;
+        try {
+            const retVal = await axios(new STSAxiosConfig(url, 'get')
+                .withDefaultHeaders()
+                .withAgentManager(agentManager).config);
+            return retVal;
+        } catch (error: any) {
+            HandleError(error);
+            return null;
+        }
+    }
+
+    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(network)
+            .withNetworkAliases("redisstackserver")
+            //.withWaitStrategy(Wait.forLogMessage(`Ready to accept connections tcp`))
+            .start();
+
+        ioRedisMessageProcessorUrl = `redis://${ioRedisContainer.getHost()}:${ioRedisContainer.getMappedPort(6379)}`;            
+
+        await Sleep(2000);
+        //expect(goptions.imRedisMessageProcessorUrl).toEqual('redis://localhost:6379');
+        // IM_REDIS_MESSAGE_PROCESSOR_URL
+
+        console.log(chalk.green(`redis/redis-stack-server Started. docker  [${ioRedisMessageProcessorUrl}]`));
+    }
+
+    const StopRedis = async () => {
+        await ioRedisContainer.stop();
+        await Sleep(200);
+    }
+
+    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);
+        appOptions.processExitOnTerminate = false;
+        app = new AppSingleWSS(appOptions)
+        await app.SetupServer();
+        await Sleep(3000);
+    }, 120000);
+    
+    afterAll(async () => {
+        agentManager.Terminate();
+        await Sleep(500);
+        await app?.TerminateApplication();
+
+        await Sleep(2000);
+
+        app = null;
+
+        await StopRedis();
+        await StopNetwork();
+
+        await Sleep(2000);
+    }, 120000);
+
+    test('Testing Module', async () => {
+        expect.assertions(1);
+        expect(1).toEqual(1);
+    });
+
+    test('GET /latency', async () => {
+        const num = 50;
+        expect.assertions(num * 2);
+        for (let i=0; i < num; i++) {
+            const retVal = await getLatency();
+            const retValObj = retVal?.data.data;
+            expect(retValObj).toMatch('Ping Completed At:');
+            expect(retVal && retVal.status).toEqual(200);
+        }
+    }, 10000);
+
+    test('client socket testing', async () => {
+        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);
+                },
+                // 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', joinRooms);
+
+            socket.emit('__STSjoinRoom', ['room1']).emit('__STSjoinRoom', ['room2']);
+
+            socket.emit('subscribe', { data: 'subject01 '});
+            socket.emit('subscribe', { data: 'subject02 '});
+
+            socket.emit('unsubscribe', { data: 'subject02 '});
+
+            socket.emit('subscribeKeepAlive', { data: 'ok'});
+
+            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)))
+        });
+
+        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...`));
+        
+    }, 60000);
+});
+

package/src/vitesttesting/wsevents.ts

@@ -0,0 +1,44 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+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
+//type WithTimeoutAck<isSender extends boolean, args extends any[]> = isSender extends true ? [Error, ...args] : args;
+
+//export interface ServerToClientEvents<isSender extends boolean = false> extends STSServerToClientEvents {
+export interface ServerToClientEvents extends STSDefaultServerToClientEvents {
+        /*
+    noArg: () => void;
+    basicEmit: (a: number, b: string, c: Buffer) => void;
+    withAck: (d: string, callback: (e: number) => void) => void;
+    */
+
+    subscribeAck: (data: any) => void;
+    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 {
+export interface ClientToServerEvents extends STSDefaultClientToServerEvents {
+    subscribe: (data: any) => void;
+    unsubscribe: (data: any) => void;
+    subscribeKeepAlive: (data: any) => void;
+    done: () => void;
+
+    //compute: (arg: number, callback: (...args: WithTimeoutAck<isSender, [string]>) => void) => void;
+    //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/tsconfig.json

@@ -0,0 +1,42 @@
+{
+    "extends": "@tsconfig/node20/tsconfig.json",
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "**/node_modules/**/*", "**/*.spec.ts"],
+    "compilerOptions": {
+        // sts custom compiler options
+        "sourceMap": true,
+        "outDir": "dist",
+        "declaration": true,
+        "declarationDir": "./types",
+        "declarationMap": true,
+
+        "module": "commonjs",
+        //"module": "ES2022",
+        "moduleResolution": "node"
+        //"isolatedModules": true,
+        //"allowSyntheticDefaultImports": true
+        //"types": ["vite/client", "node"],
+        //"resolveJsonModule": true,
+        //"allowJs": true,
+
+        // The following are from :- @tsconfig/node20/tsconfig.json
+        //"lib": ["es2023"],
+        //"module": "commonjs",
+        //"target": "es2022",
+        //"strict": true,
+        //"esModuleInterop": true,
+        //"skipLibCheck": true,
+        //"forceConsistentCasingInFileNames": true,
+        //"moduleResolution": "node"
+    
+        // The following where from previous sts builds ( <= 1.15.45 )
+        //"lib": ["DOM", "DOM.Iterable", "ES2021", "ESNext"],
+        //"module": "ESNext",
+        //"target": "ESNext",
+        //"strict": true,
+        //"esModuleInterop": false,
+        //"skipLibCheck": true,
+        //"forceConsistentCasingInFileNames": true,
+        //"moduleResolution": "node"
+    }
+}