@nsshunt/stsappframework 2.19.205 → 2.19.206

package/src/singleprocessbase.ts

@@ -18,7 +18,7 @@ const goptions = $Options()
 
 import { Gauge, GaugeTypes, InstrumentGaugeOptions, InstrumentGaugeTelemetry } from '@nsshunt/stsinstrumentation'
 
-import { ProcessOptions } from './processoptions'
+import { ProcessOptions, STSServerType } from './processoptions'
 import { ProcessBase } from './processbase';
 import { ISingleProcessBase } from './commonTypes';
 
@@ -32,9 +32,11 @@ import { createAdapter } from "@socket.io/redis-streams-adapter";
 
 import { createClient, RedisClientType } from 'redis';
 
+import { ServerProcessBase } from './serverprocessbase'
+
 export type EventCb = (socket: any, data: any) => void
 
-export class SingleProcessBase extends ProcessBase implements ISingleProcessBase
+export class SingleProcessBase extends ServerProcessBase implements ISingleProcessBase
 {
     #masterProcessExitTime = goptions.masterProcessExitTime;
     #io: any = null;
@@ -90,18 +92,6 @@ export class SingleProcessBase extends ProcessBase implements ISingleProcessBase
         return null;
     }
 
-    get io() {
-        return this.#io;
-    }
-
-    ProcessTerminating() {
-        return null;
-    }
-
-    get expressServer() {
-        return this.#expressServer;
-    }
-
     SetupServer(): Promise<boolean>
     {
         return new Promise((resolve, reject) => {
@@ -121,16 +111,6 @@ export class SingleProcessBase extends ProcessBase implements ISingleProcessBase
         })
     }
 
-    /*
-	SetupServer = async () =>
-	{
-		this.SetupInstrumentation();
-		setTimeout(() => {
-			this.SetupServerEx();
-		}, 100);
-	}
-	*/
-
     SetupServerEx = async () => {
         this.ProcessStartup();
 
@@ -138,251 +118,37 @@ export class SingleProcessBase extends ProcessBase implements ISingleProcessBase
             this.#expressServer = new STSExpressServer(this.options, this);
         }
 
