@nsshunt/stsappframework 3.1.209 → 3.1.210

package/src/masterprocessbase.ts

@@ -27,9 +27,7 @@ import { InstrumentDefinitions } from '@nsshunt/stsobservability'
 import { IPCMessagePayload, IPCMessageCommand } from './commonTypes'
 
 import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
-import { ISTSLogger, JSONObject } from "@nsshunt/stsutils";
-
-import { RedisMessageHandler } from './redisMessageHandler';
+import { JSONObject } from "@nsshunt/stsutils";
 
 import { GetFirstNetworkInterface } from './network';
 
@@ -619,27 +617,13 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         }
 
         /*
-        const stsServiceControl: RedisMessageHandler = new RedisMessageHandler({
-            logger: this.options.logger,
-            role: 'SERVER',
-            redisUrl: goptions.imRedisMessageProcessorUrl,
-            namespace: 'stsServiceControl',
-            groups: [ 'stsServiceControlGroup' ]
-        });
-        stsServiceControl.Start();
-
-        stsServiceControl.on('ping_ex', (pingData: JSONObject, callback: any) => {
-            console.log(chalk.yellow(`${process.pid}: stsServiceControl.on(ping): [${JSON.stringify(pingData)}]`));
-            callback({pingData, dateTime: new Date().getTime()})
-        });
-        */
-
         this.redisMessageHandler.AddGroup('primary');
 
         this.redisMessageHandler.on('GetSystemInformation', async (args: JSONObject, callback: any) => {
             const retVal = await this.#GetSystemInformation();
             callback(retVal);
         });
+        */
 
         this.MasterStarted();
 
@@ -661,6 +645,7 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
         }
     }
 
+    /*
     #GetSystemInformation = async (): Promise<JSONObject> => {
         // https://systeminformation.io/
         const valueObject = {
@@ -704,4 +689,5 @@ export class MasterProcessBase extends ProcessBase implements IMasterProcessBase
 
         return sysInfo;
     }
+    */
 }

package/src/processbase.ts

@@ -1,14 +1,13 @@
 /* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
 import pidusage from 'pidusage'
 import { memoryUsage } from 'process'
-import path from 'node:path';
 import cluster from 'node:cluster'
 import si from 'systeminformation' // https://systeminformation.io/
 import { GetFirstNetworkInterface } from './network'
 
 import chalk from 'chalk';
 
-import { Gauge, GaugeTypes, InstrumentObjectOptions, InstrumentLogOptions, InstrumentGaugeOptions, InstrumentBaseTelemetry, InstrumentGaugeTelemetry, InstrumentObjectTelemetry, InstrumentLogTelemetry } from '@nsshunt/stsobservability'
+import { Gauge, InstrumentBaseTelemetry, InstrumentGaugeTelemetry, InstrumentObjectTelemetry, InstrumentLogTelemetry } from '@nsshunt/stsobservability'
 
 import { IDBAccessLayer, accessLayerType, DBAccessLayerManager, IDBAccessLayerEvents } from '@nsshunt/stsdatamanagement'
 
@@ -19,19 +18,14 @@ import { StatusCodes } from 'http-status-codes'
 
 import { PublishInstrumentController, IPublishInstrumentControllerOptions, InstrumentDefinitions, 
     TransportType, IPublishTransportRESTServerOptions, 
-    PublishTransportRESTServer, IPublisherTransport,
     STSDefaultClientToServerEvents, STSDefaultServerToClientEvents, GetInstruments } from '@nsshunt/stsobservability'
 
 import os from 'os';
 
 import { IProcessBase, ISocketIoServerHelper, CreateServiceProcessContext, ProcessOptions, STSServerType } from './commonTypes'
 
-import { RedisMessageHandler } from './redisMessageHandler'
+//@@import { RedisMessageHandler } from '@nsshunt/stsmessaging'
 import { TinyEmitter } from 'tiny-emitter';
-import { WorkerInstance } from './testertesting/workerInstance';
-
-import { Worker } from 'worker_threads'
-import { status } from '@grpc/grpc-js';
 
 export abstract class ProcessBase extends TinyEmitter implements IProcessBase 
 {
@@ -40,7 +34,7 @@ export abstract class ProcessBase extends TinyEmitter implements IProcessBase
     #systemInformationInterval: NodeJS.Timeout | null = null;
     #socketIoServerHelper: ISocketIoServerHelper<STSDefaultClientToServerEvents, STSDefaultServerToClientEvents> | null = null;
     #accessLayer: IDBAccessLayer | null = null;
-    #redisMessageHandler: RedisMessageHandler | null = null;
+    //#redisMessageHandler: RedisMessageHandler | null = null;
 
     constructor(options: ProcessOptions) {
         super();
@@ -272,18 +266,7 @@ export abstract class ProcessBase extends TinyEmitter implements IProcessBase
             const accessLayer = this.accessLayer;
         }
 
-        this.LogInfoMessage(`RedisMessageHandler: redisUrl: [${goptions.imRedisMessageProcessorUrl}]`);
-        
-        this.#redisMessageHandler = new RedisMessageHandler({
-            logger: this.options.logger,
-            role: 'CLIENT',
-            redisUrl: goptions.imRedisMessageProcessorUrl,
-            namespace: 'stsServiceControl',
-            groups: [ ],
-            ignoreEvents: [ 'ping' ],
-            processOptions: this.options
-        });
-        this.#redisMessageHandler.Start();
+        //@@this.LogInfoMessage(`RedisMessageHandler: redisUrl: [${goptions.imRedisMessageProcessorUrl}]`);
     }
 
     UpdateInstrument = (instrumentName: Gauge, telemetry: InstrumentBaseTelemetry) => {
@@ -312,7 +295,7 @@ export abstract class ProcessBase extends TinyEmitter implements IProcessBase
         }
         this.#systemInformationInterval = null;
 
-        this.#redisMessageHandler?.Stop();
+        //@@this.#redisMessageHandler?.Stop();
     }
 
     /**
@@ -445,7 +428,9 @@ export abstract class ProcessBase extends TinyEmitter implements IProcessBase
         return msgcolor;
     };
 
+    /*@@
     get redisMessageHandler(): RedisMessageHandler {
         return this.#redisMessageHandler as RedisMessageHandler;
     }
+    */
 }

