open-index/open-npm huggingface dataset:
npm package: 2pl
Description: Two-phase locking for asynchronous JavaScript executions.
Author: Adrian C Shum
Latest version: 1.2.1

# 2PL

In-memory two-phase locking for asynchronous JavaScript functions.

[![Build Status](https://travis-ci.org/cshum/2pl.svg)](https://travis-ci.org/cshum/2pl)

```
npm install 2pl
```

Multiple lock keys can be acquired during the lifetime of a lock instance,
where release is done in one operation.

```js
var lock = require('2pl')
var shared = {} // in-memory lock object shared across instances

var l = lock(shared, { ttl: 5000 }) // new instance, 5 seconds timeout

l.acquire('a', function (err) {
  // a is locked
  l.acquire('b', function (err) {
    // b is locked
    l.release(function (err) {
      // a and b are released
    })
  })
})

```

## API

### var l = lock(shared, [options])

Create a new instance with `shared` object holding the in-memory locks.
Accepts following options:

* `ttl`: Time to live (milliseconds) of lock instance for liveness. Defaults to 20 seconds.

### l.acquire(key, [callback])

Attempts to acquire a lock, given a string `key`.
Accepts an optional callback function, invoked on success or error.

### l.extend(ttl, [callback])

Attempts to extend `ttl` of lock in milliseconds.
Accepts an optional callback function, invoked on success or error.

### l.release([callback])

Attempts to release lock.
Accepts an optional callback function, invoked on success or error.

### var createLock = lock.creator([options])

Returns a factory function `createLock([options])` that create instances under the same shared lock object.

```js
var createLock = lock.creator({ ttl: 5000 })

var l1 = createLock() // ttl 5000
var l2 = createLock({ ttl: 500 }) // ttl 500
```

## License

MIT