@nsshunt/stsappframework 3.1.129 → 3.1.131

package/src/ipcMessageHandler.ts

@@ -54,7 +54,8 @@ export class IPCMessageHandler extends TinyEmitter {
             messageReceiverStop: (options: any) => {
                 const worker = (options.worker as Worker);
                 worker.off('message', (payload) => this.#ipcMessageManager?.ProcessMessage(payload, { worker }));
-            }
+            },
+            groups: [ ]
         }
         this.#ipcMessageManager = new IPCMessageManager(ipcMessageManagerOptions);
     }
@@ -79,7 +80,8 @@ export class IPCMessageHandler extends TinyEmitter {
             },
             messageReceiverStop: (options: any) => {
                 process.off('message', (payload) => this.#ipcMessageManager?.ProcessMessage(payload, options));
-            }
+            },
+            groups: [ ]
         }
         this.#ipcMessageManager = new IPCMessageManager(ipcMessageManagerOptions);
     }

package/src/ipcMessageManager.ts

@@ -12,6 +12,7 @@ export interface IPCMessageManagerOptions {
     requestResponseMessageTimeout: number
     namespace: string
     role: 'SERVER' | 'CLIENT'
+    groups: string[]
     messageSender: (payload: IIPCMessageProcessorIPCPayload, options: any) => void
     ProcessRequestMessage: (payload: IIPCMessageProcessorIPCPayload, options: any) => Promise<JSONObject>
     ProcessResponseMessage?: (reesponses: Record<string, IIPCMessageProcessorIPCPayload>, options: any) => Promise<boolean>
@@ -100,28 +101,43 @@ export class IPCMessageManager
     }
 
     #ProcessMessage = async (msg: any, options: any): Promise<void> => {
