TaskingPM

A NodeJS process manager module that uses a queue of tasks to execute functions in paralel

https://github.com/ccezarst/TaskingPM

How to use

To use you need to import the package by using

const taskingPM = require("taskingPM")

After, you can create a new task using

taskingPM.newTask(currentWorkingDirectory, taskFunction, taskArguments, callback)

• currentWorkingDirectory: specified in which directory the processes will be started in, so you can import local files inside the task
• taskFunction: the function that is going to be ran in paralel
• taskArguments: parameters that you can pass to the taskFunction to make your life easier
• callback: after the taskFunction is done and it returns it's result, this callback function is called with the parameter being the result

Working example

const customLogger = {
    warn: function (text) {
        console.log(text)
    },
    info: function (text) {
        console.log(text)
    },
    error: function (text) {
        console.log(text)
    }
}
const taskingPM = new require("./index")
let tasks = 50
taskingPM.setLogger(customLogger)
let i = 1
let interval = setInterval(function () { 
    taskingPM.newTask(process.cwd(), (extra) => {
        return "Hello world! " + extra["count"]
    }, { count: i }, (result) => { console.log(result) })
    i += 1;
    if (i >= tasks) {
        clearInterval(interval)
    }
}, 100)

After waiting one second, the code creates 50 tasks. You will see when a task is finished in the console as it prints "Hello world! {taskNumber}"

Extra functions

setLogger

setLogger(logger)

By default the package doesn't output any logs. Set a custom logger. The logger must include info, error and warn functions that take a single text parameter.

setConfigs

setConfigs(maxIdleTime, maxProcesses) {},

Set configs. maxIdleTime = the maximum amount of time(in ms) a process can be idle before it is killed. Longer times mean that sporatic(chaotic) creation of tasks are handler better but the processes remain open draining a bit of resources. maxProcesses = the maximum amount of processes the package can generate

deleteTask

deleteTask(task)

Deletes a task from the queue so it doesn't execute. task = the tasks object(is returned from newTask)

flushTasks

flushTasks()

Delete all tasks from the queue

closeAllProcceses

closeAllProcesses()

Close all active processes

getTasks

getTasks()

Returns all of the tasks in the queue in the order they are going to be executed.

getActiveProcesses

getActiveProcesses()

Returns all open/active processes. The processes come in a CustomChildProcess object from where you can access information such as if the process is idle.

exit

exit()

For exiting gracefully. Deletes all tasks and closes all processes

class CustomChildProcess {
  proc: handle to the nodejs child process
  id: internal process ID
  spawned: if the nodejs child process has spawned yet
  working: true when it's working on a task, false when idle
  finishedWorkingAtEpoch: when a process finishes working, it marks the date in this variable using Date.now()
  execTask(task): executes a task. It is recommended that you don't execute tasks manually :/
  kill: kills the nodejs child process
}