concurrency.js 0.0.3-beta → 0.0.5

package/test/test.process.js

@@ -0,0 +1,85 @@
+const { expect } = require('chai');
+const { runProcessTasks } = require('../tasks.process'); // The process-based runner
+const path = require('path');
+
+describe('Process-Based Task Runner', function() {
+  // Spawning processes is heavier than threads; 10s timeout recommended
+  this.timeout(10000);
+
+  let resultContext;
+  const taskLibraryPath = path.resolve(process.cwd(), './demos/libmap.js');
+
+  beforeEach(() => {
+    // Ensure a clean context before every test case
+    resultContext = { results: [] };
+  });
+
+  it('should execute a serial task in a child process', async () => {
+    const plan = ["taskone"];
+    const finalContext = await runProcessTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(1);
+    expect(finalContext.results[0]).to.deep.include({
+      index: 0,
+      name: 'taskone'
+    });
+    expect(finalContext.results[0].result).to.contain('Data from taskone');
+  });
+
+  it('should execute parallel tasks in separate child processes', async () => {
+    const plan = [["tasktwo", "taskthree"]];
+    const finalContext = await runProcessTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(2);
+    
+    // Validate that both parallel results are assigned the same step index
+    const indices = finalContext.results.map(r => r.index);
+    expect(indices).to.members([0, 0]); // incorrect definition
+
+    const names = finalContext.results.map(r => r.name);
+    expect(names).to.include.members(['tasktwo', 'taskthree']);
+  });
+
+  it('should maintain order across complex transitions (Serial -> Parallel)', async () => {
+    const plan = [
+      "taskone", 
+      ["tasktwo", "taskthree"], 
+      "taskfour"
+    ];
+    
+    const finalContext = await runProcessTasks(plan, resultContext, taskLibraryPath);
+
+    // Total 4 results: 1 (index 0) + 2 (index 1) + 1 (index 2)
+    expect(finalContext.results).to.have.lengthOf(4);
+    
+    expect(finalContext.results[0].index).to.equal(0);
+    expect(finalContext.results[1].index).to.equal(1);
+    expect(finalContext.results[2].index).to.equal(1);
+    expect(finalContext.results[3].index).to.equal(2);
+  });
+
+  it('should return an error if the process encounters an invalid task name', async () => {
+    const plan = ["missingTask"];
+    try {
+      await runProcessTasks(plan, resultContext, taskLibraryPath);
+      throw new Error('Test should have thrown an error');
+    } catch (err) {
+      expect(err.message).to.contain("Task 'missingTask' not found");
+    }
+  });
+
+  it('should recover if a child process exits unexpectedly', async () => {
+    // This tests the logic handling process exits in the coordinator
+    const plan = ["taskone"];
+    // Simulate a failure by passing a non-existent task file path
+    const badPath = './non_existent_file.js';
+    
+    try {
+      await runProcessTasks(plan, resultContext, badPath);
+      throw new Error('Should have caught process exit error');
+    } catch (err) {
+      // Depending on OS, this might be a module not found error or exit code 1
+      expect(err).to.exist;
+    }
+  });
+});

package/test/test.promise.js

