concurrency.js 0.0.2 → 0.0.3-beta

package/README.md

@@ -1,3 +1,119 @@
 # concurrency.js
+
 npm module to work with concurrency - worker threads and worker processes easily using simple functions and script files
-  
+
+Find the demos in the [demos folder](./demos)
+
+#### Cluster Methods
+
+
+`_concurrencyClusters(filename = __filename, num = cpus().length, options = {}, greet = false)`
+
+```
+
+const path = require("path");
+let { _concurrencyClusters } = require("concurrency.js");
+
+function concurrency() {
+    return new Promise(function (resolve, reject) {
+        _concurrencyClusters(
+            path.join("C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.cluster.js"),
+            8,
+            {
+                data: {
+                    data: "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);
+        });
+    });
+}
+concurrency();
+
+```
+
+#### Process Methods
+
+
+`_concurrencyProcesses(filename = __filename, options = {}, greet = false)`
+
+```
+
+const path = require("path");
+let { _concurrencyProcesses } = require("concurrency.js");
+_concurrencyProcesses(
+    path.join(
+    "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.process.js"),
+    {
+        data: {
+            message: "Testing data",
+            url: "https://www.google.com"
+        }
+    },
+    true
+    ).then((d) => { console.log("Data fetched: ", JSON.stringify(d)); })
+    .catch((e) => { console.log(e.toString()); setTimeout(() => { process.exit(e); }, 5000) })
+
+```
+
+#### Threads Methods
+
+
+`_concurrencyThreads(filename = __filename, options = {}, greet = false)`
+
+```
+
+const path = require("path");
+let { _concurrencyThreads } = require("concurrency.js");
+_concurrencyThreads(
+    __filename,
+    {
+        data: {
+            url: "https://www.google.com",
+            data: "Testing data"
+        },
+        childData: "Testing child data"
+    },
+    true
+).then((d) => console.log(JSON.stringify(d)));
+
+```
+
+#### Thread Async Methods
+
+
+`_concurrencyThreadsAsync(command, options)`
+
+
+```
+
+const path = require("path");
+let { _concurrencyThreadsAsync } = require("concurrency.js");
+
+let threads = _concurrencyThreadsAsync(
+    "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\demos\\demos.threads.js",
+    {
+        data: {
+            data: "Testing parent data",
+            url: "https://www.google.com"
+        },
+        childData: "Test data from child"
+    }
+);
+
+```
+
+### Contributions
+
+Contributions, Feature Improvements, Bugs, and Issues are invited. [raising an issue](https://github.com/ganeshkbhat/concurrency.js/issues)
+
+# License
+
+[MIT License](./LICENSE)

package/demos/cluster.js

@@ -0,0 +1,22 @@
+
+const path = require("path");
+const { _concurrencyClusters } = require("../index.js");
+
+
+async function cluster() {
+    let filename = "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.cluster.js";
+    return _concurrencyClusters(
+        path.join(filename),
+        // __filename,
+        8,
+        {
+            data: {
+                url: "https://www.google.com",
+                message: "Testing parent data"
+            },
+            childData: "Test data from child"
+        }
+    )
+}
+
+module.exports = cluster;

package/demos/demos.cluster.js

@@ -0,0 +1,66 @@
+
+const path = require("path");
+let { _concurrencyClusters } = require("../index.js");
+
+
+// console.log(_concurrencyClusters(
+//     path.join("C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.process.js"),
+//     8,
+//     { url: "https://www.google.com", data: "Testing parent data", childData: "Test data from child" }
+// ).then((d) => {
+//     console.log("Data fetched", JSON.stringify(d));
+// }).catch((e) => {
+//     console.log(e.toString());
+// }))
+
+
+
+
+// async function concurrency() {
+//     let result = await _concurrencyClusters(
+//         path.join("C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.cluster.js"),
+//         8,
+//         { url: "https://www.google.com", data: "Testing parent data", childData: "Test data from child" }
+//     )
+//     console.log(result);
+// }
+
+// function concurrency() {
+//     _concurrencyClusters(
+//         path.join("C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.cluster.js"),
+//         8,
+//         { url: "https://www.google.com", data: "Testing parent data", childData: "Test data from child" }
+//     ).then((d) => {
+//         console.log("Data fetched", JSON.stringify(d));
+//     }).catch((e) => {
+//         console.log(e.toString());
+//     })
+// }
+
+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);
+        });
+    });
+}
+
+concurrency();
+
+setTimeout(() => console.log(`demo.cluster.js: run file PID ${process.pid}: Interval 2: 10000 `, process.pid), 10000);
+setTimeout(() => console.log(`demo.cluster.js: Closing process ${process.pid}: Timeout 1: 10000 `, process.exit()), 20000);

package/demos/demos.js

@@ -1,9 +1,9 @@
 /**
  * 
- * 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
@@ -16,6 +16,6 @@
 'use strict';
 
 
-let { _concurrencyThreads, _concurrencyProcesses } = require("../index.js");
-console.log(_concurrencyThreads, _concurrencyProcesses);
+let { _concurrencyThreads, _concurrencyProcesses, _concurrencyClusters, _concurrencyThreadsAsync } = require("../index.js");
+console.log(_concurrencyThreads, _concurrencyProcesses, _concurrencyClusters, _concurrencyThreadsAsync);
 

package/demos/demos.process.js

@@ -0,0 +1,37 @@
+/**
+ * 
+ * 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: demo.processes.js
+ * File Description: 
+ * 
+*/
+
+/* eslint no-console: 0 */
+
+'use strict';
+
+
+const path = require("path");
+let { _concurrencyProcesses } = require("../index.js");
+
+let filename = "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.process.js";
+_concurrencyProcesses(
+    path.join(filename), {
+    data: {
+        message: "Testing data",
+        url: "https://www.google.com"
+    }
+}, true).then((d) => {
+    console.log("Data fetched: ", JSON.stringify(d));
+}).catch((e) => {
+    console.log(e.toString()); setTimeout(() => { process.exit(e); }, 5000)
+});
+
+setTimeout(() => console.log(`demo.processes.js: Run file PID ${process.pid}: Interval 2: 10000 `, process.pid), 10000);
+setTimeout(() => console.log(`demo.processes.js: Closing process ${process.pid}: Timeout 1: 10000 `, process.exit()), 20000);
+