+        //console.log(chalk.grey(`#ProcessMessage`));
         if (msg.header && msg.header.localeCompare(this.#messageHeader) === 0) {
             const message = (msg as IIPCMessageProcessorIPCPayload);
             if (this.#inflightMessages[message.messageId]) {
                 const inFlightMessageRecord: IIPCMessageProcessorWorkerRecord = this.#inflightMessages[message.messageId];
                 inFlightMessageRecord.responses[message.senderId ] = { ...message };
                 let completed = true; // Defaults to true
+
+                //console.log(chalk.grey(`#ProcessMessage:2`));
+
                 if (this.#options.ProcessResponseMessage) {
+
+                    if (msg.requestPayload.__eventName.localeCompare('ping') !== 0) {
+                        console.log(chalk.grey(`#ProcessMessage:3: [${JSON.stringify(msg.requestPayload)}]`));
+                    }
+
                     completed = await this.#options.ProcessResponseMessage(inFlightMessageRecord.responses, options);
                     if (completed) {
+                        //console.log(chalk.grey(`#ProcessMessage:3.1`));
                         inFlightMessageRecord.endTime = performance.now();
                         clearTimeout(inFlightMessageRecord.timeout as NodeJS.Timer);
                         inFlightMessageRecord.callBack({
                             responsePayload: Object.values(inFlightMessageRecord.responses).map(r => r.responsePayload)
                         } as any, options) // 
                         delete this.#inflightMessages[message.messageId];
+
+                        //console.log(chalk.grey(`this.#inflightMessages.length = ${Object.keys(this.#inflightMessages).length}`));
                     }
                 } else if (completed) {
+                    //console.log(chalk.grey(`#ProcessMessage:4`));
                     inFlightMessageRecord.endTime = performance.now();
                     clearTimeout(inFlightMessageRecord.timeout as NodeJS.Timer);
                     inFlightMessageRecord.callBack(message, options) // inFlightMessageRecord.responses
                     //@@inFlightMessageRecord.callBack(Object.values(inFlightMessageRecord.responses), options) // 
                     delete this.#inflightMessages[message.messageId];
+                } else {
+                    //console.log(chalk.grey(`#ProcessMessage:5`));
                 }
             } else {
                 //throw new Error(`Could not find Request/Response message with id: [${message.messageId}]`); //@@
@@ -153,10 +169,30 @@ export class IPCMessageManager
             if ((msg.header as string).includes(checkName)) {
                 const message = (msg as IIPCMessageProcessorIPCPayload);
                 if (msg.messageType.localeCompare('REQUEST') === 0) {
-                    message.responsePayload = await this.#options.ProcessRequestMessage(message, options);
-                    message.senderId = this.#id;
-                    message.messageType = 'RESPONSE';
-                    this.#options.messageSender(message, options);
+                    let processMessage = true;
+                    if (message.requestPayload.args.length > 0 && message.requestPayload.args[0].group) {
+                        const group = message.requestPayload.args[0].group;
+                        console.log(chalk.green(`${process.pid}:ProcessMessage(): Processor Options Groups: [${this.#options.groups}] request group: [${group}]`));
+                        processMessage = (this.#options.groups.indexOf(group) === -1) ? false : true;
+                        if (processMessage === false) {
+                            console.log(chalk.red(`${process.pid}:ProcessMessage(): Skipping this message: Not in correct group: [${group}]`));
+                        } else {
+                            console.log(chalk.yellow(`${process.pid}:ProcessMessage(): Will process this message: [${group}]`));
+                        }
+                    }
+
+                    if (processMessage) {
+                        message.responsePayload = await this.#options.ProcessRequestMessage(message, options);
+                        message.senderId = this.#id;
+                        message.messageType = 'RESPONSE';
+
+                        if (message.requestPayload.__eventName.localeCompare('ping') !== 0) {
+                            console.log(chalk.grey(`${process.pid}:ProcessMessage(): Sending response: [${JSON.stringify(message.responsePayload)}]`));
+                        }
+
+                        this.#options.messageSender(message, options);
+                    }
+
                 } else {
                     // Received a response (to my request)
                     this.#ProcessMessage(msg, options);

package/src/ipcMessageProcessorPrimary.ts

@@ -42,7 +42,8 @@ export class IPCMessageProcessorPrimary
             messageReceiverStop: (options: any) => {
                 const worker = (options.worker as Worker);
                 worker.off('message', (payload) => this.#ipcMessageManager.ProcessMessage(payload, { worker }));
-            }
+            },
+            groups: [ ]
         }
         this.#ipcMessageManager = new IPCMessageManager(ipcMessageManagerOptions);
     }

package/src/ipcMessageProcessorWorker.ts

@@ -39,7 +39,8 @@ export class IPCMessageProcessorWorker {
             },
             messageReceiverStop: (options: any) => {
                 process.off('message', (payload) => this.#ipcMessageManager.ProcessMessage(payload, options));
-            }
+            },
+            groups: [ ]
         }
         this.#ipcMessageManager = new IPCMessageManager(ipcMessageManagerOptions);
     }

package/src/redisMessageHandler.test.ts

@@ -39,7 +39,8 @@ describe.skip("Redis Message Handler Test", () =>
                 logger: defaultLogger,
                 role: 'SERVER',
                 redisUrl: ioRedisMessageProcessorUrl, // goptions.imRedisMessageProcessorUrl,
-                namespace: 'redistestingstsframework'
+                namespace: 'redistestingstsframework',
+                groups: [ ]
             });
             this.#r1.Start();
 
@@ -87,7 +88,8 @@ describe.skip("Redis Message Handler Test", () =>
                 logger: defaultLogger,
                 role: 'CLIENT',
                 redisUrl: ioRedisMessageProcessorUrl, // goptions.imRedisMessageProcessorUrl,
-                namespace: 'redistestingstsframework'
+                namespace: 'redistestingstsframework',
+                groups: [ ]
             });
             this.#r1.Start();
     

package/src/redisMessageHandler.ts

