# ringpop

> Scalable, fault-tolerant application-layer sharding

Latest version **10.21.0** (published 2019-05-31) · 0 weekly downloads

## Install

```sh
npm install ringpop
pnpm add ringpop
yarn add ringpop
bun add ringpop
```

Provides the command `ringpop`.

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 10.21.0 |
| Published | 2019-05-31 |
| First published | 2014-12-04 |
| Weekly downloads | 0 |
| TypeScript types | none |
| Module format | CommonJS |
| Node | ^0.10.32 |
| Dependencies | 8 |
| Unpacked size | 980.4 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 1186 |
| Maintainers | benfleis, dansimau, mennop, mjr, raynos, uber, wieger, yulunli |

## Links

- npm: https://www.npmjs.com/package/ringpop
- Repository: https://github.com/uber/ringpop
- Homepage: https://github.com/uber/ringpop#readme
- Issues: https://github.com/uber/ringpop/issues
- npm.io page: https://npm.io/package/ringpop

## Dependencies (8)

- [body](https://npm.io/package/body.md) ^5.0.0
- [error](https://npm.io/package/error.md) ^5.0.0
- [hammock](https://npm.io/package/hammock.md) ^3.0.1
- [metrics](https://npm.io/package/metrics.md) ^0.1.8
- [farmhash](https://npm.io/package/farmhash.md) ^1.2.0
- [node-uuid](https://npm.io/package/node-uuid.md) ^1.4.3
- [toobusy-js](https://npm.io/package/toobusy-js.md) ^0.5.0
- [underscore](https://npm.io/package/underscore.md) ^1.5.2

## Recent versions

- 10.21.0 (latest) — 2019-05-31
- 10.13.0 (alpha) — 2015-11-27
- 10.20.0 — 2017-06-15
- 10.19.0 — 2017-04-12
- 10.18.0 — 2017-01-27
- 10.17.0 — 2016-11-22
- 10.16.2 — 2016-10-19
- 10.16.1 — 2016-10-04
- 10.16.0 — 2016-09-23
- 10.15.0 — 2016-05-26
- 10.14.0 — 2016-02-25
- 10.13.5 — 2016-02-02
- 10.13.4 — 2016-02-01
- 10.13.1 — 2015-12-03
- 10.12.3 — 2015-11-09
- … 90 more at https://npm.io/package/ringpop/versions

## README

# ringpop-node [![Build Status](https://travis-ci.org/uber/ringpop-node.svg?branch=master)](https://travis-ci.org/uber/ringpop-node)

**(This project is no longer under active development.)**

Ringpop is a library that brings cooperation and coordination to distributed
applications. It maintains a consistent hash ring on top of a membership protocol
and provides request forwarding as a routing convenience. It can be used to
shard your application in a way that's scalable and fault tolerant.

# Requirements

* Node 0.10 (0.10.32 or higher)

# Installation
To install Ringpop for usage as a library:

```
npm install ringpop
```

Prepare the current directory for development:

```
npm install
```

To be able to run the tests, make sure you have your open file limit
restriction on at least 4K:

```
ulimit -n 4096
```

# Tick Cluster
An example application `tools/tick-cluster.js` is included in ringpop-common
repository. It just launches a ringpop cluster of a given size. Using this
application is the quickest way to start a ringpop cluster.

```
git clone https://github.com/uber/ringpop-common.git
./ringpop-common/tools/tick-cluster.js --interpreter node main.js
```

# Example
Run a 2-node Ringpop cluster from the command-line. Install Ringpop
and TChannel, copy/paste the below into your editor and run!

```js
var Ringpop = require('ringpop');
var TChannel = require('tchannel');

function Cluster(opts) {
    this.name = opts.name;
    this.size = opts.size;
    this.basePort = opts.basePort;
    this.bootstrapNodes = [];

    // Create the bootstrap list of nodes that'll
    // be used to seed Ringpop for its join request.
    for (var i = 0; i < this.size; i++) {
        this.bootstrapNodes.push('127.0.0.1:' + (this.basePort + i));
    }
}

Cluster.prototype.launch = function launch(callback) {
    var self = this;
    var done = after(self.size, callback);

    for (var i = 0; i < this.size; i++) {
        var addr = this.bootstrapNodes[i];
        var addrParts = addr.split(':');

        var tchannel = new TChannel();
        var ringpop = new Ringpop({
            app: this.name,
            hostPort: addr,
            channel: tchannel.makeSubChannel({
                serviceName: 'ringpop',
                trace: false
            })
        });
        ringpop.setupChannel();

        // First make sure TChannel is accepting connections.
        tchannel.listen(+addrParts[1], addrParts[0], listenCb(ringpop));
    }


    function listenCb(ringpop) {
        // When TChannel is listening, bootstrap Ringpop. It'll
        // try to join its friends in the bootstrap list.
        return function onListen() {
            ringpop.bootstrap(self.bootstrapNodes, done);
        };
    }
};

// IGNORE THIS! It's a little utility function that invokes
// a callback after a specified number of invocations
// of its shim.
function after(count, callback) {
    var countdown = count;

    return function shim(err) {
        if (typeof callback !== 'function') return;

        if (err) {
            callback(err);
            callback = null;
            return;
        }

        if (--countdown === 0) {
            callback();
            callback = null;
        }
    };
}

if (require.main === module) {
    // Launch a Ringpop cluster of arbitrary size.
    var cluster = new Cluster({
        name: 'mycluster',
        size: 2,
        basePort: 3000
    });

    // When all nodes have been bootstrapped, your
    // Ringpop cluster will be ready for use.
    cluster.launch(function onLaunch(err) {
        if (err) {
            console.error('Error: failed to launch cluster');
            process.exit(1);
        }

        console.log('Ringpop cluster is ready!');
    });
}
```

# Documentation
Interested in where to go from here? Read the docs at
[ringpop.readthedocs.org](https://ringpop.readthedocs.org).

---
_Source: https://npm.io/package/ringpop · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._