concurrency.js 0.0.1 → 0.0.3-beta

package/src/worker.cluster.js

@@ -0,0 +1,122 @@
+/**
+ * 
+ * Package: concurrency.js
+ * Author: Ganesh B
+ * Description: npm module to work with concurrency - worker threads and worker processes easily using simple functions and script files
+ * Install: npm i concurrency.js --save
+ * Github: https://github.com/ganeshkbhat/concurrency
+ * npmjs Link: https://www.npmjs.com/package/
+ * File: worker.process.js
+ * File Description: 
+ * 
+*/
+
+/* eslint no-console: 0 */
+
+'use strict';
+
+const cluster = require("node:cluster");
+const http = require("node:http");
+const { cpus } = require("node:os");
+const process = require("node:process");
+
+function _concurrencyClusters(filename = __filename, num = cpus().length, options = {}, greet = false) {
+    var worker, workers = {}, result = [];
+    var messageData = {}, childMessageData = [];
+
+    if (!options.handlers) {
+        options["handlers"] = {};
+    }
+
+    return new Promise((resolve, reject) => {
+        if (cluster.isPrimary) {
+            num = num || cpus().length;
+            for (let i = 0; i < num; i++) {
+                cluster.fork(filename, { env: { ...process.env, FORK: 1, childData: options.childData, handlers: { ...options.handlers } } });
+            }
+
+            for (const id in cluster.workers) {
+                messageData[id] = [];
+                cluster.workers[id].on("message", (msg) => {
+                    if (!messageData[id]) {
+                        messageData[id] = [];
+                    }
+                    messageData[id].push(msg);
+                    if (!!options.handlers.message) {
+                        const cbFunction = require(options.handlers.message);
+                        result.push({ return: cbFunction(msg), id: id, pid: process.pid, event: "message" });
+                    }
+                    if (!!msg.closeChild) {
+                        childMessageData.push(msg);
+                        cluster.workers[id].disconnect();
+                    }
+                    if (!Object.keys(cluster.workers).length) {
+                        resolve({ message: messageData, result: result });
+                    }
+                });
+
+                if (!!greet) {
+                    cluster.workers[id].send({ pid: process.pid, message: "Message from Parent: " + process.pid.toString() });
+                }
+
+                (!!options.data) ? cluster.workers[id].send({ id: id, pid: process.pid, message: options.data }) : null;
+
+                cluster.workers[id].on("error", function (e) {
+                    if (!!options.handlers.error) {
+                        const cbFunction = require(options.handlers.error);
+                        result.push({ return: cbFunction(e), id: id, pid: process.pid, event: "error" });
+                    }
+                    reject(e);
+                });
+
+                cluster.workers[id].on("close", function (code, signal) {
+                    if (!!options.handlers.close) {
+                        let connected = cluster.workers[id].isConnected();
+                        const cbFunction = require(options.handlers.close);
+                        // result.push(cbFunction(code, signal, pid, connected));
+                        result.push({ return: cbFunction(code, signal, pid, connected), id: id, pid: process.pid, event: "close" });
+                    }
+                });
+
+                cluster.workers[id].on("exit", (code) => {
+                    if (!!options.handlers.exit) {
+                        const cbFunction = require(options.handlers.exit);
+                        result.push({ return: cbFunction(code), id: id, pid: process.pid, event: "exit" });
+                    }
+                    if (!Object.keys(cluster.workers).length) {
+                        // console.log("exit called");
+                    }
+                });
+
+                cluster.workers[id].send({ closeChild: true })
+            }
+        } else if (cluster.isWorker) {
+            // } else {
+            // return new Promise((resolve, reject) => {
+            process.on("message", (msg) => {
+                childMessageData.push(msg);
+                // if (!!process.env.handlers.childMessage) {
+                //     const childCBFunction = require(process.env.handlers.childMessage);
+                //     result.push({ return: cbFunction(msg), pid: process.pid, event: "message" });
+                // }
+                if (!!msg.closeChild) {
+                    process.send({ closeChild: true, pid: process.pid, childMessageData: childMessageData, result: result });
+                }
+            });
+
+            if (!!greet) {
+                process.send({ pid: process.pid, message: "Message from worker: " + process.pid.toString() });
+            }
+
+            (!!process.env.childData) ? child.send({ pid: process.pid, message: process.env.childData }) : null;
+        }
+    });
+    
+}
+
+if (process.env.FORK) {
+    _concurrencyClusters();
+}
+
+
+module.exports._concurrencyClusters = _concurrencyClusters;

