concurrent-tasks

!npmnpmvnpmpackage !sizesizeimgsize !npmnpmdwnpmpackage !GitHub issuesghissuesgithubissues !GitHub forksghforksgithubforks !GitHub starsghstarsgithubstars
A simple task runner which will run all tasks till completion, while maintaining concurrency limits.
The following is a quick reference guide to help you get friendly with Concurrent Tasks. Visit the websitewebsite for a detailed documentation.

• 👋🏼 Introduction
• 🎬 Getting Started
• 🏁 The Done Callback
• ⚒ Configuration
• 🕹 API

-   [add](#api-add)
-   [addFirst](#api-add-first)
-   [addMultiple](#api-add-multiple)
-   [addMultipleFirst](#api-add-multiple-first)
-   [remove](#api-remove)
-   [removeFirst](#api-remove-first)
-   [removeAt](#api-remove-at)
-   [removeAll](#api-remove-all)
-   [start](#api-start)
-   [setConcurrency](#api-set-concurrency)
-   [isBusy](#api-is-busy)

• 💪🏼 Powered by Concurrent Tasks
• 👩🏻‍💻 Contributing
• 🧐 Issues
• 🗺 Roadmap
• 🔑 License

Concurrent Tasks mimics a priority queue by using JavaScript's inbuilt array data type. Each task is a function which signals completion back to the TaskRunner. Once tasks are added, the instance starts executing them until the concurrency criteria is met. Once even a single task is complete (it calls the done callback), the next task in the queue is picked up.

What can I use it with?

The minimalism of Concurrent Tasks makes it an easy-to-use solution across any framework or flavour of JavaScript. It has ZERO dependencies and can be used virtually in any scenario.

• ✅ Vanilla JavaScript
• ✅ Frontend Frameworks (React, Vue, Angular, etc)
• ✅ Backend Frameworks (Express, Hapi, Koa, etc)
• ✅ NPM Module
• ✅ Node CLI Application

Via NPM

npm install concurrent-tasks

Or the script tag

<script src="https://cdn.jsdelivr.net/npm/concurrent-tasks/umd/concurrent-tasks.min.jss" type="text/javascript"></script>

Usage

import TaskRunner from 'concurrent-tasks';
​
const runner = new TaskRunner();
​
function generateTasks() {
    const tasks = [];
    let count = 1000;
    while(count) {
        tasks.push(done => {
            setTimeout(() => {
                done();
            }, Math.random() * 1000)
        });
        count--;
    }
    return tasks;
}
​
runner.addMultiple(generateTasks());

Important: Each task passed to the task runner, necessarily has to call the done function. If not, your queue won't process properly.In JavaScript, it gets very difficult for tasks to talk to each other. A lot of times, we need to maintain a map of running tasks and call a function which will update the value and call the next task.
Concurrent Tasks is a JavaScript module, which runs multiple tasks concurrently until all the tasks are complete. It needs a way to figure out when a particular task has been completed.

Solution

Gulp solves this problem by either accepting a return of a Gulp task, or by calling a function done. Similarly, to solve the exact same problem, each task passed to the TaskRunner has access to a special function called done (ingenuity max).

Purpose

The purpose of this function is simple: Tell the instance when a particular task is complete! Internally, the done function does a fair amount of work. It:

• Makes a free slot available for the internal runner.
• Updates completion counts and calls the internal runner.
• Updates the time elapsed from start, until the function calling done's completion.
• Calls the internal runner to pick up the next task in the priority queue.

Examples

For some examples on how you can use the callback, head over to the docs.| Property | Type | Default | Description | | ----------- | ---------- | ------------------------- | ------------------------------------------------------------ | | concurrency | Number | 3 | Set the batch size of the task runner. | | autoStart | Boolean | true | Decides whether to start executing tasks automatically. | | name | String | Runner <instance-count> | A unique name to identify the TaskRunner instance. | | onAdd | Function | undefined | Fired every time add is called. | | onStart | Function | undefined | Fired every time the runner goes from idle to working state. | | onDone | Function | undefined | Fired each time a task calls done callback. | | onEnd | Function | undefined | Fired every time the runner goes from working to idle state. |The following methods are provided by Concurrent Tasks to help you in manipulating your task list and get the most out of the module.

add

Adds a task to the task list.

add(task: Function, [first: Boolean])

addFirst

Adds a task to the beginning of the task list.

addFirst(task: Function, [first: Boolean])

addMultiple

Adds a collection of tasks to the task list.

addMultiple(tasks: Array.Function, [first: Boolean])

addMultipleFirst

Adds a collection of tasks to the beginning task list.

addMultipleFirst(tasks: Array.Function)

remove

Remove a task from the task list.

remove([first: Boolean])

removeFirst

Remove the first task from the task list.

removeFirst();

removeAt

Remove a task at a particular index from the task list.

removeAt(index: Number)

removeAll

Removes all tasks in the task list.

removeAll();

start

Programmatically start processing the first batch of tasks from the task list.

start();

setConcurrency

Set the concurrency limit on an already-running or a idle instance.

setConcurrency(concurrency: Number)

isBusy

Get the current state of the instance (idle or busy).

isBusy();

If you'd like to showcase any:

• Website
• Package
• Framework
• API

That's been powered by Concurrent Tasks, you can get in touch on Twitter or just use #poweredByConcurrentTasks and it'll be featured here!We ❤️ contributions! We are looking for people who echo our sentiments and share the same idea about Concurrent Tasks. Check out the contributing guidelines.For any issues or queries you might have about the table, please feel free to create one in the issues section.

• ✅ Custom concurrency.
• ✅ Events for task addition, idle state change, done callback firing.
• ✅ Programmatic and automatic start.
• ✅ Different kinds of addition and removal.
• ❌ Priority value for each task.
• ❌ Storing tasks as a map of priorities.
• ❌ Adding/removing tasks to/from an existing priority.
• ❌ Adding/removing multiple tasks to/from an existing priority.
• ❌ Adding tasks to a new priority.
• ❌ Adding multiple tasks to a new priority.
• ❌ Removal of a priority.

This project is under the MIT License. You can checkout the project's license for more info.
Copyright © 2018.