@nsshunt/stsappframework 3.0.94 → 3.0.96

package/src_working/stscontrollerbase.ts

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

package/src_working/stslatencycontroller.ts

@@ -0,0 +1,27 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { StatusCodes } from 'http-status-codes'
+import { STSControllerBase } from './stscontrollerbase'
+import { IProcessBase } from './commonTypes'
+
+export class STSLatencyController extends STSControllerBase
+{
+    constructor(stsApp: IProcessBase) {
+        super(stsApp);
+    }
+
+    // curl http://localhost:3000/api/v1/latency/latency
+    async stslatency(req: any, res: any)
+    {
+        try {
+            const retVal = { 
+                data: `Ping Completed At: ${Date.now()}`,
+                pid: process.pid,
+                ppid: process.ppid
+            };
+            return res.status(StatusCodes.OK).send(retVal);
+        } catch (error) {
+            console.error(error);
+            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).send( { status: StatusCodes.INTERNAL_SERVER_ERROR, error: 'Operation was not successful', detail: error } );
+        }
+    }
+}

package/src_working/stslatencyroute.ts

@@ -0,0 +1,16 @@
+import { STSRouterBase } from './stsrouterbase'
+import { STSLatencyController } from './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_working/stsrouterbase.ts

@@ -0,0 +1,22 @@
+/* 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_working/tcpclient/app.ts

@@ -0,0 +1,19 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import jayson from 'jayson'
+
+// 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_working/tcpclient/app2.ts

@@ -0,0 +1,56 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+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_working/tcpserver/app.ts

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

package/src_working/tcpserver/appConfig.ts

@@ -0,0 +1,65 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import { $Options } from '@nsshunt/stsconfig'
+const goptions = $Options()
+
+import { ProcessOptions, 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(clusterMode: boolean, isMaster: boolean): ProcessOptions {
+    if (isMaster === true) {
+        const serviceInstanceId = uuidv4();
+        const data: ProcessOptions = {
+            serverType: STSServerType.TCPRAW_TLS,
+
+            clusterMode: clusterMode,
+            wssServer: false,
+            useLatency: false,
+            httpsServerKeyPath: goptions.httpsserverkeypath,
+            httpsServerCertificatePath: goptions.httpsservercertpath,
+            processExitOnTerminate: true,
+            serviceInstanceId: serviceInstanceId,
+            useDatabase: 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;
+    }
+}