@nsshunt/stsappframework 3.0.95 → 3.0.96

package/src_working/workerprocessbase.ts

@@ -0,0 +1,185 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import debugModule from 'debug'
+const debug = debugModule(`proc:${process.pid}`);
+
+import { Gauge, InstrumentGaugeTelemetry } from '@nsshunt/stsinstrumentation'
+import { JSONObject } from '@nsshunt/stsutils'
+import { ProcessOptions } from './processoptions'
+import { IPCMessage, IPCMessages, IPCMessagePayload, IPCMessageCommand, IWorkerProcessBase } from './commonTypes'
+import { STSExpressServer } from './server';
+import { ServerProcessBase } from './serverprocessbase'
+
+import { v4 as uuidv4 } from 'uuid';
+
+import colors from 'colors'
+
+/**
+ * todo
+ * @typedef {Object} options - todo
+ * @property {boolean} [wssServer=false] - Create a web socket server on this worker instance
+ */
+export class WorkerProcessBase extends ServerProcessBase implements IWorkerProcessBase
+{
+    #inFlightMessage: IPCMessages = { }
+    #requestResponseMessageTimeout = 2000; //@@ config
+
+    constructor(options: ProcessOptions) {
+        super(options);
+    }
+
+    WorkerStarted() {
+        return null;
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+    ReceivedMessageFromMaster(msg: any) {
+        // Override in subclass if required
+    }
+
+    override CollectAdditionalTelemetry(): void {
+        this.httpServer.getConnections((error: any, count: any) => {
+            //@@this.instruments[Gauge.CONNECTION_COUNT_GAUGE].val = count;
+            this.UpdateInstrument(Gauge.CONNECTION_COUNT_GAUGE, {
+                val: count
+            } as InstrumentGaugeTelemetry);
+        });
+    }
+
+    #SendMessageToParentProcess = (message: IPCMessagePayload): Promise<JSONObject> => {
+        return new Promise((resolve, reject) => {
+            if (this.#inFlightMessage[message.id]) {
+                reject(`Message with id: [${message.id}] already exists within the Request/Response record structure`);
+            } else {
+                this.#inFlightMessage[message.id] = {
+                    iPCMessagePayload: { ...message },
+                    cb: () => {
+                        const detail: JSONObject = this.#inFlightMessage[message.id].iPCMessagePayload.responseDetail as JSONObject
+                        clearTimeout(this.#inFlightMessage[message.id].timeout);
+                        setTimeout(() => {
+                            delete this.#inFlightMessage[message.id];
+                        }, 0).unref();
+                        debug(`Resolving response message with id: [${message.id}] from parent process via IPC. Details: [${JSON.stringify(this.#inFlightMessage[message.id].iPCMessagePayload)}]`.green);
+                        resolve(detail);
+                    },
+                    timeout: setTimeout(() => {
+                        setTimeout(() => {
+                            delete this.#inFlightMessage[message.id];
+                        }, 0).unref();
+                        debug(`Timeout has occurred after: [${this.#requestResponseMessageTimeout}]ms with message id: [${message.id}]. Details: [${JSON.stringify(this.#inFlightMessage[message.id].iPCMessagePayload)}]`.red);						
+                        reject('Did not receive response form parent process.');
+                    }, this.#requestResponseMessageTimeout) // max message timeout allowed
+                }
+                debug(`Sending message with id: [${message.id}] to parent process via IPC. Details: [${JSON.stringify(this.#inFlightMessage[message.id].iPCMessagePayload)}]`.yellow);
+                (process as any).send(message);
+            }
+        });
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    AddWorker = async (options: any): Promise<string> => {
+        const workerResponse: JSONObject = await this.#SendMessageToParentProcess({
+            requestResponse: true,
+            id: uuidv4(),
+            command: IPCMessageCommand.AddWorker,
+            requestDetail: {
+                options
+            }
+        });
+        return workerResponse.workerId;
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    DeleteWorker = async (workerId: string, options: any): Promise<JSONObject> => {
+        const workerResponse: JSONObject = await this.#SendMessageToParentProcess({
+            requestResponse: true,
+            id: uuidv4(),
+            command: IPCMessageCommand.DeleteWorker,
+            requestDetail: {
+                options,
+                workerId
+            }
+        });
+        return workerResponse;
+    }
+
+    ProcessTerminating = async (): Promise<void> => {
+        return;
+    }
+
+    SetupServer = async () =>
+    {
+        this.SetupInstrumentation();
+        setTimeout(() => {
+            this.SetupServerEx();
+        }, 100);
+    }
+
+    SetupServerEx = async () => {
+        this.ProcessStartup();
+		
+        if (this.options.expressServerRouteFactory || this.options.expressServerRouteStaticFactory) {
+            this.expressServer = new STSExpressServer(this.options, this);
+        }
+
+        this.LogEx(`Worker instance starting. Service instance Id: [${this.options.serviceInstanceId}]`);
+
+        // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+        process.on('message', async (msg: any) => {
+            if (msg.requestResponse) {
+                const iPCMessagePayload: IPCMessagePayload = msg as IPCMessagePayload;
+                if (iPCMessagePayload.id) {
+                    if (this.#inFlightMessage[iPCMessagePayload.id]) {
+                        const responseMessage: IPCMessage = this.#inFlightMessage[iPCMessagePayload.id];
+                        responseMessage.iPCMessagePayload.responseDetail = { ...iPCMessagePayload.responseDetail }
+                        responseMessage.cb();
+                    } else {
+                        throw new Error(`Could not find Request/Response message with id: [${iPCMessagePayload.id}]`);
+                    }
+                } else {
+                    throw new Error(`Message does not have id attribute. [${JSON.stringify(iPCMessagePayload)}]`);
+                }
+                return;
+            }
+            if (msg.command) //@@ constants
+            {
+                switch (msg.command)
+                {
+                case 'Terminate' :
+                    this.LogEx((`Received ` + colors.bold(`Terminate`.italic) + ` message from master thread`).gray);
+                    await this.Terminate(true, false); // Don't kill the child process here, the master will take care of that ...
+                    break;
+                case 'TerminateAndKill' :
+                    this.LogEx((`Received ` + colors.bold(`Terminate`.italic) + ` message from master thread`).gray);
+                    await this.Terminate(true, true);
+                    break;
+                case 'Message' :
+                    //this.LogEx((`Received ` + colors.bold(`Message`.italic) + ` message from master thread`).gray);
+                    this.ReceivedMessageFromMaster(msg.data);
+                    break;
+                case 'Response' : // General response to a req/response interaction
+                    msg.details
+                }
+            }
+        });
+
+        // Signal Codes
+        // https://en.wikipedia.org/wiki/Signal_(IPC)
+        process.on('SIGTERM', async () =>
+        {
+            this.LogEx(`SIGTERM signal received for worker: ${process.pid}`);
+            await this.Terminate(true, true);
+        });
+
+        process.on('SIGINT', async () =>
+        {
+            this.LogEx(`SIGINT signal received for worker: ${process.pid}`);
+            await this.Terminate(true, true);
+        });
+
+        await this.SetupSTSServer();
+
+        this.WorkerStarted();
+
+        this.LogEx(`Worker process:${process.pid} started`.green);
+    };
+}