@@ -17,6 +17,7 @@ export interface IRedisAdminManagerOptions {
     logger: ISTSLogger
     role: 'SERVER' | 'CLIENT'
     namespace: string
+    groups: string[]
 }
 
 export interface IClientRecord {
@@ -24,6 +25,7 @@ export interface IClientRecord {
     clientConnected: Date
     pingCount: number
     timeout: NodeJS.Timeout
+    groups: string[]
 }
 
 export interface IEventPayload {
@@ -78,19 +80,33 @@ export class RedisMessageHandler extends TinyEmitter {
         if (this.#options.role.localeCompare('CLIENT') === 0) {
             const ping = () => {
                 this.#pingTimeout = setTimeout(() => {
-                    this.emit('ping', this.#ipcMessageManager?.id, (response: any) => { });
+                    let group = '';
+                    if (process.pid % 2 === 0) {
+                        group = 'even';
+                    } else {
+                        group = 'odd';
+                    }
+                    //console.log(chalk.gray(`${process.pid}: emitting ping ...`))
+                    this.emit('ping', {
+                        id: this.#ipcMessageManager?.id,
+                        groups: [
+                            group
+                        ]
+                    }, (response: any) => { });
                     ping();
                 }, 1000).unref();
             }
             ping();
         } else {
-            this.on('ping', (id: string, callback: any) => {
+            this.on('ping', (pingData: JSONObject, callback: any) => {
+                const { id, groups } = pingData;
                 if (this.#clients[id]) {
                     clearTimeout(this.#clients[id].timeout);
                     this.#clients[id].pingCount++;
                     this.#clients[id].timeout = setTimeout(() => {
                         delete this.#clients[id];
                     }, 2000);
+                    this.#clients[id].groups = groups;
                 } else {
                     this.#clients[id] = {
                         id,
@@ -98,12 +114,17 @@ export class RedisMessageHandler extends TinyEmitter {
                         pingCount: 0,
                         timeout: setTimeout(() => {
                             delete this.#clients[id];
-                        }, 2000)
+                        }, 2000),
+                        groups
                     }
                 }
+                //console.log(chalk.gray(`  ${process.pid}: processed ping ...`))
                 callback('ok');
             });
         }
+
+        console.log(chalk.yellow(`RedisMessageHandler:constructor(): [${JSON.stringify(this.#options.groups)}]`));
+
     }
 
     #LogInfo(message: any) {