-        const LogEx = this.LogEx;
-
-        /*
-		if (this.instruments !== null) {
-			this.instruments[Gauge.LOGGER].consoleLogging = this.options.consoleLogging;
-			this.instruments[Gauge.LOGGER].instrumentLogging = this.options.instrumentLogging;
-		}
-		*/
-
-        LogEx(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
-        LogEx(`Master process:${process.pid} started`);
-
-        const hostaddr = GetFirstNetworkInterface();
-        if (hostaddr !== null)
-        {
-            LogEx(`Host Address: ${hostaddr}`);
-        } else {
-            LogEx(`Unknown Host Address.`);
-        }
-		
-        LogEx(`Server starting with ${numCPUs} Cores/Threads`);
-
-        // https://systeminformation.io/
-        const valueObject = {
-            system: '*',
-            osInfo: '*',
-            cpu: '*',
-            mem: '*'
-        }
-
-        const sysinfo = await si.get(valueObject);
-        const hostname = sysinfo.osInfo.hostname;
-
-        LogEx(`Hostname: ${hostname}`);
-        LogEx(`System: ${JSON.stringify(sysinfo.system)}`);
-        LogEx(`OS Info: ${JSON.stringify(sysinfo.osInfo)}`);
-        LogEx(`CPU: ${JSON.stringify(sysinfo.cpu)}`);
-        LogEx(`Memory: ${JSON.stringify(sysinfo.mem)}`);
-
-        const GetSignalColour = (signal: any) =>
-        {
-            let msgcolor = null;
-            if (signal === 'SIGINT')
-            {
-                msgcolor = colors.yellow;
-            } else {
-                msgcolor = colors.red;
-            }
-            return msgcolor;
-        };
-
-        this.#httpServer = null;
-
-        // Terminate in order;
-        // forked worker threads (send signal)
-        // De-Register service
-        // systeminformation observers
-        // instrument timers (gauge etc.)
-        // publisher
-        // terminate UI (if loaded)
-        const Terminate = async (signal: any) =>
-        {
-            if (this.#shuttingDown === false)
-            {
-                this.#shuttingDown = true;
-
-                await this.ProcessTerminate();
-
-                this.ProcessTerminating();
-
-                if (this.GetUIController() !== null)
-                {
-                    LogEx('Destroy the user interface controller.');
-                    this.GetUIController().DestroyUI();
-                }
-
-                if (signal) {
-                    LogEx(GetSignalColour(signal)(`Main Process (singleprocess): ${process.pid} received signal: ${signal}`));
-                } else {
-                    LogEx(GetSignalColour(null)(`Main Process (singleprocess): ${process.pid} received Terminate without signal.`));
-                }
-
-                LogEx(`De-Registering service.`);
-                //@@ De-register here ...
-
-                LogEx(`Stopping instruments.`);
-                //@@StopInstruments(this.instruments);
-
-                if (this.options.wssServer === true && this.#io !== null)
-                {
-                    LogEx(`Disconnect Sockets.`);
-                    if (this.socketIoHelper !== null) {
-                        this.socketIoHelper.DisconnectSockets();
-                    } else {
-                        this.#io.disconnectSockets();
-                    }
-                    this.socketIoHelper = null;
-                    this.#io = null;
-                    // Note that this.#redisClient.disconnect() is not required becuase DisconnectSockets performs this action.
-                }
-
-                if (this.options.httpServer === true) {
-                    LogEx(`Closing httpServer.`);
-                    await this.#httpServer.close();
-                }
-
-                if (this.options.useDatabase) {
-                    LogEx(`Ending database connections and pools.`);
-                    await this.TerminateDatabase();
-                    //await this.accessLayer.enddatabase();
-                }
-
-                // Now allow some time for the workers to die and send any remaining messages ...
-                if (this.InstrumentController && this.InstrumentController.Workers.length > 0) {
-                    LogEx(`Ending publisher.`);
-                    setTimeout(() => {
-                        if (this.InstrumentController) {
-                            this.InstrumentController.InstrumentTerminate();
-                        }
-                    }, 100);
-                }
-
-                await Sleep(1000); // Allow socket.io time to clean-up
-
-                if (this.options.processExitOnTerminate && this.options.processExitOnTerminate === true) {
-                    setTimeout(() => {
-                        LogEx(`Performing process.exit(0).`);
-                        process.exit(0);
-                    }, this.#masterProcessExitTime); // Give the workers time to terminate gracefully
-                } else {
-                    LogEx(`Performing process.exit(0) - Immediate.`);
-                }
-            }
-            LogEx(`Service instance stopped.`);
-        }
+        this.LogEx(`Service instance starting. Instance Id: [${this.options.serviceInstanceId}]`);
+        this.LogEx(`Master process:${process.pid} started`);
 
-        this.#Terminate = Terminate;
+        this.LogSystemTelemetry();
 
-        process.on('SIGINT', async () =>
-        {
-            await Terminate('SIGINT');
+        process.on('SIGINT', async () => {
+            await this.Terminate(false, false, 'SIGINT');
         });
 
-        process.on('SIGTERM', async () =>
-        {
-            await Terminate('SIGTERM');
+        process.on('SIGTERM', async () => {
+            await this.Terminate(false, false, 'SIGTERM');
         });
 
-        process.on('exit', (code) =>
-        {
-            if (code === 0)
-            {
-                LogEx(`Main Process: ${process.pid} terminated gracefully with code: ${code}`.green);
+        process.on('exit', (code) => {
+            if (code === 0) {
+                this.LogEx(`Main Process: ${process.pid} terminated gracefully with code: ${code}`.green);
             } else {
-                LogEx(`Main Process: ${process.pid} terminated with code: ${code}`.red);
+                this.LogEx(`Main Process: ${process.pid} terminated with code: ${code}`.red);
             }
         });
 
-        if (this.options.httpServer === true) {
-            if (this.options.httpsServer === true) {
-                const options = {
-                    key: fs.readFileSync(this.options.httpsServerKeyPath),
-                    cert: fs.readFileSync(this.options.httpsServerCertificatePath)
-                };
-                this.#httpServer = createServerHttps(options, (this.#expressServer as STSExpressServer).App);
-            } else {
-                this.#httpServer = createServer((this.#expressServer as STSExpressServer).App);
-            }
-
-            //this.#httpServer.maxConnections = 50;
-
-            // Setup the web socket server (using socket.io) if enabled.
-            if (this.options.wssServer === true) {
-                // 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 = new Server(this.#httpServer, options);
-
-                if (this.options.useRedisAdaptor) {
-                    LogEx(`Using Redis for socket.io cluster management (worker)`);
-                    if (this.options.redisAdaptorUrl) {
-                        LogEx(`Redis url: [${this.options.redisAdaptorUrl}]`);
-                        this.#redisClient = createClient({url: this.options.redisAdaptorUrl});
-                    } else {
-                        LogEx(`Redis url: [localhost]`);
-                        this.#redisClient = createClient();
-                    }
-                    await this.#redisClient.connect();
-                    this.#io.adapter(createAdapter(this.#redisClient) as any);
-                    LogEx(`Redis successfully connected.`);
-                } else {
-                    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.listen(3006);
-                //		LogEx(`socket.io init`);
-
-                this.#io.engine.on("connection_error", (err: any) => {
-                    LogEx(err.req);      // the request object
-                    LogEx(err.code);     // the error code, for example 1
-                    LogEx(err.message);  // the error message, for example "Session ID unknown"
-                    LogEx(err.context);  // some additional error context
-                });
-            }
-
-            try {
-                // 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(listenPort, 511);
-                }).on('listening', () =>
-                {
-                    LogEx(`live on ${this.options.endpoint}:${this.options.listenPort}${this.options.apiRoot}`);
-                });
-            } catch (error)
-            {
-                console.error(error);
-                throw error;
-            }
-
-        }
-
-        /*
-		if (this.publishBroker !== null) {
-			setTimeout(() => {
-				this.publishBroker.StartPublish();
-			}, 0);
-		}
-		*/
+        await this.SetupSTSServer();
 
         this.ProcessStarted();
+
+        this.LogEx(`Main process:${process.pid} started`.green);
     }
 
-    async Terminate()
+    async TerminateApplication()
     {
-        await this.#Terminate('SIGINT');
+        await this.Terminate(false, false, 'SIGINT');
         this.#Terminate = null;
     }
 }

package/src/tcpclient/app.ts

@@ -0,0 +1,19 @@
+import jayson from 'jayson'
+import { JsonWebTokenError } from 'jsonwebtoken';
+
+// Read node's tls documentation for more information about these options:
+// https://nodejs.org/api/tls.html#tls_tls_connect_options_callback
+const options: jayson.TcpClientOptions = {
+    port: 3003,
+    host: 'stscore.stsmda.org'
+};
+
+const client = jayson.client.tls(options);
+
+// create a client
+
+// invoke "add"
+client.request('add', [1, 1], function(err: any, response: any) {
+    if(err) throw err;
+    console.log(response.result); // 2
+});

package/src/tcpclient/app2.ts

@@ -0,0 +1,55 @@
+import tls from 'tls';
+import { Sleep } from '@nsshunt/stsutils'
+
+import 'colors'
+
+const options = {
+    port: 3003,
+    host: 'stscore.stsmda.org'
+};
+
+const done: boolean[] = [];
+
+const dosomework = (socket: any, index: number) => {
+    console.log('Connected');
+    socket.write("Hello From Client " + JSON.stringify(socket.address()));
+    (async () => {
+        for (;;) {
+            const msg = `${new Date()}: Hello`;
+            console.log(`sending: [${msg}]`);
+            socket.write(msg);
+            await Sleep(1000);
+            if (done[index]) {
+                break;
+            }
+        }
+    })();
+}
+
+for (let i=0; i < 6; i++) {
+    const socket1 = tls.connect(options);
+    done[i] = false;
+    socket1.on('secureConnect', () => {
+        dosomework(socket1, i);
+    });
+    socket1.on('close', function(data: any) {
+        console.log(`CLOSED: ${socket1.remoteAddress} ${socket1.remotePort}`.yellow);
+        done[i]=true;
+    });
+    socket1.on('data', function(data: any) {
+        console.log(`DATA ${socket1.remoteAddress} ${socket1.remotePort} ${data}`.yellow);
+    });
+}
+
+/*
+const socket2 = tls.connect(options);
+socket2.on('secureConnect', () => {
+  dosomework(socket2);
+});
+socket2.on('close', function(data: any) {
+  console.log(`CLOSED: ${socket2.remoteAddress} ${socket2.remotePort}`.green);
+});
+socket2.on('data', function(data: any) {
+  console.log(`DATA ${socket2.remoteAddress} ${socket2.remotePort} ${data}`.green);
+});
+*/

package/src/tcpclientserver/app.ts

@@ -0,0 +1,9 @@
+import { ServiceConfigOptions } from './appConfig.js'
+import { MasterProcessBase, WorkerProcessBase } from './../index'
+import cluster from 'cluster';
+
+if (cluster.isPrimary) {
+    new MasterProcessBase(ServiceConfigOptions(cluster.isPrimary)).SetupServer();
+} else {
+    new WorkerProcessBase(ServiceConfigOptions(cluster.isPrimary)).SetupServer();
+}

package/src/tcpclientserver/appConfig.ts

@@ -0,0 +1,66 @@
+import { v4 as uuidv4 } from 'uuid';
+import express from 'express';
+
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+import { ProcessOptions, IProcessBase, STSServerType } from './../index'
+
+/*
+// 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(isMaster: boolean): ProcessOptions {
+    if (isMaster === true) {
+        const serviceInstanceId = uuidv4();
+        const data: ProcessOptions = {
+            serverType: STSServerType.TCPRAW_TLS,
+
+            wssServer: false,
+            useLatency: false,
+            httpsServerKeyPath: goptions.httpsserverkeypath,
+            httpsServerCertificatePath: goptions.httpsservercertpath,
+            processExitOnTerminate: true,
+            serviceInstanceId: serviceInstanceId,
+            useDatabase: true,
+            useInstrumentationWorkers: true,
+
+            isMaster: isMaster,
+            endpoint: goptions.rest01endpoint,
+            apiRoot: goptions.rest01apiroot,
+            listenPort: goptions.rest01hostport,
+            port: goptions.rest01port,
+
+            prometheusSupport: false,
+            prometheusClusterPort: goptions.rest01prometheusclusterport,
+
+            serviceName: goptions.rest01servicename,
+            serviceVersion: goptions.rest01serviceversion,
+            consoleLogging: true,
+            instrumentLogging: true,
+
+            instrumentationObservationInterval: goptions.instrumentationObservationInterval,
+            instrumentationTimeWindow: goptions.instrumentationTimeWindow,
+
+            useRedisAdaptor: false
+        }
+        return data;
+    } else {
+        const data: ProcessOptions = JSON.parse(process.env['STS_GSD_SII'] as string) as ProcessOptions;
+        return data;
+    }
+}