Task Execution Limiter


Help you manage asynchronous tasks

Features

- Can limit the execution rate with interval and limitation
- Can limit the number of concurrent
- Can limit the queue length
- Can hook many lifecycle events
- Ability to customize the processing logic when task queue overflows
- Ability to change interval during run time, and it won't break the alignment of the interval

Limitation

- Execution interval can not be greater than 2147483647ms or less than 1ms. See setInterval

Install

> npm install --save task-execution-limiter
>
> yarn add task-execution-limiter

Intro

> task-execution-limiter mainly exposes three interfaces, including TaskExecutionLimiter, buildTaskExecutionLimiter and buildWithLimit. You can use class TaskExecutionLimiter, or you can use the tool functions buildTaskExecutionLimiter and buildWithLimit to encapsulate higher-order functions.
>
> task-execution-limiter also exposes the QueueOverflowError class, which you can customize for other error types when you choose to implement a task queue overflow handler.

Quick Start

see gist examples

- Using TaskExecutionLimiter class. case1 and case2
- schedule method
- withLimit method

- Using functions. case5 and case6
- buildTaskExecutionLimiter
> buildTaskExecutionLimiter is a simple encapsulation for TaskExecutionLimiter.schedule

- buildWithLimit

> buildWithLimit is a simple encapsulation for TaskExecutionLimiter.withLimit

- Using custom overflow handler. case3 and case4

- Using limit with decimals. case7

API

$3

#### constructor(options) => limiter: TaskExecutionLimiter

- options.interval: Rate limit, representing the interval to the next tick. When interval is larger than 2147483647 or less than 1, the interval will be set to 1.setInterval Default: 1
- Number
- options.minInterval: Rate limit, representing the lower bound of interval. (Can be an integer or decimal). Default: 1
- Number
- options.maxInterval: Rate limit, representing the upper bound of interval. (Can be an integer or decimal). Default: 2147483647
- Number
- options.limit: Rate limit, representing the number of tasks that would be started each tick (Can be an integer or decimal). Default: Infinity
- Number
- options.concurrency: Concurrent quantitative restrictions. Default: Infinity
- Number
- options.queueLength: Task queue length. Default: Infinity
- Number
- options.queueOverflowHandler: Handle function when task queue length overflows. By default, the last task is rejected, and an error will be thrown, you can refer to QueueOverflowError to custom error type. see lib/util.defaultQueueOverflowHandler
- Function: (q: Array, item: Object) => newq: Array

#### schedule(task) => limitedTask: Promise

- task: Tasks to be processed.
- Function: () => Promise
- Function: () => Number, Array, Object...(primitive type)
- Number, Array, Object...(primitive type)
- limitedTask: Wrapped promise.
- Promise

#### withLimit(fn) => limitedFn: Function

- fn: Function to be processed.
- Function: (...args) => any
- limitedFn: Function to be processed with limitation.
- Function: (...args) => any

#### interval(setter)

You can change interval of TaskExecutionLimiter, and it won't break the alignment of the interval(through the delay in execution).

``javascript
const speedUp = () => { limiter.interval /= 2 }
const slowDown = () => { limiter.interval *= 2 }
`

#### willTick(setter)

Lifecycle event, called before interval tick. Default: noop

- fn: () => any

#### didTick(setter)

Lifecycle event, called after interval tick. Default: noop

- fn: () => any

#### willStart(setter)

Lifecycle event, called before limiter start running. Default: noop

- fn: () => any

#### didStart(setter)

Lifecycle event, called after limiter start running. Default: noop

- fn: () => any

#### willStop(setter)

Lifecycle event, called before limiter stop running. Default: noop

- fn: () => any

#### didStop(setter)

Lifecycle event, called after limiter stop running. Default: noop

- fn: () => any

$3

- options: The same as the constructor arguments of TaskExecutionLimiter.
- limiter:
- Function: (task) => limitedTask
- task: Tasks to be processed.
- Function: () => Promise
- Function: () => Number, Array, Object...(primitive type)
- Number, Array, Object...(primitive type)
- limitedTask: Wrapped promise.
- Promise

$3

- options: The same as the constructor arguments of TaskExecutionLimiter.
- limitedFn`: Function to be processed with limitation.
- Function: (...args) => any

$3

You can extends this class when you choose to implement a task queue overflow handler.