concurrency.js 0.0.2 → 0.0.3-beta

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

package/test/test_demos_cluster.js

@@ -0,0 +1,109 @@
+// /**
+//  * 
+//  * 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  --save
+//  * Github: https://github.com/ganeshkbhat/concurrency
+//  * npmjs Link: https://www.npmjs.com/package/concurrency.js
+//  * File: test.demos.cluster.js
+//  * File Description: 
+//  * 
+// */
+
+// /* eslint no-console: 0 */
+
+// 'use strict';
+
+
+// const expect = require('chai').expect;
+// const path = require("path");
+
+// const { _concurrencyClusters } = require("../index.js");
+
+// describe('test-.js::concurrency.js: [Test A] Test Suite for concurrency.js cluster in main repo directory', function () {
+
+//     it('[Test A] Test for cluster function demos', async function (done) {
+
+//         async function res() {
+//             var responses;
+//             async function concurrency() {
+//                 let filename = "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.cluster.js";
+//                 return new Promise(function (resolve, reject) {
+//                     _concurrencyClusters(
+//                         path.join(filename), 8,
+//                         {
+//                             data: {
+//                                 message: "Testing parent data",
+//                                 url: "https://www.google.com",
+//                             },
+//                             childData: "Test data from child"
+//                         }
+//                     ).then((d) => {
+//                         console.log("Data fetched", JSON.stringify(d));
+//                         resolve(d);
+//                     }).catch((e) => {
+//                         console.log(e.toString());
+//                         reject(e);
+//                     });
+//                 });
+//             }
+
+//             responses = await concurrency();
+//             return responses;
+//         }
+
+//         let response = res();
+//         // .catch((e) => {
+//         //     console.log(e.toString());
+//         //     expect(!!e.toString()).to.equal(true);
+//         //     done();
+//         // });
+
+//         // "1":[{"closeChild":true,"pid":7468,"childMessageData":[{"id":"1","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["1"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["1"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["1"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "2":[{"closeChild":true,"pid":13784,"childMessageData":[{"id":"2","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["2"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["2"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["2"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "3":[{"closeChild":true,"pid":872,"childMessageData":[{"id":"3","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["3"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["3"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["3"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "4": [{"closeChild":true,"pid":11732,"childMessageData":[{"id":"4","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["4"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["4"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["4"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "5":[{"closeChild":true,"pid":7468,"childMessageData":[{"id":"5","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["5"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["5"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["5"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "6":[{"closeChild":true,"pid":13784,"childMessageData":[{"id":"6","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["6"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["6"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["6"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "7":[{"closeChild":true,"pid":872,"childMessageData":[{"id":"7","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["7"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["7"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["7"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "8": [{"closeChild":true,"pid":11732,"childMessageData":[{"id":"8","pid":9744,"message":{"message":"Testing parent data","url":"https://www.google.com"}},{"closeChild":true}],"result":[]}]
+//         expect(JSON.stringify(response.message["8"][0]["closeChild"])).to.equal(true);
+//         expect(JSON.stringify(response.message["8"][0]["childMessageData"][0]["id"])).to.equal(1);
+//         expect(JSON.stringify(response.message["8"][0]["childMessageData"][0]["message"])).to.equal({ "message": "Testing parent data", "url": "https://www.google.com" });
+
+//         // "result":[]
+//         expect(JSON.stringify(response.result)).to.equal(JSON.stringify([]));
+//         done();
+//         process.exit();
+//     });
+
+// });

package/test/test_demos_process.js

@@ -0,0 +1,49 @@
+// /**
+//  * 
+//  * 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  --save
+//  * Github: https://github.com/ganeshkbhat/concurrency
+//  * npmjs Link: https://www.npmjs.com/package/concurrency.js
+//  * File: test.demos.process.js
+//  * File Description: 
+//  * 
+// */
+
+// /* eslint no-console: 0 */
+
+// 'use strict';
+
+
+// const expect = require('chai').expect;
+// const path = require("path");
+// const { _concurrencyProcesses } = require("../index.js");
+
+
+// describe('test-.js::concurrency.js: [Test A] Test Suite for concurrency.js .process in main repo directory', function () {
+
+//     it('[Test A] Test for process function demos', async function (done) {
+//         var responses;
+//         let filename = "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.process.js";
+//         responses = await _concurrencyProcesses(path.join(filename), { data: { url: "https://www.google.com", message: "Testing data" } });
+
+//         // console.log(responses.message);
+//         // console.log(responses.result);
+//         // console.log(responses.message[0].childMessageData);
+//         // console.log(responses.message[0].childMessageData[0]);
+//         // console.log(responses.message[0].childMessageData[0].message);
+//         // console.log(responses.message[0].childMessageData[0].message.url);
+//         // console.log(responses.message[0].childMessageData[0].message.message);
+//         // console.log(responses.message[0].childMessageData[0].pid);
+//         // console.log(responses.message[0].childMessageData[1].closeChild);
+//         // console.log(responses.message[0].pid);
+//         // console.log(responses.message[0].closeChild);
+//         // console.log(responses.message[0].result);
+
+//         expect(true).to.equal(true);
+//         // done();
+//         // process.exit();
+//     });
+
+// });