concurrency.js 0.0.3 → 0.0.5

package/src/worker.cluster.js

@@ -1,122 +0,0 @@
-/**
- * 
- * 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.cluster.threads.js

@@ -1,20 +0,0 @@
-/**
- * 
- * 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.cluster.threads.js
- * File Description: 
- * 
-*/
-
-/* eslint no-console: 0 */
-
-'use strict';
-
-const path = require("path");
-const fs = require("fs");
-

package/src/worker.process.js

@@ -1,128 +0,0 @@
-/**
- * 
- * 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 path = require("path");
-const fs = require("fs");
-const { sign } = require("crypto");
-
-
-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

@@ -1,84 +0,0 @@
-/**
- * 
- * 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,181 +0,0 @@
-/**
- * 
- * 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.js
- * File Description: 
- * 
-*/
-
-/* eslint no-console: 0 */
-
-'use strict';
-
-const path = require('path');
-const fs = require('fs');
-
-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, result });
-            });
-
-            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, result });
-            });
-
-            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" });
-                }
-                reject({ e, 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

@@ -1,44 +0,0 @@
-// /**
-//  * 
-//  * Package: 
-//  * Author: Ganesh B
-//  * Description: 
-//  * Install: npm i  --save
-//  * Github: https://github.com/ganeshkbhat/concurrency
-//  * npmjs Link: https://www.npmjs.com/package/concurrency.js
-//  * File: index.js
-//  * File Description: 
-//  * 
-// */
-
-// /* eslint no-console: 0 */
-
-// 'use strict';
-
-
-// const expect = require('chai').expect;
-
-// describe('test-.mjs::concurrency.js: Test Suite for concurrency.js Files', function() {
-
-
-//     before(async 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();
-//         // });
-
-//         it('[Test A] Test for ', function(done) {
-//             expect(100).to.equal(100);
-//             done();
-//         });
-
-//     });
-
-
-// });
-

package/test/demos.cluster.js

@@ -1,46 +0,0 @@
-// /**
-//  * 
-//  * 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 path = require("path");
-// let { _concurrencyClusters } = require("../index.js");
-
-// async function concurrency() {
-//     var responses;
-//     async function testPromise() {
-//         try {
-//             let filename = "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.cluster.js";
-//             responses = await _concurrencyClusters(
-//                 path.join(filename),
-//                 8,
-//                 {
-//                     data: {
-//                         message: "Testing parent data",
-//                         url: "https://www.google.com",
-//                     },
-//                     childData: "Test data from child"
-//                 }
-//             );
-//             return responses;
-//         } catch (e) {
-//             return e;
-//         }
-//     };
-//     return await testPromise();
-// }
-
-// module.exports.concurrency = concurrency();

package/test/demos.process.js

@@ -1,42 +0,0 @@
-/**
- * 
- * 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 path = require("path");
-let { _concurrencyProcesses } = require("../index.js");
-
-async function concurrency() {
-    var responses;
-    async function testPromise() {
-        try {
-            let filename = "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.process.js";
-            responses = await _concurrencyProcesses(
-                path.join(filename), {
-                data: {
-                    message: "Testing data",
-                    url: "https://www.google.com"
-                }
-            }, true);
-            return responses;
-        } catch (e) {
-            return e;
-        }
-    };
-    return await testPromise();
-}
-
-module.exports.concurrency = concurrency();