@@ -126,6 +147,7 @@ export class RedisMessageHandler extends TinyEmitter {
             namespace: this.#options.namespace,
             role: this.#options.role,
             messageSender: this.#messageSender,
+            groups: this.#options.groups,
             // This method is used to calculate if all responses have been received from multiple clients (broadcast)
             // returns true/false.
             ProcessResponseMessage: this.#ProcessResponseMessage,
@@ -166,16 +188,143 @@ export class RedisMessageHandler extends TinyEmitter {
             return allFound;
         }
 
+        console.log(chalk.grey(`${process.pid}:   -->> *** <<-- #ProcessResponseMessage`));
         let found = true;
+
+        // Sender role here is SERVER
+
+        console.log(chalk.yellow(`${process.pid}:  Total Clients :-`));
+        Object.values(this.#clients).forEach(c => {
+            console.log(chalk.yellow(`${process.pid}:  ${c.id}    ${c.groups}`));
+        })
+
+        let requestGroup = null;
+        console.log(chalk.blue(`${process.pid}:  Responses :-`));
+        for (const [responseId, response] of Object.entries(responses)) {
+            console.log(chalk.blue(`${process.pid}:  client.id: [${responseId}]  response payload: [${JSON.stringify(response.responsePayload)}]`));
+            if (response.requestPayload.args.length > 0 && response.requestPayload.args[0].group) {
+                requestGroup = response.requestPayload.args[0].group;
+                console.log(chalk.blue(`${process.pid}:  Group Request: [${requestGroup}]`));
+                break;
+            }
+        }
+
+        if (requestGroup) {
+            console.log(chalk.blue(`${process.pid}:  Group Request`));
+            const clientsInGroup = Object.values(this.#clients).filter(c => {
+                if (c.groups.indexOf(requestGroup) === -1) {
+                    return false;
+                }
+                return true;
+            });
+            console.log(chalk.blue(`${process.pid}:  Clients in group: [${requestGroup}] :-`));
+            clientsInGroup.forEach(c => {
+                console.log(chalk.blue(`${process.pid}:  ${c.id}`));
+            })
+
+            // Now make sure that all clients are in the responses
+            found = true;
+            clientsInGroup.forEach(c => {
+                if (!responses[c.id]) {
+                    found = false;
+                }
+            })
+            console.log(chalk.blue(`${process.pid}:  found (group) = [${found}]`));
+        } else {
+            console.log(chalk.blue(`${process.pid}:  Non-Group Request`));
+
+            const clientsInGroup = Object.values(this.#clients)
+            console.log(chalk.blue(`${process.pid}:  Clients in group (global list): [${requestGroup}] :-`));
+            clientsInGroup.forEach(c => {
+                console.log(chalk.blue(`${process.pid}:  ${c.id}`));
+            })
+
+            // Now make sure that all clients are in the responses
+            found = true;
+            clientsInGroup.forEach(c => {
+                if (!responses[c.id]) {
+                    found = false;
+                }
+            })
+            console.log(chalk.blue(`${process.pid}:  found (non-group) = [${found}]`));
+        }
+
+        return found;
+
+
+        /*
+
+
         Object.values(this.#clients).map(c => {
-            if (!responses[c.id]) {
-                found = false;
+            if (found) {
+                // Check for group payloads
+
+                console.log(chalk.magenta(`${process.pid}:  clients (from ping data)`));
+                for (const [key, value] of Object.entries(this.#clients)) {
+                    console.log(chalk.magenta(`${process.pid}: ${key} = [${value.id}  ${value.groups}]`))
+                }
+                console.log(chalk.blue(`${process.pid}:  ${JSON.stringify(responses)}`));
+
+
+                if (responses[c.id]) {
+                    console.log(chalk.blue(`${process.pid}:  1`));
+                    if (responses[c.id].requestPayload) {
+                        console.log(chalk.blue(`${process.pid}:  2`));
+                        if (responses[c.id].requestPayload.args.length > 0) {
+                            console.log(chalk.blue(`${process.pid}:  3`));
+                            if (responses[c.id].requestPayload.args[0].group) {
+                                console.log(chalk.blue(`${process.pid}:  4`));
+                                console.log(chalk.magenta(`${process.pid}:requestPayload: [${JSON.stringify(responses[c.id].requestPayload.args[0].group )}]`))
+                                const requestGroup = responses[c.id].requestPayload.args[0].group;
+                                //const responseGroup = responses[c.id].responsePayload.args[0].group;
+
+                                console.log(chalk.magenta(`${process.pid}:  clients (from ping data)`));
+                                Object.values(this.#clients).forEach(c => {
+                                    console.log(chalk.magenta(`  ${c.groups}`))
+                                })
+                                console.log(chalk.magenta(`${process.pid}:`));
+
+                                console.log(chalk.magenta(`${process.pid}:  responses so far...`));
+
+                                for (const [key, value] of Object.entries(responses)) {
+                                    console.log(chalk.magenta(`${process.pid}:  client.id: [${key}]  response payload: [${JSON.stringify(value.responsePayload)}]`));
+                                }
+                                console.log(chalk.magenta(`${process.pid}:`));
+
+                                const clientsInGroup = Object.values(this.#clients).filter(c => {
+                                    const foundGroupIndex = c.groups.indexOf(requestGroup);
+                                    if (foundGroupIndex === -1) {
+                                        return false;
+                                    }
+                                    return true;
+                                });
+                                clientsInGroup.forEach(c => {
+                                    console.log(`${process.pid}:clientsInGroup: [${c.id}]   groups: [${c.groups}]`);
+                                    if (!responses[c.id]) {
+                                        console.log(`${process.pid}:  clientsInGroup - not found: [${c.id}]`);
+                                        found = false;
+                                    }
+                                });
+                                // Now check if all responses for completed group membership
+                            }
+                        }
+                    }
+                } else {
+                    if (!responses[c.id]) {
+                        found = false;
+                    }
+                }
             }
         });
 
-        if (found) {
+        console.log(chalk.grey(`${process.pid}:  ** Testing condition **`))
+        if (found === true) {
+            console.log(chalk.green(`${process.pid}:Found all messages - should return results`))
             return true;
         }
+        console.log(chalk.red(`${process.pid}:did not find all messages (yet) ...`))
+        return false;
+        */
         return false;
     }
 

package/src/testing/app.ts

@@ -20,6 +20,9 @@ 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;
 
@@ -177,13 +180,97 @@ const StartTestWorker = () => {
     }, 1000);
 }
 
-const iterations = 100;
+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();
+
     setTimeout(() => {
         const p: Record<string, IPCMessageHandler> = { };
         /*
@@ -206,7 +293,76 @@ if (cluster.isPrimary) {
         }
         */
 
+        /*
+        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();
+
+
+
+        let i = 0;
+        let group = '';
+        const xxx = () => {
+            setTimeout(() => {
+
+                i++;
+
+                if (i % 2 === 0) {
+                    group = 'even'
+                } else {
+                    group = 'odd'
+                }
+
+                const emitobj = { group, i: i, a: 'a', b: 'b' };
+                r1.emit('fromprimaryredis', emitobj, (response: any) => {
+                    console.log(chalk.cyan(`${process.pid}: Response(fromprimaryredis): [${JSON.stringify(response)}]`));
+                });
+
+                /*
+                const globalemitobj = { i: i, a: 'a', b: 'b' };
+                r1.emit('globalmessage', globalemitobj, (response: any) => {
+                    console.log(chalk.cyan(`${process.pid}: Response(globalmessage): [${JSON.stringify(response)}]`));
+                });
+                */
+
+                //xxx();
+            }, 2000);
+        }
+        xxx();
+
+
+
+        
             
