@nsshunt/stsappframework 3.2.1 → 3.2.2

package/src/process/singleprocessbase.ts

@@ -1,63 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { goptions } from '@nsshunt/stsconfig'
-
-import { Gauge, GaugeTypes, InstrumentGaugeOptions, InstrumentGaugeTelemetry } from '@nsshunt/stsobservability'
-
-import { ISingleProcessBase, ProcessOptions } from './../commonTypes';
-import { InstrumentDefinitions } from '@nsshunt/stsobservability'
-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;
-    }
-
-    override SetupServerEx = async (): Promise<boolean> => {
-        await super.SetupServerEx();
-
-        this.LogSystemTelemetry();
-
-        return true;
-    }
-
-    async TerminateApplication() {
-        await this.Terminate(false, 'SIGINT');
-    }
-}

package/src/route/stslatencyroute.ts

@@ -1,15 +0,0 @@
-import { STSRouterBase } from './stsrouterbase'
-import { STSLatencyController } from './../controller/stslatencycontroller'
-import { IProcessBase } from './../commonTypes'
-
-export class STSLatencyRoute extends STSRouterBase {
-    constructor(stsApp: IProcessBase)
-    {
-        super(stsApp);
-
-        const latencyController = new STSLatencyController(stsApp);
-        const { stslatency } = latencyController;
-
-        this.router.get('/latency', stslatency.bind(latencyController)); // Create new test
-    }
-}

package/src/route/stsrouterbase.ts

@@ -1,21 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
-import { Router } from 'express';
-import { IProcessBase } from './../commonTypes';
-
-export abstract class STSRouterBase {
-    #router: Router;
-    #stsApp: any;
-
-    constructor(stsApp: IProcessBase) {
-        this.#stsApp = stsApp;
-        this.#router = Router();
-    }
-
-    get router(): Router {
-        return this.#router;
-    }
-
-    get stsApp(): IProcessBase {
-        return this.#stsApp
-    }
-}

package/src/stsexpressserver.ts