package/src/worker.process.js

@@ -1,12 +1,12 @@
 /**
  * 
- * Package: 
+ * Package: concurrency.js
  * Author: Ganesh B
- * Description: 
- * Install: npm i  --save
+ * Description: npm module to work with concurrency - worker threads and worker processes easily using simple functions and script files
+ * Install: npm i concurrency.js --save
  * Github: https://github.com/ganeshkbhat/concurrency
  * npmjs Link: https://www.npmjs.com/package/
- * File: index.js
+ * File: worker.process.js
  * File Description: 
  * 
 */
@@ -15,43 +15,114 @@
 
 'use strict';
 
+const path = require("path");
+const fs = require("fs");
+const { sign } = require("crypto");
 
-process.on('message', function (contents) {
-    return contents.callback(contents);
-}.bind(contents, process));
-
-// setInterval(() => {
-//     process.send("Message from parent:");
-// }, 1000);
-//
-// process.on('exit', function (code) {
-//     setTimeout(function () {
-//         console.log("This will not run");
-//     }, 0);
-//     console.log('About to exit with code:', code);
-// });
-//
-//
-// // Printing to console
-// process.stdout.write("Hello World!" + "\n");
-//
-// // Reading passed parameter
-// process.argv.forEach(function(val, index, array) {
-//    console.log(index + ': ' + val);
-// });
-//
-// // Getting executable path
-// console.log(process.execPath);
-//
-// // Platform Information
-// console.log(process.platform);
-//
-// // Print the current directory
-// console.log('Current directory: ' + process.cwd());
-//
-// // Print the process version
-// console.log('Current version: ' + process.version);
-//
-// // Print the memory usage
-// console.log(process.memoryUsage());
-//
+
+function _concurrencyProcesses(filename = __filename, options = {}, greet = false) {
+    var messageData = [], childMessageData = [], result = [];
+    if (!options.handlers) {
+        options["handlers"] = {};
+    }
+    if (process.env.FORK) {
+        if (!options.callback) {
+            options["callback"] = function (data) {
+                childMessageData.push(data);
+                if (!!process.env.handlers.childMessage) {
+                    const childCBFunction = require(process.env.handlers.childMessage);
+                    result.push({ message: childCBFunction(data), pid: process.pid, event: "message" });
+                }
+                if (!!data.closeChild) {
+                    process.send({ closeChild: true, pid: process.pid, childMessageData: childMessageData, result: result });
+                }
+            }
+        }
+
+        // process.stdout.on("message", console.log);
+        // process.stdin.on("message", console.log);
+        // process.stderr.on("message", console.log);
+
+        process.on("message", options.callback);
+
+        process.on("exit", (code) => {
+            // console.log(`worker.process.js: _concurrencyProcesses: Child Process PID:${process.pid}: EXIT CODE ${code} CHILD: `, childMessageData);
+            if (!!process.env.handlers.childExit) {
+                const cbFunction = require(process.env.handlers.childExit);
+                result.push({ message: cbFunction(code), pid: process.pid, event: "exit" });
+            }
+        });
+
+        if (!!greet) {
+            process.send({ pid: process.pid, message: `Child Process PID:${process.pid}: Hello from Child Process` });
+        }
+
+        (!!process.env.childData) ? child.send({ pid: process.pid, message: process.env.childData }) : null;
+
+    } else {
+
+        return new Promise((resolve, reject) => {
+            const { fork, spawn } = require("child_process");
+            const controller = new AbortController();
+            const { signal } = controller;
+
+            const child = fork(filename, {
+                signal: signal, silent: false, env: {
+                    ...process.env, FORK: 1, childData: options.childData, handlers: { ...options.handlers }
+                }
+            });
+
+            child.on("error", (e) => {
+                if (!!options.handlers.error) {
+                    const cbFunction = require(options.handlers.error);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "error" });
+                }
+                reject(e);
+            });
+
+            child.on("close", function (code, signal) {
+                let pid = child.pid, connected = child.connected;
+                if (!!options.handlers.close) {
+                    const cbFunction = require(options.handlers.close);
+                    result.push({ message: cbFunction(code, signal, pid, connected), pid: process.pid, event: "close" });
+                }
+            });
+
+            child.on("message", (data) => {
+                messageData.push(data);
+                if (!!options.handlers.message) {
+                    const cbFunction = require(options.handlers.message);
+                    result.push({ message: cbFunction(data), pid: process.pid, event: "message" });
+                }
+                if (!!data.closeChild) {
+                    // 
+                    // try {
+                    // // Stops the child process on message from child
+                    // // Getting Error: 
+                    // // AbortError: The operation was aborted
+                    //     controller.abort(); 
+                    // } catch (e) {
+                    //     child.kill(0);
+                    // } finally {
+                    //     resolve({ messageData, result });
+                    // }
+                    // 
+                    child.kill(0);
+                    resolve({ message: messageData, result: result });
+                }
+            });
+
+            if (!!greet) {
+                child.send({ pid: process.pid, message: `Master Process PID:${process.pid}: Hello from Master Process` });
+            }
+            options.data ? child.send({ pid: process.pid, message: options.data }) : null;
+            child.send({ closeChild: true });
+        });
+    }
+}
+
+if (process.env.FORK) {
+    _concurrencyProcesses();
+}
+
+module.exports._concurrencyProcesses = _concurrencyProcesses;

