Skip to content

Simple utility library for managing a list of tasks and their lifecycle.

License

Notifications You must be signed in to change notification settings

philidem/task-list

Folders and files

NameName
Last commit message
Last commit date

Latest commit

author
Phillip Gates-Idem
Nov 15, 2016
74643ea · Nov 15, 2016

History

15 Commits
Oct 28, 2015
Feb 11, 2015
Oct 28, 2015
Feb 11, 2015
Oct 28, 2015
Nov 15, 2016
Nov 3, 2015
Nov 3, 2015
Nov 15, 2016

Repository files navigation

task-list

Simple utility library for managing a list of tasks and their lifecycle with support for promises and Node.js-style callbacks.

Installation

npm install task-list --save

Overview

The task-list module is used to orchestrate starting and stopping tasks in sequential order.

Each task is provided as an object that provides a start function and an optional stop function.

If your task is asynchronous then your start/stop function can either invoke a callback or return a promise. If returning a promise, then your start/stop function should have no arguments. If not using promises for your asynchronous operation, then your function should declare a single callback argument which will be a Node.js-style callback that you can invoke to indicate success or failure.

If your task is synchronous then make sure your start/stop function does not declare any arguments. As long as the function doesn't return something that looks like a Promise then it will be assumed that your task completed synchronously.

Usage

Simple example with minimal configuration:

var tasks = require('task-list').create([
    {
        name: 'asynchronous-task',

        // if you want to use callback for your async operation then
        // your function should have one argument which will be the
        // callback function
        start: function(callback) {
            // do something
            callback();
        },

        // NOTE: "stop" functional is optional
        // if you want to use callback for your async operation then
        // your function should have one argument which will be the
        // callback function
        stop: function(callback) {
            // do something
            callback();
        }
    },

    {
        name: 'asynchronous-task-using-promise',

        start: function() {
            // return a Promise
            return new Promise(function(resolve, reject) {
                setTimeout(function() {
                    resolve();
                }, 10);
            });
        }
    },

    {
        name: 'synchronous-task',

        // synchronous operations should be declared as a function
        // with no arguments
        start: function() {
            // all we need to do is return if our task is synchronous
        }
    }
]);

// Using callback-style to start/stop all tasks
tasks.startAll(function(err) {
    if (err) {
        // some error occurred
    } else {
        // tasks are running
    }

    // now stop the tasks
    tasks.stopAll(function(err) {
        if (err) {
            // one or more services failed to stop
        } else {
            // all services stopped successfully
        }
    });
});

// startAll and stopAll can also be invoked with no argument if you
// would rather use promises.
tasks.startAll().then(function() {
    // now stop the tasks and return the Promise that it creates
    return tasks.stopAll();
}).then(function() {
    console.log('All tasks were started and have now been stopped');
}).catch(function(err) {
    throw err;
})

An example that provides a logger:

var options = {
    logger: {
        info: function(message) {
            console.log('INFO: ' + message);
        },

        success: function(message) {
            console.log('SUCCESS: ' + message);
        },

        error: function(message) {
            console.error('ERROR: ' + message);
        }
    }
};

var services = require('task-list').create([
    {
        name: 'task1',

        start: function() {
            // do something
        }
    }
], options);

API

Method: create(tasks, options)

Returns a TaskList which has operations for controlling the lifecycle of the tasks

options

  • logger: An object that has info, success, or error properties which should be functions that expect a single message argument. The info, success, and error properties are optional and if not provided then the corresponding log level will not produce any output.

Example:

var tasks = require('task-list').create(tasksArray, options)

Class: TaskList

A TaskList is returned by call to require('task-list').create(...).

NOTE: If you call startAll or stopAll without a callback argument then a Promise will be returned. The Promise implementation will be the native Promise provided by the JavaScript runtime environment or the Promise implementation that your application exposed as a global. If there is no global Promise implementation found, then you will encounter exceptions.

Method: startAll([callback])

This method is used to start all of the tasks that belong to this TaskList. If a callback is provided then it is expected to be a Node.js-style callback that will be invoked when all tasks have been started or error occurred. If a callback is not provided then a Promise will be returned.

Method: stopAll([callback])

This method is used to stop all of the tasks that belong to this TaskList. If a callback is provided then it is expected to be a Node.js-style callback that will be invoked when all tasks have been stopped or error occurred. If a callback is not provided then a Promise will be returned.

About

Simple utility library for managing a list of tasks and their lifecycle.

Resources

License

Stars

Watchers

Forks

Packages

No packages published