package/demos/demos.threads.async.js

@@ -0,0 +1,22 @@
+
+
+const path = require("path");
+let { _concurrencyThreadsAsync } = require("../index.js");
+
+let filename = "C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\demos\\demos.threads.js";
+
+let threads = _concurrencyThreadsAsync(filename, {
+    data: {
+        message: "Testing parent data",
+        url: "https://www.google.com"
+    },
+    childData: "Test data from child"
+});
+
+console.log(` STDOUT: console.log(threads.stderr); console.log(threads.stdout); `);
+
+console.log(threads.stderr);
+console.log(threads.stdout);
+
+// setTimeout(() => console.log(`demo.cluster.js: run file PID ${process.pid}: Interval 2: 10000 `, process.pid), 10000);
+// setTimeout(() => console.log(`demo.cluster.js: Closing process ${process.pid}: Timeout 1: 10000 `, process.exit()), 20000);

package/demos/demos.threads.js

@@ -0,0 +1,40 @@
+/**
+ * 
+ * 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: demo.threads.js
+ * File Description: 
+ * 
+*/
+
+/* eslint no-console: 0 */
+
+'use strict';
+
+const path = require("path");
+let { _concurrencyThreads } = require("../index.js");
+
+// _concurrencyThreads(path.join("C:\\Users\\GB\\Documents\\projects\\requireurl\\concurrency\\src\\worker.threads.js"), { data: { url: "https://www.google.com", message: "Testing data" } });
+
+
+_concurrencyThreads(__filename, {
+    data: {
+        url: "https://www.google.com",
+        message: "Testing data"
+    },
+    childData: "Testing child data"
+}, true).then((d) => console.log(JSON.stringify(d)))
+// .catch((e) => { console.log(e.toString()); setTimeout(() => {process.exit(e);}, 5000) })
+
+// setTimeout(() => {
+//     console.log(`demo.threads.js: Closing process ${process.pid}: Timeout 1: 20000 `, __filename);
+//     process.exit(0);
+// }, 20000);
+
+setTimeout(() => console.log(`demo.processes.js: Run file PID ${process.pid}: Interval 2: 10000 `, process.pid), 10000);
+setTimeout(() => console.log(`demo.processes.js: Closing process ${process.pid}: Timeout 1: 10000 `, process.exit()), 20000);
+

package/index.js

@@ -1,9 +1,9 @@
 /**
  * 
- * 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
@@ -16,9 +16,20 @@
 'use strict';
 
 
-const { _concurrencyThreads, _concurrencyProcesses } = require("./src/concurrency.js");
+const { _concurrencyThreads } = require("./src/worker.threads.js");
+const { _concurrencyProcesses } = require("./src/worker.process.js");
+const { _concurrencyClusters } = require("./src/worker.cluster.js");
+const { _concurrencyThreadsAsync } = require("./src/worker.thread.async.js");
 
 
 module.exports._concurrencyThreads = _concurrencyThreads;
 module.exports._concurrencyProcesses = _concurrencyProcesses;
+module.exports._concurrencyClusters = _concurrencyClusters;
+module.exports._concurrencyThreadsAsync = _concurrencyThreadsAsync;
 
+module.exports.default = {
+    _concurrencyThreads,
+    _concurrencyProcesses,
+    _concurrencyClusters,
+    _concurrencyThreadsAsync
+};

package/index.mjs

@@ -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: index.mjs
  * File Description: 
  * 
 */
@@ -15,8 +15,7 @@
 
 'use strict';
 
-import { _concurrencyThreads, _concurrencyProcesses } from "./src/concurrency.js";
-
-export { _concurrencyThreads, _concurrencyProcesses }
-export default _concurrencyThreads
+import { _concurrencyThreads, _concurrencyProcesses, _concurrencyThreadsAsync, _concurrencyThreadsAsync } from "./index.js";
 
+export { _concurrencyThreads, _concurrencyProcesses, _concurrencyClusters, _concurrencyThreadsAsync };
+export default _concurrencyProcesses;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "concurrency.js",
-  "version": "0.0.2",
-  "description": "npm module to work with concurrency - worker threads and worker processes easily using simple functions and script files",
+  "version": "0.0.3-beta",
+  "description": "npm module to work with concurrency - worker threads and worker processes (currrently only fork method) easily using simple functions and script files",
   "main": "index.js",
   "directories": {
     "test": "test"
@@ -10,10 +10,10 @@
     "require": "./index.js",
     "import": "./index.mjs"
   },
-  "dependencies": {},
   "devDependencies": {
     "chai": "^4.3.6",
     "mocha": "^10.0.0",
+    "npm-check": "^6.0.1",
     "sinon": "^14.0.0",
     "unimported": "^1.22.0"
   },
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/ganeshkbhat/concurrency#readme",
   "scripts": {
-    "test": "mocha --reporter spec --recursive"
+    "test": "mocha --reporter spec --recursive --timeout 60000"
   },
   "author": "Ganesh B",
   "license": "MIT"

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;