package/src/worker.thread.async.js

@@ -0,0 +1,84 @@
+/**
+ * 
+ * Package: concurrency.js
+ * Author: Ganesh B
+ * Description: npm module to work with concurrency - worker threads and worker processes easily using simple functions and script files
+ * Install: npm i concurrency.js --save
+ * Github: https://github.com/ganeshkbhat/concurrency
+ * npmjs Link: https://www.npmjs.com/package/
+ * File: worker.threads.async.js
+ * File Description: 
+ * 
+ * https://github.com/danday74/shelljs.exec
+ * 
+ * 
+*/
+
+/* eslint no-console: 0 */
+
+'use strict';
+
+var cp = require('child_process');
+
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+function toBoolean(bool) {
+    if (bool === 'false') bool = false;
+    return !!bool;
+}
+
+function normaliseOptions(options) {
+
+    var DEFAULTS = Object.freeze({
+        encoding: 'utf8',
+        silent: false
+    })
+
+    if (!isObject(options)) {
+        options = {}
+    } else {
+        if (typeof options.silent !== 'undefined') {
+            options.silent = toBoolean(options.silent);
+        }
+    }
+
+    options = Object.assign({}, DEFAULTS, options);
+
+    if (options.silent && typeof options.stdio === 'undefined') {
+        options.stdio = 'pipe';
+    }
+
+    return options;
+}
+
+function _concurrencyThreadsAsync(command, options) {
+
+    options = normaliseOptions(options);
+    var error, stdout, stderr, code, ok;
+
+    try {
+        error = null
+        stdout = cp.execSync("node " + command, options)
+        stderr = ''
+        code = 0
+        ok = true
+    } catch (e) {
+        error = e
+        stdout = e.stdout
+        stderr = e.stderr
+        code = e.status || /* istanbul ignore next */ 1
+        ok = false
+    }
+
+    return {
+        error: error,
+        stdout: stdout,
+        stderr: stderr,
+        code: code,
+        ok: ok
+    }
+}
+
+module.exports._concurrencyThreadsAsync = _concurrencyThreadsAsync;

package/src/worker.threads.js