@@ -0,0 +1,86 @@
+const { expect } = require('chai');
+const { runPromiseTasks } = require('../tasks.async');
+const path = require('path');
+
+describe('Promise-Based Task Runner', () => {
+  let resultContext;
+  const taskLibraryPath = './demos/libmap.js';
+
+  beforeEach(() => {
+    // Reset context before each test
+    resultContext = { results: [] };
+  });
+
+  it('should execute a single serial task and update the context', async () => {
+    const plan = ['taskone'];
+    const finalContext = await runPromiseTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(1);
+    expect(finalContext.results[0]).to.deep.include({
+      index: 0,
+      name: 'taskone'
+    });
+    expect(finalContext.results[0].result).to.contain('Data from taskone');
+  });
+
+  it('should execute tasks in the correct serial order', async () => {
+    const plan = ['taskone', 'taskfour'];
+    const finalContext = await runPromiseTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results[0].name).to.equal('taskone');
+    expect(finalContext.results[1].name).to.equal('taskfour');
+    expect(finalContext.results[1].index).to.equal(1);
+  });
+
+  it('should execute parallel blocks correctly', async () => {
+    const plan = [['tasktwo', 'taskthree']];
+    const finalContext = await runPromiseTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(2);
+    // Both parallel tasks should share the same step index
+    expect(finalContext.results[0].index).to.equal(0);
+    expect(finalContext.results[1].index).to.equal(0);
+    
+    const names = finalContext.results.map(r => r.name);
+    expect(names).to.include('tasktwo');
+    expect(names).to.include('taskthree');
+  });
+
+  it('should maintain order for complex plans (Serial -> Parallel -> Serial)', async () => {
+    const plan = [
+      'taskone', 
+      ['tasktwo', 'taskthree'], 
+      'taskfour'
+    ];
+    const finalContext = await runPromiseTasks(plan, resultContext, taskLibraryPath);
+
+    // Total 4 result entries (1 + 2 + 1)
+    expect(finalContext.results).to.have.lengthOf(4);
+    
+    // Check indices
+    expect(finalContext.results[0].index).to.equal(0); // taskone
+    expect(finalContext.results[1].index).to.equal(1); // parallel part 1
+    expect(finalContext.results[2].index).to.equal(1); // parallel part 2
+    expect(finalContext.results[3].index).to.equal(2); // taskfour
+  });
+
+  it('should allow repeated tasks and distinguish them by index', async () => {
+    const plan = ['taskone', 'taskone'];
+    const finalContext = await runPromiseTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(2);
+    expect(finalContext.results[0].index).to.equal(0);
+    expect(finalContext.results[1].index).to.equal(1);
+    expect(finalContext.results[0].name).to.equal(finalContext.results[1].name);
+  });
+
+  it('should throw an error if a task name is not found in the map', async () => {
+    const plan = ['nonExistentTask'];
+    try {
+      await runPromiseTasks(plan, resultContext, taskLibraryPath);
+      throw new Error('Should have failed');
+    } catch (err) {
+      expect(err.message).to.contain("Task 'nonExistentTask' not found");
+    }
+  });
+});

package/test/test.thread.js

@@ -0,0 +1,86 @@
+const { expect } = require('chai');
+const { runThreadedTasks } = require('../tasks.thread'); // The threaded version
+const path = require('path');
+
+describe('Threaded Task Runner', function() {
+  // Increase timeout because spawning threads has overhead
+  this.timeout(5000);
+
+  let resultContext;
+  const taskLibraryPath = path.resolve(process.cwd(), './demos/libmap.js');
+
+  beforeEach(() => {
+    resultContext = { results: [] };
+  });
+
+  it('should execute a serial task in a thread and return results', async () => {
+    const plan = ["taskone"];
+    const finalContext = await runThreadedTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(1);
+    expect(finalContext.results[0].name).to.equal('taskone');
+    expect(finalContext.results[0].index).to.equal(0);
+    expect(finalContext.results[0].result).to.contain('Data from taskone');
+  });
+
+  it('should execute parallel tasks across multiple threads', async () => {
+    const plan = [["tasktwo", "taskthree", "taskone"]];
+    const finalContext = await runThreadedTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(3);
+    
+    // All tasks in a parallel block should share the same index
+    finalContext.results.forEach(res => {
+      expect(res.index).to.equal(0);
+    });
+
+    const names = finalContext.results.map(r => r.name);
+    expect(names).to.include('tasktwo');
+    expect(names).to.include('taskthree');
+    expect(names).to.include('taskone');
+  });
+
+  it('should preserve execution order and context across serial and parallel boundaries', async () => {
+    const plan = [
+      "taskone",                       // Index 0
+      ["tasktwo", "taskthree"],        // Index 1
+      "taskfour"                       // Index 2
+    ];
+
+    const finalContext = await runThreadedTasks(plan, resultContext, taskLibraryPath);
+
+    // Total 4 results (1 serial + 2 parallel + 1 serial)
+    expect(finalContext.results).to.have.lengthOf(4);
+
+    // Verify correct indexing sequence
+    expect(finalContext.results[0].index).to.equal(0);
+    expect(finalContext.results[1].index).to.equal(1);
+    expect(finalContext.results[2].index).to.equal(1);
+    expect(finalContext.results[3].index).to.equal(2);
+    
+    expect(finalContext.results[3].name).to.equal('taskfour');
+  });
+
+  it('should distinguish between multiple runs of the same task name', async () => {
+    const plan = ["taskone", "taskone"];
+    const finalContext = await runThreadedTasks(plan, resultContext, taskLibraryPath);
+
+    expect(finalContext.results).to.have.lengthOf(2);
+    expect(finalContext.results[0].name).to.equal('taskone');
+    expect(finalContext.results[1].name).to.equal('taskone');
+    
+    // They must have different indices
+    expect(finalContext.results[0].index).to.equal(0);
+    expect(finalContext.results[1].index).to.equal(1);
+  });
+
+  it('should report errors if a string name does not exist in libmap.js', async () => {
+    const plan = ["invalidTaskName"];
+    try {
+      await runThreadedTasks(plan, resultContext, taskLibraryPath);
+      throw new Error('Test should have failed');
+    } catch (err) {
+      expect(err.message).to.contain("Task 'invalidTaskName' not found");
+    }
+  });
+});

