@nsshunt/stsrunnerframework 2.0.33 → 2.0.34

package/dist/index.mjs

@@ -65,6 +65,8 @@ var eIWMessageCommands = /* @__PURE__ */ function(eIWMessageCommands) {
 	eIWMessageCommands["GetRunnersResponse"] = "__STS__GetRunnersResponse";
 	eIWMessageCommands["PostWorkerMessage"] = "__STS__PostWorkerMessage";
 	eIWMessageCommands["PostWorkerMessageResponse"] = "__STS__PostWorkerMessageResponse";
+	eIWMessageCommands["PostWorkerPreTerminateMessage"] = "__STS__PostWorkerPreTerminateMessage";
+	eIWMessageCommands["PostWorkerPreTerminateMessageResponse"] = "__STS__PostWorkerPreTerminateMessageResponse";
 	return eIWMessageCommands;
 }({});
 var IRunnerState = /* @__PURE__ */ function(IRunnerState) {
@@ -1036,6 +1038,25 @@ var AbstractRunnerExecutionWorker = class {
 			this.#error(`#PostWorkerMessageToWorkerManager(): [${error}]`);
 		}
 	};
+	#PostWorkerPreTerminateMessageToWorkerManager = async (messagePayload) => {
+		try {
+			if (this.#collectorCollectorPort) {
+				const response = await this.ProcessPreTerminateWorkerMessage(messagePayload);
+				const message = {
+					command: eIWMessageCommands.PostWorkerMessageResponse,
+					payload: {
+						messageId: messagePayload.payload.messageId,
+						workerId: this.#workerId,
+						response
+					}
+				};
+				this.#collectorCollectorPort.postMessage(message);
+				await Sleep(0);
+			}
+		} catch (error) {
+			this.#error(`#PostWorkerPreTerminateMessageToWorkerManager(): [${error}]`);
+		}
+	};
 	/**
 	* Start a runner and, if valid, launch its execution loop.
 	*
@@ -1419,6 +1440,9 @@ var AbstractRunnerExecutionWorker = class {
 	async ProcessGenericWorkerMessage(messagePayload) {
 		return {};
 	}
+	async ProcessPreTerminateWorkerMessage(messagePayload) {
+		return {};
+	}
 	/**
 	* Main inbound message dispatcher for this worker runtime.
 	*
@@ -1502,6 +1526,10 @@ var AbstractRunnerExecutionWorker = class {
 					this.#silly(`ProcessMessage::PostWorkerMessage`);
 					this.#PostWorkerMessageToWorkerManager(payloadMessage);
 					break;
+				case eIWMessageCommands.PostWorkerPreTerminateMessage:
+					this.#silly(`ProcessMessage::PostWorkerPreTerminateMessage`);
+					this.#PostWorkerPreTerminateMessageToWorkerManager(payloadMessage);
+					break;
 				default: this.#warn(`ProcessMessage::default: Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
 			}
 		} catch (error) {
@@ -4485,13 +4513,24 @@ var WorkerInstance = class {
 		try {
 			const runners = this.GetAllRunnersEx();
 			const promArray = [];
+			const microDelayForPreTerminate = 500;
+			const microDelayForTerminate = 500;
 			for (let i = 0; i < runners.length; i++) promArray.push(runners[i].Terminate());
 			const retVal = Promise.all(promArray);
-			if (this.worker) setTimeout(() => {
-				this.worker.terminate();
-				this.#logger.debug(`_TerminateWorker(): Terminated worker: [${this.id}]`);
-				this.#workerRegistry.DeleteWorker(this.id);
-			}, 500);
+			if (this.worker) {
+				await Sleep(microDelayForPreTerminate);
+				this.#logger.debug(chalk.rgb(150, 170, 90)(`Terminate(): Sending Pre Terminate worker command ...`));
+				const retValPreTerminate = await this.#messageBroker.SendMessageToWorkerForWorkerWithCallBack(this, eIWMessageCommands.PostWorkerPreTerminateMessage, {});
+				this.#logger.debug(chalk.rgb(150, 170, 90)(`Terminate(): Pre Terminate worker response: [${JSON.stringify(retValPreTerminate, null, 2)}]`));
+			}
+			setTimeout(() => {
+				if (this.worker) if (this.options.mocked === false) {
+					this.worker.terminate();
+					this.#logger.debug(`Terminate(): Terminated worker: [${this.id}]`);
+					this.#workerRegistry.DeleteWorker(this.id);
+				} else this.#logger.debug(`Terminate(): Terminated worker: [${this.id}] (Mocked)`);
+				else this.#logger.warn(`Terminate(): Could not terminate worker: [${this.id}] - this.worker not set`);
+			}, microDelayForTerminate);
 			return retVal;
 		} catch (error) {
 			this.#logger.error(`_TerminateWorker(): Error: [${error}]`);
@@ -6611,7 +6650,7 @@ var STSWorkerManager = class {
 	* - this does not automatically terminate all workers
 	* - callers should explicitly terminate workers first if desired
 	*/
-	Terminate() {
+	async Terminate() {
 		this.options.logger.debug(`STSWorkerManager:Terminate()`);
 		this.#archiveManager.Terminate();
 	}