From bd65bb67e25a79b019d745b7262b2008ce2adb15 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Wed, 16 Nov 2016 01:59:39 +0100 Subject: incrementally verify denoms The denominations are not stored in a separate object store. --- node_modules/orchestrator/README.md | 572 ++++++++++++++++++------------------ 1 file changed, 286 insertions(+), 286 deletions(-) (limited to 'node_modules/orchestrator/README.md') diff --git a/node_modules/orchestrator/README.md b/node_modules/orchestrator/README.md index 3d3fee45c..d87844cf4 100644 --- a/node_modules/orchestrator/README.md +++ b/node_modules/orchestrator/README.md @@ -1,286 +1,286 @@ -[![Build Status](https://secure.travis-ci.org/orchestrator/orchestrator.svg?branch=master)](https://travis-ci.org/orchestrator/orchestrator) -[![Dependency Status](https://david-dm.org/orchestrator/orchestrator.svg)](https://david-dm.org/orchestrator/orchestrator) - -Orchestrator -============ - -A module for sequencing and executing tasks and dependencies in maximum concurrency - -Usage ------ - -### 1. Get a reference: - -```javascript -var Orchestrator = require('orchestrator'); -var orchestrator = new Orchestrator(); -``` - -### 2. Load it up with stuff to do: - -```javascript -orchestrator.add('thing1', function(){ - // do stuff -}); -orchestrator.add('thing2', function(){ - // do stuff -}); -``` - -### 3. Run the tasks: - -```javascript -orchestrator.start('thing1', 'thing2', function (err) { - // all done -}); -``` - -API ---- - -### orchestrator.add(name[, deps][, function]); - -Define a task - -```javascript -orchestrator.add('thing1', function(){ - // do stuff -}); -``` - -#### name -Type: `String` - -The name of the task. - -#### deps -Type: `Array` - -An array of task names to be executed and completed before your task will run. - -```javascript -orchestrator.add('mytask', ['array', 'of', 'task', 'names'], function() { - // Do stuff -}); -``` - -**Note:** Are your tasks running before the dependencies are complete? Make sure your dependency tasks -are correctly using the async run hints: take in a callback or return a promise or event stream. - -#### fn -Type: `function` - -The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: - -- Take in a callback -- Return a stream or a promise - -#### examples: - -**Accept a callback:** - -```javascript -orchestrator.add('thing2', function(callback){ - // do stuff - callback(err); -}); -``` - -**Return a promise:** - -```javascript -var Q = require('q'); - -orchestrator.add('thing3', function(){ - var deferred = Q.defer(); - - // do async stuff - setTimeout(function () { - deferred.resolve(); - }, 1); - - return deferred.promise; -}); -``` - -**Return a stream:** (task is marked complete when stream ends) - -```javascript -var map = require('map-stream'); - -orchestrator.add('thing4', function(){ - var stream = map(function (args, cb) { - cb(null, args); - }); - // do stream stuff - return stream; -}); -``` - -**Note:** By default, tasks run with maximum concurrency -- e.g. it launches all the tasks at once and waits for nothing. -If you want to create a series where tasks run in a particular order, you need to do two things: - -- give it a hint to tell it when the task is done, -- and give it a hint that a task depends on completion of another. - -For these examples, let's presume you have two tasks, "one" and "two" that you specifically want to run in this order: - -1. In task "one" you add a hint to tell it when the task is done. Either take in a callback and call it when you're -done or return a promise or stream that the engine should wait to resolve or end respectively. - -2. In task "two" you add a hint telling the engine that it depends on completion of the first task. - -So this example would look like this: - -```javascript -var Orchestrator = require('orchestrator'); -var orchestrator = new Orchestrator(); - -// takes in a callback so the engine knows when it'll be done -orchestrator.add('one', function (cb) { - // do stuff -- async or otherwise - cb(err); // if err is not null or undefined, the orchestration will stop, and note that it failed -}); - -// identifies a dependent task must be complete before this one begins -orchestrator.add('two', ['one'], function () { - // task 'one' is done now -}); - -orchestrator.start('one', 'two'); -``` - -### orchestrator.hasTask(name); - -Have you defined a task with this name? - -#### name -Type: `String` - -The task name to query - -### orchestrator.start(tasks...[, cb]); - -Start running the tasks - -#### tasks -Type: `String` or `Array` of `String`s - -Tasks to be executed. You may pass any number of tasks as individual arguments. - -#### cb -Type: `function`: `function (err) {` - -Callback to call after run completed. - -Passes single argument: `err`: did the orchestration succeed? - -**Note:** Tasks run concurrently and therefore may not complete in order. -**Note:** Orchestrator uses `sequencify` to resolve dependencies before running, and therefore may not start in order. -Listen to orchestration events to watch task running. - -```javascript -orchestrator.start('thing1', 'thing2', 'thing3', 'thing4', function (err) { - // all done -}); -``` -```javascript -orchestrator.start(['thing1','thing2'], ['thing3','thing4']); -``` - -**FRAGILE:** Orchestrator catches exceptions on sync runs to pass to your callback -but doesn't hook to process.uncaughtException so it can't pass those exceptions -to your callback - -**FRAGILE:** Orchestrator will ensure each task and each dependency is run once during an orchestration run -even if you specify it to run more than once. (e.g. `orchestrator.start('thing1', 'thing1')` -will only run 'thing1' once.) If you need it to run a task multiple times, wait for -the orchestration to end (start's callback) then call start again. -(e.g. `orchestrator.start('thing1', function () {orchestrator.start('thing1');})`.) -Alternatively create a second orchestrator instance. - -### orchestrator.stop() - -Stop an orchestration run currently in process - -**Note:** It will call the `start()` callback with an `err` noting the orchestration was aborted - -### orchestrator.on(event, cb); - -Listen to orchestrator internals - -#### event -Type: `String` - -Event name to listen to: -- start: from start() method, shows you the task sequence -- stop: from stop() method, the queue finished successfully -- err: from stop() method, the queue was aborted due to a task error -- task_start: from _runTask() method, task was started -- task_stop: from _runTask() method, task completed successfully -- task_err: from _runTask() method, task errored -- task_not_found: from start() method, you're trying to start a task that doesn't exist -- task_recursion: from start() method, there are recursive dependencies in your task list - -#### cb -Type: `function`: `function (e) {` - -Passes single argument: `e`: event details - -```javascript -orchestrator.on('task_start', function (e) { - // e.message is the log message - // e.task is the task name if the message applies to a task else `undefined` - // e.err is the error if event is 'err' else `undefined` -}); -// for task_end and task_err: -orchestrator.on('task_stop', function (e) { - // e is the same object from task_start - // e.message is updated to show how the task ended - // e.duration is the task run duration (in seconds) -}); -``` - -**Note:** fires either *stop or *err but not both. - -### orchestrator.onAll(cb); - -Listen to all orchestrator events from one callback - -#### cb -Type: `function`: `function (e) {` - -Passes single argument: `e`: event details - -```javascript -orchestrator.onAll(function (e) { - // e is the original event args - // e.src is event name -}); -``` - -LICENSE -------- - -(MIT License) - -Copyright (c) 2013 [Richardson & Sons, LLC](http://richardsonandsons.com/) - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be -included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +[![Build Status](https://secure.travis-ci.org/robrich/orchestrator.svg?branch=master)](https://travis-ci.org/robrich/orchestrator) +[![Dependency Status](https://david-dm.org/robrich/orchestrator.svg)](https://david-dm.org/robrich/orchestrator) + +Orchestrator +============ + +A module for sequencing and executing tasks and dependencies in maximum concurrency + +Usage +----- + +### 1. Get a reference: + +```javascript +var Orchestrator = require('orchestrator'); +var orchestrator = new Orchestrator(); +``` + +### 2. Load it up with stuff to do: + +```javascript +orchestrator.add('thing1', function(){ + // do stuff +}); +orchestrator.add('thing2', function(){ + // do stuff +}); +``` + +### 3. Run the tasks: + +```javascript +orchestrator.start('thing1', 'thing2', function (err) { + // all done +}); +``` + +API +--- + +### orchestrator.add(name[, deps][, function]); + +Define a task + +```javascript +orchestrator.add('thing1', function(){ + // do stuff +}); +``` + +#### name +Type: `String` + +The name of the task. + +#### deps +Type: `Array` + +An array of task names to be executed and completed before your task will run. + +```javascript +orchestrator.add('mytask', ['array', 'of', 'task', 'names'], function() { + // Do stuff +}); +``` + +**Note:** Are your tasks running before the dependencies are complete? Make sure your dependency tasks +are correctly using the async run hints: take in a callback or return a promise or event stream. + +#### fn +Type: `function` + +The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: + +- Take in a callback +- Return a stream or a promise + +#### examples: + +**Accept a callback:** + +```javascript +orchestrator.add('thing2', function(callback){ + // do stuff + callback(err); +}); +``` + +**Return a promise:** + +```javascript +var Q = require('q'); + +orchestrator.add('thing3', function(){ + var deferred = Q.defer(); + + // do async stuff + setTimeout(function () { + deferred.resolve(); + }, 1); + + return deferred.promise; +}); +``` + +**Return a stream:** (task is marked complete when stream ends) + +```javascript +var map = require('map-stream'); + +orchestrator.add('thing4', function(){ + var stream = map(function (args, cb) { + cb(null, args); + }); + // do stream stuff + return stream; +}); +``` + +**Note:** By default, tasks run with maximum concurrency -- e.g. it launches all the tasks at once and waits for nothing. +If you want to create a series where tasks run in a particular order, you need to do two things: + +- give it a hint to tell it when the task is done, +- and give it a hint that a task depends on completion of another. + +For these examples, let's presume you have two tasks, "one" and "two" that you specifically want to run in this order: + +1. In task "one" you add a hint to tell it when the task is done. Either take in a callback and call it when you're +done or return a promise or stream that the engine should wait to resolve or end respectively. + +2. In task "two" you add a hint telling the engine that it depends on completion of the first task. + +So this example would look like this: + +```javascript +var Orchestrator = require('orchestrator'); +var orchestrator = new Orchestrator(); + +// takes in a callback so the engine knows when it'll be done +orchestrator.add('one', function (cb) { + // do stuff -- async or otherwise + cb(err); // if err is not null or undefined, the orchestration will stop, and note that it failed +}); + +// identifies a dependent task must be complete before this one begins +orchestrator.add('two', ['one'], function () { + // task 'one' is done now +}); + +orchestrator.start('one', 'two'); +``` + +### orchestrator.hasTask(name); + +Have you defined a task with this name? + +#### name +Type: `String` + +The task name to query + +### orchestrator.start(tasks...[, cb]); + +Start running the tasks + +#### tasks +Type: `String` or `Array` of `String`s + +Tasks to be executed. You may pass any number of tasks as individual arguments. + +#### cb +Type: `function`: `function (err) {` + +Callback to call after run completed. + +Passes single argument: `err`: did the orchestration succeed? + +**Note:** Tasks run concurrently and therefore may not complete in order. +**Note:** Orchestrator uses `sequencify` to resolve dependencies before running, and therefore may not start in order. +Listen to orchestration events to watch task running. + +```javascript +orchestrator.start('thing1', 'thing2', 'thing3', 'thing4', function (err) { + // all done +}); +``` +```javascript +orchestrator.start(['thing1','thing2'], ['thing3','thing4']); +``` + +**FRAGILE:** Orchestrator catches exceptions on sync runs to pass to your callback +but doesn't hook to process.uncaughtException so it can't pass those exceptions +to your callback + +**FRAGILE:** Orchestrator will ensure each task and each dependency is run once during an orchestration run +even if you specify it to run more than once. (e.g. `orchestrator.start('thing1', 'thing1')` +will only run 'thing1' once.) If you need it to run a task multiple times, wait for +the orchestration to end (start's callback) then call start again. +(e.g. `orchestrator.start('thing1', function () {orchestrator.start('thing1');})`.) +Alternatively create a second orchestrator instance. + +### orchestrator.stop() + +Stop an orchestration run currently in process + +**Note:** It will call the `start()` callback with an `err` noting the orchestration was aborted + +### orchestrator.on(event, cb); + +Listen to orchestrator internals + +#### event +Type: `String` + +Event name to listen to: +- start: from start() method, shows you the task sequence +- stop: from stop() method, the queue finished successfully +- err: from stop() method, the queue was aborted due to a task error +- task_start: from _runTask() method, task was started +- task_stop: from _runTask() method, task completed successfully +- task_err: from _runTask() method, task errored +- task_not_found: from start() method, you're trying to start a task that doesn't exist +- task_recursion: from start() method, there are recursive dependencies in your task list + +#### cb +Type: `function`: `function (e) {` + +Passes single argument: `e`: event details + +```javascript +orchestrator.on('task_start', function (e) { + // e.message is the log message + // e.task is the task name if the message applies to a task else `undefined` + // e.err is the error if event is 'err' else `undefined` +}); +// for task_end and task_err: +orchestrator.on('task_stop', function (e) { + // e is the same object from task_start + // e.message is updated to show how the task ended + // e.duration is the task run duration (in seconds) +}); +``` + +**Note:** fires either *stop or *err but not both. + +### orchestrator.onAll(cb); + +Listen to all orchestrator events from one callback + +#### cb +Type: `function`: `function (e) {` + +Passes single argument: `e`: event details + +```javascript +orchestrator.onAll(function (e) { + // e is the original event args + // e.src is event name +}); +``` + +LICENSE +------- + +(MIT License) + +Copyright (c) 2013-2015 [Richardson & Sons, LLC](http://richardsonandsons.com/) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -- cgit v1.2.3