@@ -1,137 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import express, { Express, Request, Response, NextFunction } from 'express';
-
-import cors from 'cors';
-import cookieParser from 'cookie-parser';
-
-import { RequestLoggerMiddleware, RequestLoggerMiddlewareEventName } from '@nsshunt/stsobservability'
-
-import { goptions } from '@nsshunt/stsconfig'
-
-import { IProcessBase, ProcessOptions } from './commonTypes'
-import { Gauge, InstrumentGaugeTelemetry, InstrumentHistogramTelemetry, InstrumentVelocityTelemetry } from '@nsshunt/stsobservability'
-
-import { ISocketRecord, ServerNetworkMiddleware, ServerNetworkMiddlewareEventName } from './middleware/serverNetworkMiddleware'
-
-export class STSExpressServer {
-    #app: Express;
-
-    constructor(options: ProcessOptions, stsApp: IProcessBase)
-    {
-        // Standard RequestLoggerMiddleware for all STS services
-        const requestLoggerMiddleware = new RequestLoggerMiddleware({ 
-            ignoresocketio: goptions.ignoresocketio 
-        });
-
-        const serverNetworkMiddleware = new ServerNetworkMiddleware({ 
-            name: (stsApp.options as ProcessOptions).serviceName,
-            outputDebug: false,
-            logger: stsApp.options?.logger
-        });
-
-        serverNetworkMiddleware.on(ServerNetworkMiddlewareEventName.UpdateInstrument_SERVER_NET_VAL, (data: ISocketRecord) => {
-            //this.#LogInfoMessage(chalk.magenta(`serverNetworkMiddleware: [${JSON.stringify(data)}]`));
-            stsApp.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
-                Inc: data.requestBytesRead
-            } as InstrumentGaugeTelemetry);
-
-            stsApp.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
-                Inc: data.requestBytesWritten
-            } as InstrumentGaugeTelemetry);
-        });
-
-        requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_AR_INC, () => {
-            stsApp.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
-                Inc: 1
-            } as InstrumentGaugeTelemetry);
-        });
-
-        requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_AR_DEC, () => {
-            stsApp.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
-                Dec: 1
-            } as InstrumentGaugeTelemetry);
-        });
-
-        requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_DH_VAL, (timeInMs) => {
-            stsApp.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
-                val: timeInMs
-            } as InstrumentHistogramTelemetry);
-        });
-
-        requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_D_VAL, (timeInMs) => {
-            stsApp.UpdateInstrument(Gauge.DURATION_GAUGE, {
-                val: timeInMs
-            } as InstrumentHistogramTelemetry);
-        });
-
-        requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_RC_INC, () => {
-            stsApp.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
-                Inc: 1
-            } as InstrumentGaugeTelemetry);
-        });
-
-        requestLoggerMiddleware.on(RequestLoggerMiddlewareEventName.UpdateInstrument_V_INC, () => {
-            if (stsApp.InstrumentExists(Gauge.VELOCITY_GAUGE)) {
-                stsApp.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
-                    Inc: 1
-                } as InstrumentVelocityTelemetry);
-            }
-        });
-
-        const app = express();
-        this.#app = app;
-
-        // https://stackoverflow.com/questions/19743396/cors-cannot-use-wildcard-in-access-control-allow-origin-when-credentials-flag-i
-        // See answer from Christoph Hansen is thread above ...
-        // https://expressjs.com/en/resources/middleware/cors.html
-        const corsConfig = {
-            credentials: true,
-            origin: true,
-        };
-
-        app.use(cors(corsConfig));
-
-        app.use(cookieParser())
-
-        app.use(express.urlencoded({ extended: false, limit: goptions.maxPayloadSize }));
-		
-        app.use(express.json({limit: goptions.maxPayloadSize}));
-
-        // Allow the static SPA to also be servered by this app
-        //app.use('/static', express.static(path.join(__dirname, 'public')))
-        if (options.expressServerRouteStaticFactory) {
-            options.expressServerRouteStaticFactory(app, stsApp);
-        }
-
-        app.use(requestLoggerMiddleware.Middleware.bind(requestLoggerMiddleware));
-
-        app.use(serverNetworkMiddleware.Middleware.bind(serverNetworkMiddleware));
-
-        if (options.expressServerRouteFactory) {
-            options.expressServerRouteFactory(app, stsApp);
-        }
-
-        // Express error handling fall-back
-        app.use(function(err: any, req: Request, res: Response, next: NextFunction) {
-            //@@ add to errors metric here - perhaps break down by type
-
-            if (err) {
-                //@@this.#LogInfoMessage(err);
-                res.status(err.status).send(err);
-            } else {
-                next();
-            }
-            /*
-			if(err.name === 'UnauthorizedError') {
-				res.status(401).send(err);
-			} else {
-				next();
-			}
-			*/
-        });
-    }
-
-    get App(): Express {
-        return this.#app;
-    }
-}

package/src/validation/errors.ts

@@ -1,6 +0,0 @@
-export const AppFrameworkErrorCode = Object.freeze({
-    APPFRAMEWORK_MISSING_PERMISSION: {
-        code: 'STS_AF_0001',
-        description: 'STS_AF_0001: Missing Permission(s).'
-    },
-});

package/src/vitesttesting/appConfig.ts

@@ -1,111 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import express from 'express';
-
-import { goptions } from '@nsshunt/stsconfig'
-
-import { ProcessOptions, IProcessBase } 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 = {
-            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: false,  //@@
-            instrumentLogging: true,
-
-            instrumentationObservationInterval: goptions.instrumentationObservationInterval,
-            instrumentationTimeWindow: goptions.instrumentationTimeWindow,
-
-            useSocketIoRedisAdaptor: true,
-            socketIoRedisAdaptorUrl: goptions.socketIoRedisAdaptorUrl,
-            //socketIoRedisAdaptorUrl: 'redis://192.168.50.5:6379',
-            //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;
-    }
-}

package/src/vitesttesting/appSingleWSS.ts

@@ -1,142 +0,0 @@
-/* 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

@@ -1,17 +0,0 @@
-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);
-    }
-}