@nsshunt/stsappframework 3.1.130 → 3.1.131

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);
 }

package/src/workerprocessbase.ts

@@ -12,6 +12,13 @@ import { v4 as uuidv4 } from 'uuid';
 
 import { STSTransportLoggerWinston } from './stsTransportLoggerWinston'
 
+import { RedisMessageHandler } from './redisMessageHandler';
+
+import { goptions } from '@nsshunt/stsconfig'
+
+import si from 'systeminformation' // https://systeminformation.io/
+import { GetFirstNetworkInterface } from './network'
+
 /**
  * todo
  * @typedef {Object} options - todo
@@ -21,6 +28,10 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
 {
     #inFlightMessage: IPCMessages = { }
     #requestResponseMessageTimeout = 2000; //@@ config
+    #redisMessageHandler: RedisMessageHandler | null = null;
+    #redisMessageHandlerPing: number = 1000;
+    #pingTimeout: NodeJS.Timeout | null = null;
+    #instanceId: string = uuidv4();
 
     constructor(options: ProcessOptions) {
         super(options);
@@ -120,14 +131,77 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
         return parentResponse;
     }
 
-    SetupServer = async () =>
-    {
+    SetupServer = async () => {
         this.SetupInstrumentation();
         setTimeout(() => {
             this.SetupServerEx();
         }, 100);
     }
 
+    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;
+    }
+
+    GetSystemTelemetry = async () => {
+        
+
+        // https://systeminformation.io/
+        const valueObject = {
+            system: '*',
+            osInfo: '*',
+            cpu: '*',
+            mem: '*',
+            dockerInfo: '*',
+            //dockerImages: '*',
+            dockerContainers: '*',
+        }
+    
+        const sysinfo = await si.get(valueObject);
+        const numCPUs = await this.GetNumCPUs();
+        const hostname = sysinfo.osInfo.hostname;
+        const hostaddr = GetFirstNetworkInterface();
+
+        const promArray: Promise<any>[] = [ ];
+    
+        sysinfo.dockerContainers.forEach((dc: { id: string; }) => {
+            const dcs = promArray.push(si.dockerContainerStats(dc.id));
+            console.log(dcs);
+        });
+        const dockerContainerStats = await Promise.all(promArray);
+    
+        const sysInfo = {
+            instanceId: this.#instanceId,
+            hostname,
+            numCPUs,
+            hostaddr,
+            system: sysinfo.system,
+            osInfo: sysinfo.osInfo,
+            cpu: sysinfo.cpu,
+            mem: sysinfo.mem,
+            dockerInfo: sysinfo.dockerInfo,
+            dockerContainers: sysinfo.dockerContainers,
+            dockerContainerStats
+        }
+
+        return sysInfo;
+    }
+
     SetupServerEx = async () => {
         this.ProcessStartup();
 		
@@ -192,8 +266,55 @@ export class WorkerProcessBase extends ServerProcessBase implements IWorkerProce
 
         await this.SetupSTSServer();
 
+        /*
+        this.#redisMessageHandler = new RedisMessageHandler({
+            logger: this.options.logger,
+            role: 'CLIENT',
+            redisUrl: goptions.imRedisMessageProcessorUrl,
+            namespace: 'stsServiceControl',
+            groups: [ ]
+        });
+        this.#redisMessageHandler.Start();
+
+        const ping = () => {
+            this.#pingTimeout = setTimeout(() => {
+                const pingData = {
+                    instanceId: this.#instanceId
+                }
+                if (this.#redisMessageHandler) {
+                    this.#redisMessageHandler.emit('ping_ex', pingData, (response: any) => {
+                        console.log(chalk.cyan(`  ==>> ${process.pid}: Response(ping): [${JSON.stringify(response)}]`));
+                    });
+                }
+                ping();
+            }, this.#redisMessageHandlerPing).unref();
+        }
+        ping();
+        */
+
+        //        this.#redisMessageHandler.on('GET_SYSTEM_TELEMETRY', async (getSystemTelemetryCommand: JSONObject, callback: any) => {
+        //          callback({ instanceId: this.#instanceId, process: process.pid, systemTelemetry: getSystemTelemetryCommand });
+        /*
+            if (getSystemTelemetryCommand.instanceId.localeCompare(this.#instanceId) === 0) {
+                const systemTelemetry = await this.GetSystemTelemetry();
+                callback({ systemTelemetry });
+            } else {
+                callback({ systemTelemetry: null });
+            }
+                */
+        //        });
+
         this.WorkerStarted();
 
         this.LogInfoMessage(chalk.green(`Worker process:${process.pid} started`));
     };
+
+    override ProcessTerminate(): Promise<void> {
+        //this.#redisMessageHandler?.off()
+        if (this.#pingTimeout) {
+            clearTimeout(this.#pingTimeout);
+        }
+        this.#redisMessageHandler?.Stop();
+        return super.ProcessTerminate();
+    }
 }

package/types/ipcMessageHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipcMessageHandler.d.ts","sourceRoot":"","sources":["../src/ipcMessageHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAgB,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAiB,MAAM,mBAAmB,CAAA;AAMzE,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,UAAU,CAAA;IAClB,6BAA6B,EAAE,MAAM,CAAA;IACrC,SAAS,EAAE,MAAM,CAAA;CAEpB;AAED,qBAAa,iBAAkB,SAAQ,WAAW;;gBAMlC,OAAO,EAAE,wBAAwB;IAU7C,IAAI,QAAQ,eAEX;IAED,YAAY,aAuBX;IAED,WAAW,aAuBV;IAED,WAAW,YAAmB,UAAU,KAAG,OAAO,CAAC,UAAU,CAAC,CAW7D;IAwBQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI;IAejD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI;IAQjD,KAAK,YAAa,MAAM,UAOvB;IAED,IAAI,aAOH;IAED,IAAI,MAAM,IAAI,MAAM,GAAG,IAAI,CAE1B;IAEQ,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CAcrD"}
+{"version":3,"file":"ipcMessageHandler.d.ts","sourceRoot":"","sources":["../src/ipcMessageHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAgB,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAiB,MAAM,mBAAmB,CAAA;AAMzE,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,UAAU,CAAA;IAClB,6BAA6B,EAAE,MAAM,CAAA;IACrC,SAAS,EAAE,MAAM,CAAA;CAEpB;AAED,qBAAa,iBAAkB,SAAQ,WAAW;;gBAMlC,OAAO,EAAE,wBAAwB;IAU7C,IAAI,QAAQ,eAEX;IAED,YAAY,aAwBX;IAED,WAAW,aAwBV;IAED,WAAW,YAAmB,UAAU,KAAG,OAAO,CAAC,UAAU,CAAC,CAW7D;IAwBQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI;IAejD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI;IAQjD,KAAK,YAAa,MAAM,UAOvB;IAED,IAAI,aAOH;IAED,IAAI,MAAM,IAAI,MAAM,GAAG,IAAI,CAE1B;IAEQ,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CAcrD"}