@nsshunt/stsappframework 3.0.94 → 3.0.95

package/src_new/serverprocessbase.ts

@@ -0,0 +1,393 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import debugModule from 'debug'
+const debug = debugModule(`proc:${process.pid}`);
+
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+import fs from "fs"
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import colors from 'colors'
+
+import { createAdapter as clusterCreateAdapter } from '@socket.io/cluster-adapter'
+import { createAdapter } from "@socket.io/redis-streams-adapter";
+
+import { JSONObject, Sleep } from '@nsshunt/stsutils'
+
+import { ProcessOptions, STSServerType } from './processoptions'
+import { ProcessBase } from './processbase';
+
+import { register, Counter, collectDefaultMetrics, AggregatorRegistry } from 'prom-client'
+
+import { createServer as createServerHttps } from 'https'
+import { createServer } from 'http'
+import tls from 'node:tls'
+import net from 'node:net'
+
+import { Server, ServerOptions } from "socket.io";
+import { STSExpressServer } from './server';
+import { Express } from 'express'
+
+import { createClient, RedisClientType } from 'redis';
+
+import jayson from 'jayson'
+
+/**
+ * todo
+ * @typedef {Object} options - todo
+ * @property {boolean} [wssServer=false] - Create a web socket server on this worker instance
+ */
+export class ServerProcessBase extends ProcessBase
+{
+    #masterProcessExitTime = goptions.masterProcessExitTime;
+    #io: Server | null = null;
+    #redisClient: RedisClientType | null = null;
+    #httpServer: any = null;
+    #expressServer: STSExpressServer | null = null;
+    #sockets: net.Socket[] = [ ];
+    #shuttingDown = false;
+
+    constructor(options: ProcessOptions) {
+        super(options);
+    }
+
+    get httpServer() {
+        return this.#httpServer;
+    }
+
+    get io() {
+        return this.#io;
+    }
+
+    get expressServer(): STSExpressServer | null {
+        return this.#expressServer;
+    }
+    set expressServer(val: STSExpressServer | null) {
+        this.#expressServer = val;
+    }
+
+    // Setup server to Prometheus scrapes:
+    #SetupPrometheusEndPoints = (expressServer: Express) => {
+        // AggregatorRegistry is required here in the worker as well as the master in order for prom-client to work correctly.
+        new AggregatorRegistry();
+
+        const prefix = 'sts_';
+
+        collectDefaultMetrics({
+            labels: { NODE_APP_INSTANCE: process.pid },
+            prefix: prefix
+        });
+
+        const c = new Counter({
+            name: 'sts_test_counter',
+            help: 'Example of a counter',
+            labelNames: ['code'],
+        });
+
+        setInterval(() => {
+            c.inc({ code: 200 });
+        }, 1000).unref();
+
+        setInterval(() => {
+            c.inc({ code: 400 });
+            c.inc({ code: 'worker_' + process.pid });
+        }, 500).unref();
+
+        expressServer.get('/metrics', async (req: any, res: any) => {
+            try {
+                res.set('Content-Type', register.contentType);
+                res.end(await register.metrics());
+            } catch (ex) {
+                res.status(500).end(ex);
+            }
+        });
+
+        expressServer.get('/metrics/counter', async (req: any, res: any) => {
+            try {
+                res.set('Content-Type', register.contentType);
+                res.end(await register.getSingleMetricAsString('test_counter'));
+            } catch (ex) {
+                res.status(500).end(ex);
+            }
+        });
+    }
+
+    #SetupTLSServer = async (socket: net.Socket): Promise<void> => {
+        // Add a 'close' event handler to this instance of socket
+        console.log('CONNECTED: ' + socket.remoteAddress + ':' + socket.remotePort + ' ' + process.pid);
+        this.#sockets.push(socket);
+
+        //const self = this;
+        socket.on('close', (data: any) => {
+            const index = this.#sockets.findIndex(function(o) {
+                return o.remoteAddress === socket.remoteAddress && o.remotePort === socket.remotePort;
+            })
+            if (index !== -1) this.#sockets.splice(index, 1);
+            console.log('CLOSED: ' + socket.remoteAddress + ' ' + socket.remotePort + ' ' + process.pid);
+        });
+
+        socket.on('data', function(data: any) {
+            console.log('DATA ' + socket.remoteAddress + ': ' + socket.remotePort + ': ' + data);
+            socket.write(socket.remoteAddress + ':' + socket.remotePort + " said " + data + '\n');
+
+            // Write the data back to all the connected, the client will receive it as data from the server
+            /*
+            self.#sockets.forEach(function(socket, index, array) {
+                socket.write(socket.remoteAddress + ':' + socket.remotePort + " said " + data + '\n');
+            });
+
+            */
+        });
+    }
+
+    #SetupRPCServer = async (socket: net.Socket): Promise<void> => {
+        console.log('CONNECTED: ' + socket.remoteAddress + ':' + socket.remotePort + ' ' + process.pid);
+
+        socket.on('close', function(data: any) {
+            console.log('CLOSED: ' + socket.remoteAddress + ' ' + socket.remotePort + ' ' + process.pid);
+        });
+
+        socket.on('data', function(data: any) {
+            console.log('DATA ' + socket.remoteAddress + ': ' + data);
+        });
+    }
+
+    #SetupWSSServer = async (): Promise<void> => {
+        // socket.io
+        // WebSocket
+        const options: Partial<ServerOptions> = {
+            transports: [ "websocket" ] // or [ "websocket", "polling" ] (to use long-poolling. Note that the order matters)
+            // The default path is /socket.io
+            // This can be changed with the path option as shown below
+            //,path: '/zzz'
+        };
+
+        //this.#io = require("socket.io")(this.#httpServer, options);
+        this.#io = new Server(this.#httpServer, options);
+
+        if (this.options.clusterMode) {
+            if (this.options.useRedisAdaptor) {
+                this.LogEx(`Using Redis for socket.io cluster management (worker)`);
+                if (this.options.redisAdaptorUrl) {
+                    this.LogEx(`Redis url: [${this.options.redisAdaptorUrl}]`);
+                    this.#redisClient = createClient({url: this.options.redisAdaptorUrl});
+                } else {
+                    this.LogEx(`Redis url: [localhost]`);
+                    this.#redisClient = createClient();
+                }
+                await this.#redisClient.connect();
+                this.#io.adapter(createAdapter(this.#redisClient) as any);
+                this.LogEx(`Redis successfully connected.`);
+            } else {
+                this.#io.adapter(clusterCreateAdapter() as any);
+                this.LogEx(`Using nodejs cluster mode for socket.io cluster management`);
+            }
+        } else {
+            this.LogEx(`Not using any adaptors for socket.io cluster management.}`);
+        }
+
+        // To use a seperate socket server, the code below can be applied.
+        // this.#io = require("socket.io")(options);
+        // this.#io.adapter(createAdapter());
+        // this.#io.listen(3006);
+        // LogEx(`socket.io init`);
+
+        this.#io.engine.on("connection_error", (err) => {
+            this.LogEx(err.req); // the request object
+            this.LogEx(err.code); // the error code, for example 1
+            this.LogEx(err.message); // the error message, for example "Session ID unknown"
+            this.LogEx(err.context); // some additional error context
+        });
+    }
+
+    #GetTLSOptions = (): JSONObject => {
+        return {
+            key: fs.readFileSync(this.options.httpsServerKeyPath),
+            cert: fs.readFileSync(this.options.httpsServerCertificatePath)
+        };
+    }
+
+    #SetupExpressServer = async (useTls: boolean): Promise<void> => {
+        if (useTls) {
+            this.#httpServer = createServerHttps(this.#GetTLSOptions(), (this.#expressServer as STSExpressServer).App);
+        } else {
+            this.#httpServer = createServer((this.#expressServer as STSExpressServer).App);
+        }
+        if (this.options.prometheusSupport === true) {
+            this.#SetupPrometheusEndPoints((this.#expressServer as STSExpressServer).App);
+        }
+        if (this.options.wssServer === true) {
+            await this.#SetupWSSServer();
+        }
+        // https://stackoverflow.com/questions/21342828/node-express-unix-domain-socket-permissions
+        //@@httpServer.listen('/tmp/stsrest01.sock').on('listening', () =>
+        //@@httpServer.listen('/var/run/sts/stsrest01.sock').on('listening', () =>
+        this.#httpServer.listen(this.options.listenPort, () => { 
+            //@@chmodSync(this.options.port, 511);
+        }).on('listening', () =>
+        {
+            this.LogEx(`live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+        });
+    }
+
+    #SetupTCPRawServer = async (): Promise<void> => {
+        // The second parameter is the automatic listener for the secureConnection event from the tls.Server class
+        this.#httpServer = tls.createServer(this.#GetTLSOptions(), this.#SetupTLSServer);
+        this.#httpServer.listen(this.options.listenPort, 'stscore.stsmda.org', () => { 
+            console.log('TCP Server is running on port ' + this.options.listenPort + '.');
+        }).on('listening', () =>
+        {
+            this.LogEx(`TCP live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+        });
+    }
+
+    #SetupJSONRPCServer = async (): Promise<void> => {
+        const jaysonServer = new jayson.server();
+        // Supported methods here - move somewhere else ...
+        jaysonServer.method("add", function(args: any, callback: any) {
+            callback(null, args[0] + args[1]);
+        });
+        this.#httpServer = jaysonServer.tls(this.#GetTLSOptions());
+        (this.#httpServer as tls.Server).on('secureConnection', this.#SetupRPCServer);
+        this.#httpServer.listen(this.options.listenPort, 'stscore.stsmda.org', () => { 
+            console.log('JSON RPC 2.0 Server is running on port ' + this.options.listenPort + '.');
+        }).on('listening', () =>
+        {
+            this.LogEx(`JSON RPC 2.0 live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
+        });
+    }
+
+    ProcessTerminating = async (): Promise<void> => {
+        return;
+    }
+
+    override get shuttingDown(): boolean {
+        return this.#shuttingDown;
+    }
+
+    // Terminate in order;
+    // forked worker threads (send signal)
+    // De-Register service
+    // systeminformation observers
+    // instrument timers (gauge etc.)
+    // publisher
+    // terminate UI (if loaded)
+    Terminate = async (clusterPerformExit: boolean, signal?: any): Promise<void> => {
+        if (this.#shuttingDown === false) {
+            this.#shuttingDown = true;
+
+            await this.ProcessTerminate();
+
+            await this.ProcessTerminating();
+
+            if (!this.options.clusterMode) {
+                if (this.GetUIController() !== null)
+                {
+                    this.LogEx('Destroy the user interface controller.');
+                    this.GetUIController().DestroyUI();
+                }
+        
+                if (signal) {
+                    this.LogEx(this.GetSignalColour(signal)(`Main Process (singleprocess): ${process.pid} received signal: ${signal}`));
+                } else {
+                    this.LogEx(this.GetSignalColour(null)(`Main Process (singleprocess): ${process.pid} received Terminate without signal.`));
+                }
+            }
+
+            if (this.options.wssServer === true && this.#io !== null)
+            {
+                this.LogEx(`Disconnect Sockets.`);
+                if (this.socketIoServerHelper !== null) {
+                    this.socketIoServerHelper.DisconnectSockets();
+                } else {
+                    this.#io.disconnectSockets();
+                }
+                this.socketIoServerHelper = null;
+                this.#io = null;
+                // Note that this.#redisClient.disconnect() is not required becuase DisconnectSockets performs this action.
+            }
+
+            if (this.#httpServer) {
+                if (this.options.serverType === STSServerType.TCPRAW_TLS) {
+                    this.#sockets.forEach((socket: net.Socket, index, array) => {
+                        this.LogEx(`TCP Socket destroy, remote address: [${socket.remoteAddress}], remote port: [${socket.remotePort}]`.yellow);
+                        socket.destroy();
+                        //socket.end();
+                    });
+                }
+                this.LogEx(`Closing httpServer.`);
+                await this.#httpServer.close();
+            }
+            
+            if (this.options.useDatabase) {
+                this.LogEx(`Ending database connections and pools.`);
+                await this.TerminateDatabase();
+                //await this.accessLayer.enddatabase();
+            }
+
+            if (this.options.clusterMode) {
+                this.LogEx(`Performing exit value: [${clusterPerformExit}]`);
+                if (clusterPerformExit) {
+                    this.LogEx(`Process will self terminate with process.exit(0).`);
+                } else {
+                    this.LogEx(`Child process will not self terminate. Terminate will be handled by master process.`);
+                }
+            }
+
+            //if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
+            if (this.InstrumentController) {
+                this.LogEx(`Ending publisher.`);
+                setTimeout(() => {
+                    //if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
+                    if (this.InstrumentController) {
+                        this.InstrumentController.InstrumentTerminate();
+                    }
+                }, 100);
+            }
+
+            //@@ always return here appears to always cleanly exit
+            // and cleanly exit from socket.io cluster adaptor
+            // without return here, socket.io cluster adaptor terminates in an error state
+            // as the implementation relies on cluster.on to send messages to worker threads
+            // but these have already been closed from the process.exit(0) below.
+
+            await Sleep(1000); // Allow socket.io time to clean-up
+
+            if (this.options.clusterMode) {
+                if (clusterPerformExit) {
+                    setTimeout(() => {
+                        process.exit(0);
+                    }, 0);
+                } 
+            } else {
+                if (this.options.processExitOnTerminate && this.options.processExitOnTerminate === true) {
+                    setTimeout(() => {
+                        this.LogEx(`Performing process.exit(0).`);
+                        process.exit(0);
+                    }, this.#masterProcessExitTime); // Give the workers time to terminate gracefully
+                } else {
+                    this.LogEx(`Performing process.exit(0) - Immediate.`);
+                }
+            }
+        } else {
+            this.LogEx(`Process already terminating.`);
+        }
+    }
+
+    SetupSTSServer = async(): Promise<void> => {
+        switch (this.options.serverType) {
+        case STSServerType.EXPRESS :
+            await this.#SetupExpressServer(false);
+            break;
+        case STSServerType.EXPRESS_TLS :
+            await this.#SetupExpressServer(true);
+            break;
+        case STSServerType.TCPRAW_TLS :
+            await this.#SetupTCPRawServer();
+            break;
+        case STSServerType.JSONRPC2_TLS :
+            await this.#SetupJSONRPCServer();
+            break;
+        }
+    }
+}

package/src_new/singleprocessbase.ts

@@ -0,0 +1,123 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+import chalk from 'chalk';
+
+import { Gauge, GaugeTypes, InstrumentGaugeOptions, InstrumentGaugeTelemetry } from '@nsshunt/stsinstrumentation'
+
+import { ProcessOptions } from './processoptions'
+import { ISingleProcessBase } from './commonTypes';
+import { InstrumentDefinitions } from '@nsshunt/stspublisherserver'
+import { STSExpressServer } from './server'
+import { ServerProcessBase } from './serverprocessbase'
+
+import si from 'systeminformation' // https://systeminformation.io/
+
+export type EventCb = (socket: any, data: any) => void
+
+export class SingleProcessBase extends ServerProcessBase implements ISingleProcessBase
+{
+    /**
+	 * 
+	 * @param {SingleProcessBaseOptions} options 
+	 */
+    constructor(options: ProcessOptions) {
+        super(options)
+    }
+
+    override CollectAdditionalTelemetry(): void {
+        const siValueObject = {
+            currentLoad: 'currentLoad'
+        }
+        si.get(siValueObject).then(data => {
+            this.UpdateInstrument(Gauge.CPU_SYSTEM_LOAD_GAUGE, {
+                val: data.currentLoad.currentLoad
+            } as InstrumentGaugeTelemetry);
+        });
+    }
+
+    override GetAdditionalInstruments(): InstrumentDefinitions {
+        return [
+            [ Gauge.CPU_SYSTEM_LOAD_GAUGE, GaugeTypes.INSTRUMENT_GAUGE, {
+                interval: goptions.instrumentationObservationInterval, 
+                sampleSize: goptions.instrumentationTimeWindow
+            } as InstrumentGaugeOptions]
+        ]
+    }
+
+    /**
+	 * UIController (instance of UIController) to manage a console based user interface associated for this node application.
+	 * @returns UIController instance to manage a console based user interface associated for this node application. Null for no capability.
+	 */
+    override GetUIController(): any {
+        return null;
+    }
+
+    ProcessStarted() {
+        return null;
+    }
+
+    SetupServer(): Promise<boolean>
+    {
+        return new Promise((resolve, reject) => {
+            try {
+                this.SetupInstrumentation();
+                setTimeout(async () => {
+                    try {
+                        await this.SetupServerEx();
+                        resolve(true);
+                    } catch (error) {
+                        reject(error);
+                    }
+                }, 100);
+            } catch (error) {
+                reject(error);
+            }
+        })
+    }
+
+    SetupServerEx = async () => {
+        this.ProcessStartup();
+
+        if (this.options.expressServerRouteFactory || this.options.expressServerRouteStaticFactory) {
+            this.expressServer = new STSExpressServer(this.options, this);
+        }
+
+        this.LogEx(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
+        this.LogEx(`Master process:${process.pid} started`);
+
+        this.LogSystemTelemetry();
+
+        process.on('SIGINT', async () => {
+            await this.Terminate(false, 'SIGINT');
+        });
+
+        process.on('SIGTERM', async () => {
+            await this.Terminate(false, 'SIGTERM');
+        });
+
+        process.on('exit', (code) => {
+            if (code === 0) {
+                this.LogEx(chalk.green(`Main Process: ${process.pid} terminated gracefully with code: ${code}`));
+            } else {
+                this.LogEx(chalk.red(`Main Process: ${process.pid} terminated with code: ${code}`));
+            }
+        });
+
+        await this.SetupSTSServer();
+
+        this.ProcessStarted();
+
+        this.LogEx(chalk.green(`Main process:${process.pid} started`));
+    }
+
+    async TerminateApplication()
+    {
+        await this.Terminate(false, 'SIGINT');
+    }
+
+    override ProcessTerminating = async (): Promise<void> => {
+        return;
+    }
+}

package/src_new/socketIoServerHelper.ts

@@ -0,0 +1,177 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import Debug from "debug";
+const debug = Debug(`proc:${process.pid}:socketiohelper`);
+
+import { JSONObject } from '@nsshunt/stsutils'
+
+import { Server, Namespace, Socket } from "socket.io";
+
+import { STSSocketIONamespace, STSServerSocket, STSNamespace, 
+    ISocketIoServerHelper, ServerEventCb, InterServerEvents } from './commonTypes'
+
+import { STSDefaultClientToServerEvents, STSDefaultServerToClientEvents } from '@nsshunt/stssocketio-client'
+
+export interface ISocketIoServerHelperOptions
+{
+    logger: (message: string) => void;
+}
+
+export class SocketIoServerHelper<ClientToServerEvents extends STSDefaultClientToServerEvents, ServerToClientEvents extends STSDefaultServerToClientEvents> implements ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents>
+{
+    #socketIoServerHelperOptions: ISocketIoServerHelperOptions
+
+    constructor(options: ISocketIoServerHelperOptions) { // IProcessBase
+        this.#socketIoServerHelperOptions = options;
+    }
+
+    #namespace: Record<string, STSSocketIONamespace> = { };
+
+    LogMessage = (namespace: STSSocketIONamespace, message: string): void => {
+
+        this.#socketIoServerHelperOptions.logger(`${namespace.namespace}: ${message}`);
+        /*
+        this.#stsApp.UpdateInstrument(Gauge.LOGGER, {
+            LogMessage: message
+        } as InstrumentLogTelemetry);
+        */
+    };
+
+    LeaveRoom = (namespace: STSSocketIONamespace, socket: Socket<ClientToServerEvents, ServerToClientEvents>, room: string): void => {
+        const logMessage = `${namespace.socketionamespace.name}: Leaving room [${room}]`;
+        debug(logMessage);
+        this.LogMessage(namespace, logMessage);
+        socket.leave(room);
+    };
+
+    JoinRoom = (namespace: STSSocketIONamespace, socket: Socket<ClientToServerEvents, ServerToClientEvents>, room: string): void => {
+        const logMessage = `${namespace.socketionamespace.name}: Socket joining room [${room}], ID: [${socket.id}]`;
+        debug(logMessage);
+        this.LogMessage(namespace, logMessage);
+        socket.join(room);
+    };
+
+    #SetupStandardEvents = (namespace: STSSocketIONamespace, socket: Socket<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents>): void => {
+        socket.on("__STSdisconnect", (reason) => {
+            debug(`${namespace.socketionamespace.name}: socket disconnect, ID: [${socket.id}] [${reason}]`);
+        });
+
+        socket.on("__STSdisconnecting", (reason, callBackResult) => {
+            debug(`${namespace.socketionamespace.name}: socket disconnecting, ID: [${socket.id}] [${reason}]`);
+            callBackResult("__STSdisconnecting accepted by server.");
+        });
+
+        socket.on('__STSjoinRoom', (rooms: string[]): void => { //@@ names
+            rooms.forEach((room) => {
+                const logMessage = `${namespace.socketionamespace.name}:socket.on:joinRoom: Socket joining room [${room}], ID: [${socket.id}]`;
+                debug(logMessage);
+                this.JoinRoom(namespace, socket, room)
+            });
+        });
+
+        socket.on('__STSleaveRoom', (rooms: string[]): void => { //@@ names
+            rooms.forEach((room) => {
+                const logMessage = `${namespace.socketionamespace.name}:socket.on:joinRoom: Socket leaving room [${room}], ID: [${socket.id}]`;
+                debug(logMessage);
+                this.LeaveRoom(namespace, socket, room);
+            });
+        });
+
+        socket.on('__STSsendToRoom', (rooms: string[], payload: { command: string, payload: JSONObject }): void => {
+            rooms.forEach((room) => {
+                const logMessage = `${namespace.socketionamespace.name}:socket.on:sendToRoom: Sending to room [${room}], ID: [${socket.id}]`;
+                debug(logMessage);
+                // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+                namespace.socketionamespace.to(room).emit(payload.command as any, payload);
+            });
+        });
+    }
+
+    // Use this middleward to check every incomming connection
+    #SetupConnectionMiddleware = (nameSpace: STSSocketIONamespace) => {
+        nameSpace.socketionamespace.use((socket, next) => {
+            //console.log(JSON.stringify(socket));
+            //console.log(JSON.stringify(socket.handshake.auth));
+            //console.log(JSON.stringify(socket.handshake.headers));
+            //if (isValid(socket.request)) {
+            const a=5; // for lint purposes
+            if (a === 5) {
+                next();
+            } else {
+                next(new Error("invalid"));
+            }
+        });
+    }
+
+    // Use this middleware to check very packet being received
+    #SetupMessageMiddleware = (socket: STSServerSocket) => {
+        socket.use(([event, ...args], next) => {
+            //console.log(JSON.stringify(event));
+            //console.log(JSON.stringify(args));
+            /*
+            if (isUnauthorized(event)) {
+                return next(new Error("unauthorized event"));
+            }
+            */
+            next();
+        });
+    }
+    
+    SetupNamespace = (io: Server, namespace: STSNamespace, rooms: string[], autoJoinRooms: boolean, /* serverSocketEvents: ServerSocketEvent[], */
+        socketConnectCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null,
+        socketEventsCallBack: ((socket: Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents>) => void) | null
+    ): Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents> => {
+        // Create STS Command Centre Client namespace
+        this.#namespace[namespace] = {
+            namespace: namespace,
+            pid: process.pid,
+            socketionamespace: io.of(`/${namespace}/`)
+        }
+
+        this.#SetupConnectionMiddleware(this.#namespace[namespace]);
+
+        this.#namespace[namespace].socketionamespace.on("connection", socket => {
+            const logMessage = `${namespace}: Socket connected, ID: [${socket.id}]`;
+            debug(logMessage);
+            this.LogMessage(this.#namespace[namespace], logMessage);
+            debug(`${namespace}: Auth: [${JSON.stringify(socket.handshake.auth)}]`);
+
+            this.#SetupMessageMiddleware(socket);
+
+            if (autoJoinRooms) {
+                rooms.map((room) => {
+                    this.JoinRoom(this.#namespace[namespace], socket, room);
+                });
+            }
+
+            this.#SetupStandardEvents(this.#namespace[namespace], socket);
+
+            if (socketConnectCallBack) {
+                setTimeout(() => {
+                    socketConnectCallBack(socket);
+                }, 0);
+            }
+
+            if (socketEventsCallBack) {
+                socketEventsCallBack(socket);
+            }
+        });
+
+        return this.#namespace[namespace].socketionamespace as Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>;
+    }
+
+    GetSTSSocketIONamespace = (namespace: string): STSSocketIONamespace => {
+        return this.#namespace[namespace];
+    }
+
+    DisconnectSockets = (): void =>
+    {
+        for (const [, namespace] of Object.entries(this.#namespace)) {
+            namespace.socketionamespace.disconnectSockets();
+        }
+        this.#namespace = { };
+    }
+
+    SetupEvent(event: ClientToServerEvents, eventCb: ServerEventCb): ISocketIoServerHelper<ClientToServerEvents, ServerToClientEvents> {
+        return this as any;
+    }
+}