+        /*
         const r1: RedisMessageHandler = new RedisMessageHandler({
             logger: defaultLogger,
             role: 'SERVER',
@@ -224,16 +380,6 @@ if (cluster.isPrimary) {
 
         setTimeout(async () => {
             for (let i=0; i < iterations; i++) {
-                /*
-                Object.keys(p).forEach(async (pKey) => {
-                    const emitobj = { i: i, a: 'a', b: 'b', worker: pKey };
-                    console.log(chalk.green(`${process.pid}: emit event to worker: [${pKey}] fromprimary: [${JSON.stringify(emitobj)}`));
-                    p[pKey].emit('fromprimary', emitobj, (response: any) => {
-                        console.log(chalk.green(`${process.pid}: ${JSON.stringify(response)}`));
-                    });
-                });
-                */
-
 
                 const emitobj = { i: i, a: 'a', b: 'b' };
                 console.log(chalk.cyan(`${process.pid}: emit event fromprimaryredis fromprimary: [${JSON.stringify(emitobj)}`));
@@ -245,12 +391,45 @@ if (cluster.isPrimary) {
             }
 
         }, 1000);
+        */
     }, 1000);
 } else {
     new WorkerProcess(ServiceConfigOptions(true, cluster.isPrimary)).SetupServer();
     //StartTestWorker();
 
     setTimeout(async () => {
+
+        let group = '';
+        if (process.pid % 2 === 0) {
+            group = 'even'
+        } else {
+            group = 'odd'
+        }
+
+        const r1: RedisMessageHandler = new RedisMessageHandler({
+            logger: defaultLogger,
+            role: 'CLIENT',
+            redisUrl: goptions.imRedisMessageProcessorUrl,
+            namespace: 'mytestapp',
+            groups: [ group ]
+        });
+        r1.Start();
+
+        r1.on('fromprimaryredis', (arg1: JSONObject, callback: any) => {
+            console.log(chalk.greenBright(`   -->> ${process.pid}: fromprimaryredis.ON: [${JSON.stringify(arg1)}]`));
+            callback( {
+                status: `PID: [${process.pid}]: response message from event = fromprimaryredis with args ${JSON.stringify(arg1)}`
+            })
+        });
+
+        r1.on('globalmessage', (arg1: JSONObject, callback: any) => {
+            console.log(chalk.greenBright(`   -->> ${process.pid}: globalmessage.ON: [${JSON.stringify(arg1)}]`));
+            callback( {
+                status: `PID: [${process.pid}]: response message from event = globalmessage with args ${JSON.stringify(arg1)}`
+            })
+        });
+
+
         /*
         const w1: IPCMessageHandler = new IPCMessageHandler({
             logger: defaultLogger,
@@ -265,6 +444,7 @@ if (cluster.isPrimary) {
         });
         */
 
+        /*
         const r1: RedisMessageHandler = new RedisMessageHandler({
             logger: defaultLogger,
             role: 'CLIENT',
@@ -282,12 +462,6 @@ if (cluster.isPrimary) {
         setTimeout(async () => {
             for (let i=0; i < iterations; i++) {
                 const id = uuidv4();
-                /*
-                console.log(chalk.yellow(`${process.pid}: emit event fromworker: [${id} ${i} Hello]`));
-                w1.emit('fromworker', id, i, 'Hello', (response: any) => {
-                    console.log(chalk.yellow(`${process.pid}: ${JSON.stringify(response)}`));
-                });
-                */
 
                 console.log(chalk.green(`${process.pid}: emit event fromworkerredis: [${id} ${i} Hello]`));
                 r1.emit('fromworkerredis', id, i, 'Hello', (response: any) => {
@@ -296,5 +470,6 @@ if (cluster.isPrimary) {
                 await Sleep(delay);
             }
         }, 1000);
+        */
     }, 1000);
 }