biz-a-cli 2.3.71 → 2.3.73

package/tests/hub.test.js

@@ -11,6 +11,9 @@ import { Writable, pipeline } from "node:stream";
 import { text } from "node:stream/consumers";
 import { directHubEvent, createSocketServer } from "../bin/directHubEvent.js";
 import os from "node:os";
+import { cliScriptWorkerPool } from "../worker/cliWorkerPool.js";
+import workerpool from "workerpool";
+import { isAsyncFunction } from "node:util/types";
 
 let socketsBySubdomain = {};
 
@@ -82,7 +85,9 @@ describe("Hub event tests", () => {
 
 	test("request to cli", async () => {
 		const logSpy = jest.spyOn(console, "log").mockImplementation();
-		let mockedRequest = jest.spyOn(axios, "request").mockReturnValue({ data: "OK" });
+		let mockedRequest = jest
+			.spyOn(axios, "request")
+			.mockReturnValue({ data: "OK" });
 
 		let socket;
 		try {
@@ -103,8 +108,8 @@ describe("Hub event tests", () => {
 						query: { subdomain: "abc" },
 						body: { data: "xyz" },
 					},
-					(cb) => resolve(cb)
-				)
+					(cb) => resolve(cb),
+				),
 			);
 
 			expect(result).toStrictEqual("OK");
@@ -123,8 +128,8 @@ describe("Hub event tests", () => {
 						query: { subdomain: "abc" },
 						body: { data: "xyz" },
 					},
-					(cb) => resolve(cb)
-				)
+					(cb) => resolve(cb),
+				),
 			);
 
 			expect(result).toStrictEqual("OK");
@@ -166,7 +171,13 @@ describe("Hub event tests", () => {
 				port: 212,
 				serverport: 3002,
 				cliAddress: () => {
-					return { ip: "59.60.1.22", port: "3002", address: `59.60.1.22:3002`, publicUrl: "https://some.tunnel.url", hubUrl: "https://some.hub.url" };
+					return {
+						ip: "59.60.1.22",
+						port: "3002",
+						address: `59.60.1.22:3002`,
+						publicUrl: "https://some.tunnel.url",
+						hubUrl: "https://some.hub.url",
+					};
 				},
 				hubServer: "https://some.hub.url",
 			});
@@ -174,10 +185,19 @@ describe("Hub event tests", () => {
 			mockAPIServer = net.createServer((clientSocket) => {
 				cliToAPISocket = clientSocket;
 				clientSocket.on("data", (data) => {
-					if (data.toString().toUpperCase() === "POST /SUCCESS HTTP/1.1") {
-						clientSocket.write("HTTP/1.1 200 Ok\r\nServer: datasnapHTTPService\r\n\r\n");
-					} else if (data.toString().toUpperCase() === "POST /FAIL HTTP/1.1") {
-						clientSocket.write("HTTP/1.1 403 Forbidden\r\nServer: datasnapHTTPService\r\n\r\n");
+					if (
+						data.toString().toUpperCase() ===
+						"POST /SUCCESS HTTP/1.1"
+					) {
+						clientSocket.write(
+							"HTTP/1.1 200 Ok\r\nServer: datasnapHTTPService\r\n\r\n",
+						);
+					} else if (
+						data.toString().toUpperCase() === "POST /FAIL HTTP/1.1"
+					) {
+						clientSocket.write(
+							"HTTP/1.1 403 Forbidden\r\nServer: datasnapHTTPService\r\n\r\n",
+						);
 					}
 				});
 			});
@@ -200,13 +220,19 @@ describe("Hub event tests", () => {
 						},
 					});
 					tunnelStream = await toPromise((resolve) => {
-						ss(socketsBySubdomain[subdomain]).once(uniqueId, (stream) => {
-							pipeline(stream, outputStream, (err) => {
-								if (err) console.error(err);
-							});
-							resolve(stream);
-						});
-						socketsBySubdomain[subdomain].emit("incomingClient", uniqueId);
+						ss(socketsBySubdomain[subdomain]).once(
+							uniqueId,
+							(stream) => {
+								pipeline(stream, outputStream, (err) => {
+									if (err) console.error(err);
+								});
+								resolve(stream);
+							},
+						);
+						socketsBySubdomain[subdomain].emit(
+							"incomingClient",
+							uniqueId,
+						);
 					});
 
 					tunnelStream.write(httpRawRequest);
@@ -224,10 +250,13 @@ describe("Hub event tests", () => {
 					"Server: datasnapHTTPService\r\n" +
 					"Access-Control-Expose-Headers: biza-cli-address, biza-hub-address\r\n" +
 					"biza-cli-address: https://some.tunnel.url\r\n" +
-					"biza-hub-address: https://some.hub.url\r\n\r\n"
+					"biza-hub-address: https://some.hub.url\r\n\r\n",
 			);
 
-			expect(await getResponse("POST /fail HTTP/1.1")).toBe("HTTP/1.1 403 Forbidden\r\n" + "Server: datasnapHTTPService\r\n\r\n");
+			expect(await getResponse("POST /fail HTTP/1.1")).toBe(
+				"HTTP/1.1 403 Forbidden\r\n" +
+					"Server: datasnapHTTPService\r\n\r\n",
+			);
 		} finally {
 			freeSocketClient(cliToBizAServerSocket);
 			if (mockAPIServer) mockAPIServer.close();
@@ -255,16 +284,26 @@ describe("Hub event tests", () => {
 				secure: false,
 				dbindex: 2,
 				cliAddress: () => {
-					return { ip: "59.60.1.22", port: "3002", address: `59.60.1.22:3002`, publicUrl: "https://some.tunnel.url", hubUrl: "https://some.hub.url" };
+					return {
+						ip: "59.60.1.22",
+						port: "3002",
+						address: `59.60.1.22:3002`,
+						publicUrl: "https://some.tunnel.url",
+						hubUrl: "https://some.hub.url",
+					};
 				},
 			});
-			clientToCliSocket = ioClient("http://localhost:9999", { query: { isClient: true } });
+			clientToCliSocket = ioClient("http://localhost:9999", {
+				query: { isClient: true },
+			});
 		});
 
 		afterAll(async () => {
 			freeSocketClient(clientToCliSocket);
 			if (cliSocketServer) {
-				await cliSocketServer.of("").sockets.forEach((sock) => sock.removeAllListeners());
+				await cliSocketServer
+					.of("")
+					.sockets.forEach((sock) => sock.removeAllListeners());
 				await cliSocketServer.close();
 			}
 		});
@@ -282,17 +321,28 @@ describe("Hub event tests", () => {
 				const [error, response] = await toPromise((resolve) => {
 					clientToCliSocket.emit(
 						"apiRequest",
-						{ subDomain: subdomain, method: "POST", path: "/test", headers: { "req-header": "aa" }, body: "body of request", responseType: "json" },
+						{
+							subDomain: subdomain,
+							method: "POST",
+							path: "/test",
+							headers: { "req-header": "aa" },
+							body: "body of request",
+							responseType: "json",
+						},
 						(err, res) => {
 							resolve([err, res]);
-						}
+						},
 					);
 				});
 
 				expect(response).toStrictEqual({
 					status: 200,
 					statusText: "Success",
-					headers: { "res-header": "aa", "biza-cli-address": "https://some.tunnel.url", "biza-hub-address": "https://some.hub.url" },
+					headers: {
+						"res-header": "aa",
+						"biza-cli-address": "https://some.tunnel.url",
+						"biza-hub-address": "https://some.hub.url",
+					},
 					body: "body of response",
 					url: `http://${apiAddress}:${port}/test`,
 				});
@@ -337,7 +387,7 @@ describe("Hub event tests", () => {
 						},
 						(err, res) => {
 							resolve([err, res]);
-						}
+						},
 					);
 				});
 