@@ -1,12 +1,12 @@
 /**
  * 
- * Package: 
+ * Package: concurrency.js
  * Author: Ganesh B
- * Description: 
- * Install: npm i  --save
+ * Description: npm module to work with concurrency - worker threads and worker processes easily using simple functions and script files
+ * Install: npm i concurrency.js --save
  * Github: https://github.com/ganeshkbhat/concurrency
  * npmjs Link: https://www.npmjs.com/package/
- * File: index.js
+ * File: worker.threads.js
  * File Description: 
  * 
 */
@@ -15,9 +15,168 @@
 
 'use strict';
 
+const path = require('path');
+const fs = require('fs');
 
-const { parentPort } = require("worker_threads");
 
-parentPort.on("message", function (contents) {
-    return contents.callback(contents, parentPort);
-}.bind(contents, parentPort));
+
+function _concurrencyThreads(filename = __filename, options = {}, greet = false) {
+    const { Worker, isMainThread, parentPort } = require('worker_threads');
+
+    var messageData = [], childMessageData = [], result = [];
+    if (!options.handlers) { options["handlers"] = {}; }
+
+    return new Promise((resolve, reject) => {
+        if (isMainThread) {
+            // return new Promise((resolve, reject) => {
+            const worker = new Worker(filename);
+            if (!!greet) {
+                worker.postMessage({ pid: process.pid, message: `Hello, world! - Server: ${process.pid}` });
+            }
+
+            worker.on("connection", (e) => {
+                // console.log(`Main thread ${process.pid} due to connection event`, e.toString());
+                if (!!options.handlers.connection) {
+                    const cbFunction = require(options.handlers.connection);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "connection" });
+                }
+            });
+
+            worker.on("message", function (mainData) {
+                messageData.push({ ...mainData, threadId: worker.threadId });
+                if (!!options.handlers.message) {
+                    const cbFunction = require(options.handlers.message);
+                    result.push({ message: cbFunction(mainData), pid: process.pid, event: "message" });
+                }
+                if (!!mainData.closeChild) {
+                    mainData = { ...mainData, threadId: worker.threadId };
+                    childMessageData.push(mainData);
+                    try {
+                        worker.unref();
+                    } catch (e) {
+                        worker.terminate();
+                    }
+                    resolve({ message: messageData, result: result });
+                }
+                // console.log(`demo.threads.js:_concurrencyThreads: Main Thread PID ${process.pid}, filename: ${filename}, data: ${mainData}`);
+            });
+
+            worker.on("online", () => {
+                if (!!options.handlers.online) {
+                    const cbFunction = require(options.handlers.online);
+                    result.push({ message: cbFunction(), pid: process.pid, event: "online" });
+                }
+            });
+
+            worker.on("error", (e) => {
+                if (!!options.handlers.error) {
+                    const cbFunction = require(options.handlers.error);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "error" });
+                }
+                reject(e)
+            });
+
+            worker.on("messageerror", (e) => {
+                if (!!options.handlers.messageerror) {
+                    const cbFunction = require(options.handlers.messageerror);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "messageerror" });
+                }
+                reject(e)
+            });
+
+            worker.on("close", (e) => {
+                console.log(`demo.threads.js:_concurrencyThreads: Main Thread PID ${process.pid} threadID:${worker.threadId} : Closing main thread `, e.toString(), messageData);
+                worker.unref();
+                if (!!options.handlers.close) {
+                    const cbFunction = require(options.handlers.close);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "close" });
+                }
+                // resolve({ messageData, result });
+            });
+
+            worker.on("exit", (code) => {
+                console.log(`demo.threads.js:_concurrencyThreads: Main Thread PID ${process.pid} threadID:${worker.threadId}, filename: ${filename}, ExitCode: ${code}, messageData`, messageData);
+                if (!!options.handlers.exit) {
+                    const cbFunction = require(options.handlers.exit);
+                    result.push({ message: cbFunction(code), pid: process.pid, event: "exit" });
+                }
+                if (code !== 0) {
+                    reject(new Error(`Worker (PID ${process.pid}) threadID:${worker.threadId} stopped with exit code ${code}`));
+                }
+                // reject(new Error(`Worker (PID ${process.pid}) threadID:${worker.threadId} stopped with exit code ${code}`));
+            });
+            worker.postMessage({ closeChild: true });
+            // });
+
+        } else {
+
+            if (!options.callback) {
+
+                // options.callback = function (contents) {
+                //     console.log("Testing worker");
+                //     const { get } = (options.protocol === "https") ? require("https") : require("http");
+                //     get(contents.url, (res) => {
+                //         let result = "";
+                //         res.on("data", (chunk) => result += chunk);
+                //         res.on("end", () => {
+                //             parentPort.postMessage(result);
+                //         });
+                //     }).on("error", (err) => parentPort.postMessage(err));
+                // }.bind(null, null, options);
+
+                options.callback = function (mainData) {
+                    // return options.callback(data, parentPort);
+                    // console.log(`demo.threads.js:_concurrencyThreads: Thread: Child Thread PID ${process.pid}, messageData: `, mainData);
+                    childMessageData.push(mainData);
+                    if (!!options.handlers.childMessage) {
+                        const childCBFunction = require(options.handlers.childMessage);
+                        result.push({ message: childCBFunction(mainData), pid: process.pid, event: "message" });
+                    }
+                    if (!!mainData.closeChild) {
+                        parentPort.postMessage({ closeChild: true, pid: process.pid, childMessageData: childMessageData, result: result });
+                    }
+                }
+            }
+
+            parentPort.on("connection", (e) => {
+                console.log(`demo.threads.js:_concurrencyThreads: Thread PID ${process.pid}: Child thread due to connection event `, e.toString())
+                if (!!options.handlers.childConnection) {
+                    const childCBFunction = require(options.handlers.childConnection);
+                    result.push({ message: childCBFunction(e), pid: process.pid, event: "connection" });
+                }
+            });
+
+            parentPort.on("message", options.callback);
+
+            parentPort.on("error", (e) => {
+                console.log(`demo.threads.js:_concurrencyThreads: Thread PID ${process.pid}:Closing child thread due to error`, e.toString());
+                if (!!options.handlers.childError) {
+                    const cbFunction = require(options.handlers.childError);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "error" });
+                }
+            });
+
+            parentPort.on("messageerror", (e) => {
+                console.log(`demo.threads.js:_concurrencyThreads: Thread PID ${process.pid}: Closing child thread due to messageerror`, e.toString());
+                if (!!options.handlers.messageerror) {
+                    const cbFunction = require(options.handlers.messageerror);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "messageerror" });
+                }
+            });
+
+            parentPort.on("close", (e) => {
+                console.log(`demo.threads.js:_concurrencyThreads: Thread PID ${process.pid}: Closing child thread due to close event`, e.toString());
+                if (!!options.handlers.close) {
+                    const cbFunction = require(options.handlers.close);
+                    result.push({ message: cbFunction(e), pid: process.pid, event: "close" });
+                }
+            });
+
+            if (!!greet) {
+                parentPort.postMessage({ pid: process.pid, message: `"Hello from child. - Thread: ${process.pid}` });
+            }
+        }
+    });
+}
+
+module.exports._concurrencyThreads = _concurrencyThreads;

package/test/_.test-template.js

@@ -5,7 +5,7 @@
 //  * Description: 
 //  * Install: npm i  --save
 //  * Github: https://github.com/ganeshkbhat/concurrency
-//  * npmjs Link: https://www.npmjs.com/package/
+//  * npmjs Link: https://www.npmjs.com/package/concurrency.js
 //  * File: index.js
 //  * File Description: 
 //  * 
@@ -18,7 +18,7 @@
 
 // const expect = require('chai').expect;
 
-// describe('test-.mjs::require-urls: Test Suite for require-urls Files', function() {
+// describe('test-.mjs::concurrency.js: Test Suite for concurrency.js Files', function() {
 
 
 //     before(async function(){
@@ -26,7 +26,7 @@
 //     });
 
 
-//     describe ('test-.js::require-urls: [Test A] Test Suite for require-urls in main repo directory', function() {
+//     describe ('test-.js::concurrency.js: [Test A] Test Suite for concurrency.js in main repo directory', function() {
 //         // it('[Test A] Test for ', function(done){
 //         //     expect(200).to.equal(200);
 //         //     done();