package/worker.js

@@ -0,0 +1,24 @@
+const { parentPort, workerData } = require('worker_threads');
+const path = require('path');
+
+// Dynamically import the task map using the file path provided in workerData
+const taskFilePath = path.resolve(workerData.taskFilePath);
+const taskMap = require(taskFilePath);
+
+parentPort.on('message', async ({ taskName, context, index }) => {
+  try {
+    const taskFunction = taskMap[taskName];
+    if (!taskFunction) {
+      throw new Error(`Task '${taskName}' not found in file: ${workerData.taskFilePath}`);
+    }
+
+    const resultValue = await taskFunction(context, index);
+    
+    parentPort.postMessage({ 
+      status: 'success', 
+      result: { index, name: taskName, result: resultValue } 
+    });
+  } catch (error) {
+    parentPort.postMessage({ status: 'error', error: error.message });
+  }
+});

package/worker_process.js

@@ -0,0 +1,29 @@
+// worker_process.js
+const path = require('path');
+
+// Listen for messages from the parent process
+process.on('message', async ({ taskName, context, index, taskFilePath }) => {
+  try {
+    // Dynamically load the task map
+    const taskMap = require(path.resolve(taskFilePath));
+    const taskFunction = taskMap[taskName];
+
+    if (!taskFunction) {
+      throw new Error(`Task '${taskName}' not found in ${taskFilePath}`);
+    }
+
+    // Execute the task
+    const resultValue = await taskFunction(context, index);
+
+    // Send the result back to the parent
+    process.send({
+      status: 'success',
+      result: { index, name: taskName, result: resultValue }
+    });
+  } catch (error) {
+    process.send({ status: 'error', error: error.message });
+  } finally {
+    // Process exits after task completion to free up system memory
+    process.exit(0);
+  }
+});

package/demos/cluster.js

@@ -1,22 +0,0 @@
-
-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

@@ -1,66 +0,0 @@
-
-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,21 +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: index.js
- * File Description: 
- * 
-*/
-
-/* eslint no-console: 0 */
-
-'use strict';
-
-
-let { _concurrencyThreads, _concurrencyProcesses, _concurrencyClusters, _concurrencyThreadsAsync } = require("../index.js");
-console.log(_concurrencyThreads, _concurrencyProcesses, _concurrencyClusters, _concurrencyThreadsAsync);
-

package/demos/demos.process.js

@@ -1,37 +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: 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

@@ -1,22 +0,0 @@
-
-
-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

@@ -1,40 +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: 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.mjs

@@ -1,21 +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: index.mjs
- * File Description: 
- * 
-*/
-
-/* eslint no-console: 0 */
-
-'use strict';
-
-import { _concurrencyThreads, _concurrencyProcesses, _concurrencyThreadsAsync, _concurrencyThreadsAsync } from "./index.js";
-
-export { _concurrencyThreads, _concurrencyProcesses, _concurrencyClusters, _concurrencyThreadsAsync };
-export default _concurrencyProcesses;

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;