@@ -362,10 +412,16 @@ describe("Hub event tests", () => {
 				const [error, response] = await toPromise((resolve) => {
 					clientToCliSocket.emit(
 						"apiRequest",
-						{ subDomain: "wrong subdomain", method: "POST", path: "/test", headers: { "req-header": "aa" }, body: "body of request" },
+						{
+							subDomain: "wrong subdomain",
+							method: "POST",
+							path: "/test",
+							headers: { "req-header": "aa" },
+							body: "body of request",
+						},
 						(err, res) => {
 							resolve([err, res]);
-						}
+						},
 					);
 				});
 
@@ -385,15 +441,24 @@ describe("Hub event tests", () => {
 			test("status", async () => {
 				const runCommand = async (command) => {
 					return await toPromise((resolve) => {
-						clientToCliSocket.emit("cliCommand", { command }, (err, res) => {
-							resolve([err, res]);
-						});
+						clientToCliSocket.emit(
+							"cliCommand",
+							{ command },
+							(err, res) => {
+								resolve([err, res]);
+							},
+						);
 					});
 				};
 
 				let [error, response] = await runCommand("StAtus ");
 				const cpuArchitecture = os.arch();
-				const osArchitecture = ["x64", "arm64", "ppc64", "s390x"].includes(cpuArchitecture)
+				const osArchitecture = [
+					"x64",
+					"arm64",
+					"ppc64",
+					"s390x",
+				].includes(cpuArchitecture)
 					? "64-bit"
 					: ["ia32", "arm", "mips", "mipsel", "s390"].includes(cpuArchitecture)
 						? "32-bit"
@@ -413,6 +478,9 @@ describe("Hub event tests", () => {
 							minutes: expect.any(Number),
 							seconds: expect.any(Number),
 						}),
+						workers: {
+							cliScript: cliScriptWorkerPool.stats(),
+						},
 					},
 					api: {
 						address: `${apiAddress}:${port}`,
@@ -424,7 +492,10 @@ describe("Hub event tests", () => {
 						platform: os.platform(),
 						cpuCount: os.cpus().length,
 						memory: {
-							total: (os.totalmem / (1024 * 1024 * 1024)).toFixed(2) + " GB",
+							total:
+								(os.totalmem / (1024 * 1024 * 1024)).toFixed(
+									2,
+								) + " GB",
 							free: expect.any(String),
 							used: expect.any(String),
 						},
@@ -436,6 +507,154 @@ describe("Hub event tests", () => {
 				expect(response).toBe(null);
 				expect(error).toBe("Unknown CLI command 'invalid command'");
 			});
+
+			describe("runCLIScript", () => {
+				const runCommand = () =>
+					toPromise((resolve) => {
+						clientToCliSocket.emit(
+							"cliCommand",
+							{
+								command: "runCliScript",
+								scriptName: "sumScript",
+								scriptData: { x: 1, y: 2 },
+							},
+							(err, res) => {
+								resolve([err, res]);
+							},
+						);
+					});
+
+				test("shall used worker pool", async () => {
+					expect(cliScriptWorkerPool.workerType).toBe("thread"); // used node.js worker thread
+					expect(cliScriptWorkerPool.workerThreadOpts).toStrictEqual({
+						env: { NODE_ENV: process.env.NODE_ENV },
+					});
+
+					const execSpy = jest.spyOn(cliScriptWorkerPool, "exec");
+
+					execSpy.mockResolvedValueOnce("success");
+					await expect(runCommand()).resolves.toStrictEqual([
+						null,
+						"success",
+					]);
+					expect(execSpy.mock.calls.length).toBe(1);
+					expect(execSpy).toHaveBeenCalledWith("run", [
+						{
+							dbindex: 2,
+							subdomain,
+							url: `http://${apiAddress}:${port}`,
+						},
+						"sumScript",
+						{ x: 1, y: 2 },
+					]);
+					execSpy.mockReset();
+
+					execSpy.mockRejectedValueOnce("fail");
+					await expect(runCommand()).resolves.toStrictEqual([
+						"fail",
+						null,
+					]);
+					expect(execSpy.mock.calls.length).toBe(1);
+					expect(execSpy).toHaveBeenCalledWith("run", [
+						{
+							dbindex: 2,
+							subdomain,
+							url: `http://${apiAddress}:${port}`,
+						},
+						"sumScript",
+						{ x: 1, y: 2 },
+					]);
+					execSpy.mockReset();
+
+					// process beforeexit can not be reliably triggered or handled as expected within Jest's test environment, especially in worker thread scenario
+					// so we trigger the function directly
+					const workerpoolBeforeExit = process
+						.listeners("beforeexit")
+						.find(
+							(listener) =>
+								listener
+									.toString()
+									.toLowerCase()
+									.indexOf("cliscriptworkerpool") !== -1,
+						);
+					expect(isAsyncFunction(workerpoolBeforeExit)).toBeTruthy();
+					const terminateSpy = jest.spyOn(
+						cliScriptWorkerPool,
+						"terminate",
+					);
+					terminateSpy.mockReset();
+					workerpoolBeforeExit();
+					expect(terminateSpy.mock.calls.length).toBe(1);
+				});
+
+				test("shall used worker thread", async () => {
+					let mockAPIServer;
+					let scriptWorkerPool;
+					try {
+						// cannot used jest mocking because worker thread is running in different context.
+						// We must create http mock server, then direct worker request to the mock server
+						mockAPIServer = createServer((req, res) => {
+							res.writeHead(200, {
+								"Content-Type": "application/json",
+							});
+							res.end(
+								JSON.stringify([
+									{
+										"SYS$CLI_SCRIPT.SCRIPT": `get = function (lib) {
+                                        return {
+                                            functions: {
+                                                onInit: function (data) {
+                                                    return (data.x + data.y);
+                                                }
+                                            }
+                                        }
+                                    }`,
+									},
+								]),
+							);
+						});
+						await toPromise((resolve) => {
+							mockAPIServer.listen(
+								{ host: "127.0.0.1", port: 0 },
+								() => {
+									resolve();
+								},
+							);
+						});
+						scriptWorkerPool = workerpool.pool(
+							"./worker/cliScriptWorker.js",
+							{
+								workerType: "thread",
+								workerThreadOpts: {
+									env: { NODE_ENV: "production" },
+								},
+							},
+						); // set worker NODE_ENV, so logger will not print to console
+						const sumResult = await scriptWorkerPool
+							.exec("run", [
+								{
+									dbindex: 2,
+									subdomain,
+									url: `http://127.0.0.1:${mockAPIServer.address().port}`,
+								},
+								"sumScript",
+								{ x: 1, y: 2 },
+							])
+							.then(async (result) => {
+								await scriptWorkerPool.terminate();
+								return result;
+							})
+							.catch((err) => {
+								return err.message || err;
+							});
+						expect(sumResult).toBe(3);
+					} finally {
+						if (mockAPIServer) {
+							mockAPIServer.close();
+						}
+					}
+				});
+			});
 		});
 	});
 
@@ -472,9 +691,11 @@ describe("Hub event tests", () => {
 				},
 				(hubUrl) => {
 					expect(hubUrl).toBe("https://some.hub.url");
-				}
+				},
+			);
+			await toPromise((resolve) =>
+				cliToHubSocket.once("connect", () => resolve()),
 			);
-			await toPromise((resolve) => cliToHubSocket.once("connect", () => resolve()));
 		});
 
 		afterAll(async () => {
@@ -489,10 +710,17 @@ describe("Hub event tests", () => {
 				const [error, response] = await toPromise((resolve) => {
 					hubToCLISocket.emit(
 						"apiRequest",
-						{ subDomain: subdomain, method: "POST", path: "/test", headers: { "req-header": "aa" }, body: reqData, responseType: "json" },
+						{
+							subDomain: subdomain,
+							method: "POST",
+							path: "/test",
+							headers: { "req-header": "aa" },
+							body: reqData,
+							responseType: "json",
+						},
 						(err, res) => {
 							resolve([err, res]);
-						}
+						},
 					);
 				});
 				return { error, response };
@@ -513,7 +741,11 @@ describe("Hub event tests", () => {
 			expect(result.response).toStrictEqual({
 				status: 200,
 				statusText: "Success",
-				headers: { "res-header": "aa", "biza-cli-address": "https://some.tunnel.url", "biza-hub-address": "https://some.hub.url" },
+				headers: {
+					"res-header": "aa",
+					"biza-cli-address": "https://some.tunnel.url",
+					"biza-hub-address": "https://some.hub.url",
+				},
 				body: "body of response",
 				url: `http://127.0.0.1:${port}/test`,
 			});
@@ -531,11 +763,20 @@ describe("Hub event tests", () => {
 
 			// parameterize API address as String
 			mockedRequest.mockClear();
-			result = await emitApiRequest(JSON.stringify({ other: "data", apiAddress: "http://apiHost:apiPort" }));
+			result = await emitApiRequest(
+				JSON.stringify({
+					other: "data",
+					apiAddress: "http://apiHost:apiPort",
+				}),
+			);
 			expect(result.response).toStrictEqual({
 				status: 200,
 				statusText: "Success",
-				headers: { "res-header": "aa", "biza-cli-address": "https://some.tunnel.url", "biza-hub-address": "https://some.hub.url" },
+				headers: {
+					"res-header": "aa",
+					"biza-cli-address": "https://some.tunnel.url",
+					"biza-hub-address": "https://some.hub.url",
+				},
 				body: "body of response",
 				url: "http://apiHost:apiPort/test",
 			});
@@ -553,11 +794,18 @@ describe("Hub event tests", () => {
 
 			// parameterize API address as Object
 			mockedRequest.mockClear();
-			result = await emitApiRequest({ other: "data", apiAddress: "http://apiHost:apiPort" });
+			result = await emitApiRequest({
+				other: "data",
+				apiAddress: "http://apiHost:apiPort",
+			});
 			expect(result.response).toStrictEqual({
 				status: 200,
 				statusText: "Success",
-				headers: { "res-header": "aa", "biza-cli-address": "https://some.tunnel.url", "biza-hub-address": "https://some.hub.url" },
+				headers: {
+					"res-header": "aa",
+					"biza-cli-address": "https://some.tunnel.url",
+					"biza-hub-address": "https://some.hub.url",
+				},
 				body: "body of response",
 				url: "http://apiHost:apiPort/test",
 			});
@@ -578,17 +826,28 @@ describe("Hub event tests", () => {
 			test("status", async () => {
 				const runCommand = async (command) => {
 					return await toPromise((resolve) => {
-						hubToCLISocket.emit("cliCommand", { command }, (err, res) => {
-							resolve([err, res]);
-						});
+						hubToCLISocket.emit(
+							"cliCommand",
+							{ command },
+							(err, res) => {
+								resolve([err, res]);
+							},
+						);
 					});
 				};
 
 				let [error, response] = await runCommand("StAtus ");
 				const cpuArchitecture = os.arch();
-				const osArchitecture = ["x64", "arm64", "ppc64", "s390x"].includes(cpuArchitecture)
+				const osArchitecture = [
+					"x64",
+					"arm64",
+					"ppc64",
+					"s390x",
+				].includes(cpuArchitecture)
 					? "64-bit"
-					: ["ia32", "arm", "mips", "mipsel", "s390"].includes(cpuArchitecture)
+					: ["ia32", "arm", "mips", "mipsel", "s390"].includes(
+								cpuArchitecture,
+						  )
 						? "32-bit"
 						: `Unknown CPU architecture: ${cpuArchitecture}`;
 				expect(response).toMatchObject({
@@ -606,6 +865,9 @@ describe("Hub event tests", () => {
 							minutes: expect.any(Number),
 							seconds: expect.any(Number),
 						}),
+						workers: {
+							cliScript: cliScriptWorkerPool.stats(),
+						},
 					},
 					api: {
 						address: `${apiAddress}:${port}`,
@@ -617,7 +879,10 @@ describe("Hub event tests", () => {
 						platform: os.platform(),
 						cpuCount: os.cpus().length,
 						memory: {
-							total: (os.totalmem / (1024 * 1024 * 1024)).toFixed(2) + " GB",
+							total:
+								(os.totalmem / (1024 * 1024 * 1024)).toFixed(
+									2,
+								) + " GB",
 							free: expect.any(String),
 							used: expect.any(String),
 						},
@@ -629,6 +894,82 @@ describe("Hub event tests", () => {
 				expect(response).toBe(null);
 				expect(error).toBe("Unknown CLI command 'invalid command'");
 			});
+
+			describe("runCLIScript", () => {
+				test("shall used worker pool", async () => {
+					expect(cliScriptWorkerPool.workerType).toBe("thread"); // used node.js worker thread
+
+					const execSpy = jest.spyOn(cliScriptWorkerPool, "exec");
+					const runCommand = () =>
+						toPromise((resolve) => {
+							hubToCLISocket.emit(
+								"cliCommand",
+								{
+									command: "runCliScript",
+									scriptName: "sumScript",
+									scriptData: { x: 1, y: 2 },
+								},
+								(err, res) => {
+									resolve([err, res]);
+								},
+							);
+						});
+
+					execSpy.mockResolvedValueOnce("success");
+					await expect(runCommand()).resolves.toStrictEqual([
+						null,
+						"success",
+					]);
+					expect(execSpy.mock.calls.length).toBe(1);
+					expect(execSpy).toHaveBeenCalledWith("run", [
+						{
+							dbindex: 2,
+							subdomain,
+							url: `http://${apiAddress}:${port}`,
+						},
+						"sumScript",
+						{ x: 1, y: 2 },
+					]);
+					execSpy.mockReset();
+
+					execSpy.mockRejectedValueOnce("fail");
+					await expect(runCommand()).resolves.toStrictEqual([
+						"fail",
+						null,
+					]);
+					expect(execSpy.mock.calls.length).toBe(1);
+					expect(execSpy).toHaveBeenCalledWith("run", [
+						{
+							dbindex: 2,
+							subdomain,
+							url: `http://${apiAddress}:${port}`,
+						},
+						"sumScript",
+						{ x: 1, y: 2 },
+					]);
+					execSpy.mockReset();
+
+					// process beforeexit can not be reliably triggered or handled as expected within Jest's test environment, especially in worker thread scenario
+					// so we trigger the function directly
+					const terminateSpy = jest.spyOn(
+						cliScriptWorkerPool,
+						"terminate",
+					);
+					const workerpoolBeforeExit = process
+						.listeners("beforeexit")
+						.find(
+							(listener) =>
+								listener
+									.toString()
+									.toLowerCase()
+									.indexOf("cliscriptworkerpool") !== -1,
+						);
+					expect(isAsyncFunction(workerpoolBeforeExit)).toBeTruthy();
+					terminateSpy.mockReset();
+					workerpoolBeforeExit();
+					expect(terminateSpy.mock.calls.length).toBe(1);
+				});
+			});
 		});
 	});