package/src/testing/app.ts

@@ -3,541 +3,12 @@ import { ServiceConfigOptions } from './appConfig'
 import { MasterProcessBase } from './..'
 import { WorkerProcess } from './appWorkerWSS'
 
-import cluster, { Worker } from 'node:cluster';
+import cluster from 'node:cluster';
 
-import { IPCMessageProcessorWorker } from './../ipcMessageProcessorWorker'
-import { JSONObject, Sleep, defaultLogger } from '@nsshunt/stsutils';
-
-import { IPCMessageProcessorPrimary } from './../ipcMessageProcessorPrimary'
-
-import { IIPCMessageProcessorIPCPayload, IProcessBase } from './../commonTypes'
-
-import chalk from 'chalk';
-
-import { IPCMessageHandler } from './../ipcMessageHandler'
-
-import { v4 as uuidv4 } from 'uuid';
-import { RedisMessageHandler } from './../redisMessageHandler'
-import { goptions } from '@nsshunt/stsconfig'
-
-import si from 'systeminformation' // https://systeminformation.io/
-import { GetFirstNetworkInterface } from './../network'
-
-const sleepVal = 0;
-const maxLoop = 100;
-
-const zzz = async () => {
-    const ipc: IPCMessageProcessorPrimary[] = [ ];
-    for (const id in cluster.workers) {
-        const worker = cluster.workers[id] as Worker;
-        const p1 = new IPCMessageProcessorPrimary({
-            logger: defaultLogger,
-            namespace: 'zzz'
-        })
-        p1.Start(cluster.workers[id] as Worker);
-        ipc.push(p1);
-    }
-
-    const promArray: Promise<JSONObject>[] = [ ];
-    ipc.forEach(v => promArray.push(v.SendMessage({id: v.worker?.id, cmd: 'cmd1'})));
-    const retVal = await Promise.all(promArray).catch(error => {
-        console.error(chalk.red(`   ===>>> Error with promise.all: [${JSON.stringify(error)}]`))
-    });
-    if (retVal) {
-        console.log(chalk.green(JSON.stringify(retVal)));
-    }
-}
-
-const StartTestPrimary = () => {
-    setTimeout(async () => {
-        for (const id in cluster.workers) {
-            const p1 = new IPCMessageProcessorPrimary({
-                logger: defaultLogger,
-                namespace: 'test1',
-                processPayload: async (payload: IIPCMessageProcessorIPCPayload) => {
-                    return { 
-                        msg: `From PRIMARY: [${process.pid}]`,
-                        yousent: payload.requestPayload,
-                        hello1: `world1`,
-                        pid: process.pid
-                    };
-                }
-            })
-
-            const p2 = new IPCMessageProcessorPrimary({
-                logger: defaultLogger,
-                namespace: 'test2',
-                processPayload: async (payload: IIPCMessageProcessorIPCPayload) => {
-                    return { 
-                        msg: `From PRIMARY: [${process.pid}]`,
-                        yousent: payload.requestPayload,
-                        hello2: `world2`,
-                        pid: process.pid
-                    };
-                }
-            })
-
-            p1.Start(cluster.workers[id] as Worker);
-            p2.Start(cluster.workers[id] as Worker);
-
-            setTimeout(async () => {
-                for (let i=0; i < maxLoop; i++) {
-                    const retVal1 = await p1.SendMessage({
-                        from1: 'text from PRIMARY 1',
-                        loop1: i,
-                    });
-                    const retVal2 = await p2.SendMessage({
-                        from2: 'text from PRIMARY 2',
-                        loop2: i
-                    });
-
-                    console.log(`[${process.pid}] [${JSON.stringify(retVal1)}]`)
-                    console.log(`[${process.pid}] [${JSON.stringify(retVal2)}]`)
-
-                    await Sleep(sleepVal);
-                }
-            }, 1000);
-        }
-
-        zzz();
-
-    }, 1000);
-}
-
-const StartTestWorker = () => {
-    const w1 = new IPCMessageProcessorWorker({
-        logger: defaultLogger,
-        namespace: 'test1',
-        requestResponseMessageTimeout: 5000,
-        processPayload: async (payload) => {
-            return {
-                msg1: `From WORKER: [${process.pid}]`,
-                yousent1: payload.requestPayload,
-                pid1: process.pid
-            }
-        }
-    })
-
-    const w2 = new IPCMessageProcessorWorker({
-        logger: defaultLogger,
-        namespace: 'test2',
-        requestResponseMessageTimeout: 5000,
-        processPayload: async (payload) => {
-            return {
-                msg2: `From WORKER: [${process.pid}]`,
-                yousent2: payload.requestPayload,
-                pid2: process.pid
-            }
-        }
-    })
-
-    const w3 = new IPCMessageProcessorWorker({
-        logger: defaultLogger,
-        namespace: 'zzz',
-        requestResponseMessageTimeout: 5000,
-        processPayload: async (payload) => {
-            switch (payload.requestPayload.cmd) {
-            case 'cmd1' : return {
-                msg3: `COMMAND 1 From WORKER: [${process.pid}]`,
-                yousent3: payload.requestPayload,
-                pid3: process.pid
-            }
-                break;
-            case 'cmd2' :
-                return {
-                    msg3: `COMMAND 2 From WORKER: [${process.pid}]`,
-                    yousent3: payload.requestPayload,
-                    pid3: process.pid
-                }
-                break;
-            }
-            return {
-                msg3: `COMMAND Unknown From WORKER: [${process.pid}]`,
-                yousent3: payload.requestPayload,
-                pid3: process.pid
-            }
-        }
-    })
-
-    w1.Start();
-    w2.Start();
-    w3.Start();
-
-    setTimeout(async () => {
-        for (let i=0; i < maxLoop; i++) {
-            const retVal1 = await w1.SendMessage({
-                hello1:`from WORKER 1: ${i}`
-            });
-            console.log(chalk.blue(` ==> [${process.pid}] [${JSON.stringify(retVal1)}]`));
-
-            const retVal2 = await w2.SendMessage({
-                hello2:`from WORKER 2: ${i}`
-            });
-            console.log(chalk.blue(` ==> [${process.pid}] [${JSON.stringify(retVal2)}]`));
-
-            await Sleep(sleepVal);
-        }
-    }, 1000);
-}
-
-const iterations = 0;
-const delay = 100;
-
-const GetNumCPUs = async (): Promise<number> => {
-    // https://systeminformation.io/
-    const valueObject = {
-        cpu: '*'
-    }
-
-    const sysinfo = await si.get(valueObject);
-    let numCPUs = 2;
-    if (goptions.useCPUs > 0) {
-        if (goptions.useCPUs >= 1) {
-            numCPUs = goptions.useCPUs;
-        } else {
-            numCPUs = Math.round(sysinfo.cpu.cores * goptions.useCPUs);
-        }
-    } else {
-        numCPUs = sysinfo.cpu.physicalCores;
-    }
-    return numCPUs;
-}
-
-const LogInfoMessage = (message: string) => {
-    console.log(message);
-}
-
-const LogSystemTelemetry = async () => {
-    // https://systeminformation.io/
-    const valueObject = {
-        system: '*',
-        osInfo: '*',
-        cpu: '*',
-        mem: '*',
-        dockerInfo: '*',
-        //dockerImages: '*',
-        dockerContainers: '*',
-    }
-
-    const sysinfo = await si.get(valueObject);
-    const numCPUs = await GetNumCPUs();
-    const hostname = sysinfo.osInfo.hostname;
-
-    const hostaddr = GetFirstNetworkInterface();
-    if (hostaddr !== null) {
-        LogInfoMessage(`Host Address: ${hostaddr}`);
-    } else {
-        LogInfoMessage(`Unknown Host Address.`);
-    }
-    LogInfoMessage(`Server starting with ${numCPUs} Cores/Threads`);
-
-    LogInfoMessage(`Hostname: ${hostname}`);
-    LogInfoMessage(`System: ${JSON.stringify(sysinfo.system)}`);
-    LogInfoMessage(`OS Info: ${JSON.stringify(sysinfo.osInfo)}`);
-    LogInfoMessage(`CPU: ${JSON.stringify(sysinfo.cpu)}`);
-    LogInfoMessage(`Memory: ${JSON.stringify(sysinfo.mem)}`);
-
-    const promArray: Promise<any>[] = [ ];
-
-    sysinfo.dockerContainers.forEach((dc: { id: string; }) => {
-        LogInfoMessage(dc.id);
-        const dcs = promArray.push(si.dockerContainerStats(dc.id));
-        console.log(dcs);
-    });
-    const dockerContainerStats = await Promise.all(promArray);
-
-    const sysInfo = {
-        hostname,
-        numCPUs,
-        hostaddr,
-        system: sysinfo.system,
-        osInfo: sysinfo.osInfo,
-        cpu: sysinfo.cpu,
-        mem: sysinfo.mem,
-        dockerInfo: sysinfo.dockerInfo,
-        //dockerImages: sysinfo.dockerImages,
-        dockerContainers: sysinfo.dockerContainers,
-        dockerContainerStats
-    }
-
-    console.log(sysInfo);
-
-    console.log(JSON.stringify(sysInfo));
-}
 
 if (cluster.isPrimary) {
     new MasterProcessBase(ServiceConfigOptions(true, cluster.isPrimary)).SetupServer();
-    //StartTestPrimary();
-
-    LogSystemTelemetry();
-
-    // This RedisMessageHandler is the master service controller. Created here for testing purposes.
-    // This code will be within the primary service controller. It will live in stsinstrumentmanager until the new service is created.
-    const stsServiceControl: RedisMessageHandler = new RedisMessageHandler({
-        logger: defaultLogger,
-        role: 'SERVER',
-        redisUrl: goptions.imRedisMessageProcessorUrl,
-        namespace: 'stsServiceControl',
-        groups: [ ]
-    });
-    stsServiceControl.Start();
-
-    setTimeout(() => {
-        const p: Record<string, IPCMessageHandler> = { };
-        /*
-        for (const id in cluster.workers) {
-            const worker = cluster.workers[id] as Worker;
-
-            const p1: IPCMessageHandler = new IPCMessageHandler({
-                logger: defaultLogger,
-                requestResponseMessageTimeout: 5000,
-                namespace: 'aabbcc'
-            });
-            p1.Start(worker);
-
-            p1.on('fromworker', (arg1: string, arg2: number, arg3: string, callback: any) => {
-                //callback(null);
-                callback({status: `response message from event = fromworker with args ${arg1} ${arg2} ${arg3}`})
-            });
-
-            p[worker.id] = p1;
-        }
-        */
-
-        /*
-        const stsServiceControl: RedisMessageHandler = new RedisMessageHandler({
-            logger: defaultLogger,
-            role: 'SERVER',
-            redisUrl: goptions.imRedisMessageProcessorUrl,
-            namespace: 'stsServiceControl',
-            groups: [ ]
-        });
-        stsServiceControl.Start();
-
-        stsServiceControl.on('ping_ex', (pingData: JSONObject, callback: any) => {
-            console.log(chalk.yellow(`${process.pid}: stsServiceControl.on(ping): [${JSON.stringify(pingData)}]`));
-            callback({pingData, dateTime: new Date().getTime()})
-        });
-
-        setInterval(() => {
-            stsServiceControl.emit('GET_SYSTEM_TELEMETRY', { }, (response: any) => {
-                console.log(chalk.green(`  ==>> ${process.pid}: Response(GET_SYSTEM_TELEMETRY): [${JSON.stringify(response)}]`));
-            });
-        }, 5000);
-        */
-
-
-
-        const r1: RedisMessageHandler = new RedisMessageHandler({
-            logger: defaultLogger,
-            role: 'SERVER',
-            redisUrl: goptions.imRedisMessageProcessorUrl,
-            namespace: 'mytestapp',
-            groups: [ ]
-        });
-        r1.Start();
-
-        const RunTest = async (eventName: string, emitobj: JSONObject) => {
-            const start = performance.now();
-            try {
-                const response = await r1.emitex(eventName, emitobj);
-                const duration = performance.now() - start;
-                console.log(chalk.cyan(`${process.pid}: Duration: ${duration} Test: [test1] Response(${chalk.bold(eventName)}): [${JSON.stringify(response)}]`));
-            } catch (error) {
-                const duration = performance.now() - start;
-                console.log(chalk.cyan(`${process.pid}: Duration: ${duration} Test: [test1] Response(${chalk.bold(eventName)}): Error: [${JSON.stringify(error)}]`));
-            }
-        }
-
-        let i = 0;
-        let group = '';
-        const maxIterations = 20;
-        const xxx = () => {
-            setTimeout(() => {
-                i++;
-
-                if (i > maxIterations) {
-                    return;
-                }
-
-                console.log(chalk.yellow(`Iteration: [${i}]`));
-
-                if (i % 2 === 0) {
-                    group = 'even'
-                } else {
-                    group = 'odd'
-                }
-
-                const promArray: Promise<void>[] = [ ];
-                const start = performance.now();
-                promArray.push(
-                    RunTest('fromprimaryredis', { group, i: i, a: 'a', b: 'b' }),
-                    RunTest('fromprimaryredis', { group: '2', i: i, a: 'a', b: 'b' }),
-                    RunTest('fromprimaryredis', { group: '4', i: i, a: 'a', b: 'b' }),
-                    RunTest('globalmessage', { i: i, a: 'a', b: 'b' })
-                );
-                (async () => {
-                    await Promise.all(promArray);
-                    const duration = performance.now() - start;
-                    console.log(chalk.green(`${process.pid}: Duration: ${duration} Test: [All Tests Run]`));
-                    console.log();
-                    xxx();
-                })();
-            }, 250);
-        }
-        //setTimeout(() => xxx(), 1000);
-
-
-
-        
-            
-        /*
-        const r1: RedisMessageHandler = new RedisMessageHandler({
-            logger: defaultLogger,
-            role: 'SERVER',
-            redisUrl: goptions.imRedisMessageProcessorUrl,
-            namespace: 'mytestapp'
-        });
-        r1.Start();
-
-        r1.on('fromworkerredis', (arg1: string, arg2: number, arg3: string, callback: any) => {
-            console.log(chalk.magenta(`${process.pid}: fromworkerredis.ON: [${arg1} ${arg2} ${arg3}]`));
-            //callback(null);
-            callback({status: `response message from event = fromworkerredis with args ${arg1} ${arg2} ${arg3}`})
-        });
-
-
-        setTimeout(async () => {
-            for (let i=0; i < iterations; i++) {
-
-                const emitobj = { i: i, a: 'a', b: 'b' };
-                console.log(chalk.cyan(`${process.pid}: emit event fromprimaryredis fromprimary: [${JSON.stringify(emitobj)}`));
-                r1.emit('fromprimaryredis', emitobj, (response: any) => {
-                    console.log(chalk.cyan(`${process.pid}: Response(fromprimaryredis): [${JSON.stringify(response)}]`));
-                });
-
-                await Sleep(delay);
-            }
-
-        }, 1000);
-        */
-    }, 2000);
-
-
-    const ListClients = () => {
-        setTimeout(() => {
-            Object.values(stsServiceControl.clients).forEach(c => {
-                console.log(chalk.gray(`client id: [${c.id}]`));
-                console.log(chalk.gray(`client groups: [${c.groups}]`));
-                console.log(chalk.gray(`client pingCount: [${c.pingCount}]`));
-                console.log(chalk.gray(`client serviceProcessContext: [${JSON.stringify(c.serviceProcessContext)}]`));
-            });
-            ListClients();
-        }, 1000).unref();
-    }
-    //ListClients();
-
-
 } else {
     const worker = new WorkerProcess(ServiceConfigOptions(true, cluster.isPrimary));
     worker.SetupServer();
-    //StartTestWorker();
-
-    setTimeout(async () => {
-
-        let group = '';
-        if (process.pid % 2 === 0) {
-            group = 'even'
-        } else {
-            group = 'odd'
-        }
-
-        let workerId = '0';
-        if (cluster.worker) {
-            console.log(chalk.blue(`Worker: [${cluster.worker?.id}]`));
-            workerId = cluster.worker?.id.toString();
-        }
-
-        const r1: RedisMessageHandler = new RedisMessageHandler({
-            logger: defaultLogger,
-            role: 'CLIENT',
-            redisUrl: goptions.imRedisMessageProcessorUrl,
-            namespace: 'mytestapp',
-            groups: [ group, workerId ],
-            ignoreEvents: [ 'ping' ]
-        });
-        r1.Start();
-
-        r1.on('fromprimaryredis', (arg1: JSONObject, callback: any) => {
-            callback( {
-                status: `PID: [${process.pid}]: response message from event = fromprimaryredis with args ${JSON.stringify(arg1)}`
-            })
-        });
-
-        r1.on('globalmessage', (arg1: JSONObject, callback: any) => {
-            callback( {
-                status: `PID: [${process.pid}]: response message from event = globalmessage with args ${JSON.stringify(arg1)}`
-            })
-        });
-
-
-        /*
-        const w1: IPCMessageHandler = new IPCMessageHandler({
-            logger: defaultLogger,
-            requestResponseMessageTimeout: 5000,
-            namespace: 'aabbcc'
-        });
-        w1.Start();
-
-        w1.on('fromprimary', (arg1: JSONObject, callback: any) => {
-            //callback();
-            callback({status: `response message from event = fromprimary with args ${JSON.stringify(arg1)}`})
-        });
-        */
-
-        /*
-        const r1: RedisMessageHandler = new RedisMessageHandler({
-            logger: defaultLogger,
-            role: 'CLIENT',
-            redisUrl: goptions.imRedisMessageProcessorUrl,
-            namespace: 'mytestapp'
-        });
-        r1.Start();
-
-        r1.on('fromprimaryredis', (arg1: JSONObject, callback: any) => {
-            //callback();
-            console.log(chalk.yellow(`${process.pid}: fromprimaryredis.ON: [${JSON.stringify(arg1)}]`));
-            callback({status: `PID: [${process.pid}]: response message from event = fromprimaryredis with args ${JSON.stringify(arg1)}`})
-        });
-
-        setTimeout(async () => {
-            for (let i=0; i < iterations; i++) {
-                const id = uuidv4();
-
-                console.log(chalk.green(`${process.pid}: emit event fromworkerredis: [${id} ${i} Hello]`));
-                r1.emit('fromworkerredis', id, i, 'Hello', (response: any) => {
-                    console.log(chalk.green(`${process.pid}: Response(fromworkerredis): [${JSON.stringify(response)}]`));
-                });
-                await Sleep(delay);
-            }
-        }, 1000);
-        */
-
-        worker.redisMessageHandler.emit('GetSystemInformation', {
-            group: 'primary'
-        }, (response: any) => {
-            console.log(`------------------------------------------------------------------------`);
-            console.log(response);
-        });
-
-        worker.redisMessageHandler.emitWithError('GetSystemInformation', {
-            group: 'primary'
-        }, (response: any) => {
-            console.log(`************************************************************************`);
-            console.log(response);
-        }, (error: any) => {
-            console.log(chalk.red(`GetSystemInformation Error: [${error}]`));
-        });
-
-    }, 2000);
 }