https://github.com/lbovet/vertx-redisques

A highly scalable redis-persistent queuing system for vertx
https://github.com/lbovet/vertx-redisques

Last synced: 5 months ago
JSON representation

A highly scalable redis-persistent queuing system for vertx

Host: GitHub
URL: https://github.com/lbovet/vertx-redisques
Owner: lbovet
License: other
Created: 2012-12-26T22:35:09.000Z (over 12 years ago)
Default Branch: master
Last Pushed: 2018-01-08T18:38:29.000Z (over 7 years ago)
Last Synced: 2024-04-17T15:36:25.030Z (about 1 year ago)
Language: Java
Size: 2.23 MB
Stars: 8
Watchers: 4
Forks: 12
Open Issues: 0
Metadata Files:
- Readme: README.md
- License: LICENSE.txt

Awesome Lists containing this project

README

# vertx-redisques

[![Build Status](https://travis-ci.org/swisspush/vertx-redisques.svg?branch=master)](https://travis-ci.org/swisspush/vertx-redisques)
[![codecov](https://codecov.io/gh/swisspush/vertx-redisques/branch/master/graph/badge.svg)](https://codecov.io/gh/swisspush/vertx-redisques)
[![Maven Central](https://img.shields.io/maven-central/v/org.swisspush/redisques.svg)](http://search.maven.org/#artifactdetails|org.swisspush|redisques|2.2.0|)

A highly scalable redis-persistent queuing system for vert.x.

## Getting Started
### Install
* Clone this repository or unzip [archive](https://github.com/swisspush/vertx-redisques/archive/master.zip)
* Install and start Redis
* Debian/Ubuntu: `apt-get install redis-server`
* Fedora/RedHat/CentOS: `yum install redis`
* OS X: `brew install redis`
* [Windows](https://github.com/MSOpenTech/redis/releases/download/win-2.8.2400/Redis-x64-2.8.2400.zip)
* [Other](http://redis.io/download)

### Build
You need Java 8 and Maven.
```
cd vertx-redisques
mvn clean install
```

## Dynamic Queues

They are stored as redis lists, thus created only when needed and removed when empty.
There is nothing left even if you just used thousands of queues with thousands of messages.

## Smart Consuming

It is guaranteed that a queue is consumed by the same RedisQuesVerticle instance (a consumer).
If no consumer is registered for a queue, one is assigned (this uses redis setnx to ensure only one is assigned).
When idle for a given time, a consumer is removed. This prevents subscription leaks and makes recovering automatic
when a consumer dies.

## Safe Distribution

There is no single point of control/failure. Just create many instances of RedisQues, they will work together.
If an instance dies, its queues will be assigned to other instances.

## Configuration

The following configuration values are available:

### Configuration util

The configurations have to be passed as JsonObject to the module. For a simplified configuration the _RedisquesConfigurationBuilder_ can be used.

Example:

```java
RedisquesConfiguration config = RedisquesConfiguration.with()
.redisHost("anotherhost")
.redisPort(1234)
.build();

JsonObject json = config.asJsonObject();
```

Properties not overridden will not be changed. Thus remaining default.

To use default values only, the _RedisquesConfiguration_ constructor without parameters can be used:

```java
JsonObject json = new RedisquesConfiguration().asJsonObject();
```

## RedisQues APIs

Redisques API for Vert.x - Eventbus

**Evenbus Settings:**

> address = redisque

### RedisquesAPI util
For a simplified working with the Redisques module, see the RedisquesAPI class:

> org.swisspush.redisques.util.RedisquesAPI

This class provides utility methods for a simple configuration of the queue operations. See _Queue operations_ chapter below for details.

### Queue operations
The following operations are available in the Redisques module.

#### getConfiguration

Request Data

```
{
"operation": "getConfiguration"
}
```

Response Data

```
{
"status": "ok" / "error",
"value":
}
```

#### setConfiguration

Request Data

```
{
"operation": "setConfiguration",
"payload": {
"": ,
"": ,
"":
}
}
```

Response Data

```
{
"status": "ok" / "error",
"message":
}
```

#### enqueue

Request Data

```
{
"operation": "enqueue",
"payload": {
"queuename":
},
"message": {
"method": "POST",
"uri": ,
"payload": null
}
}
```

Response Data

```
{
"status": "ok" / "error",
"message": "enqueued" /
}
```

#### lockedEnqueue
Request Data

```
{
"operation": "lockedEnqueue",
"payload": {
"queuename": ,
"requestedBy":
},
"message": {
"method": "POST",
"uri": ,
"payload": null
}
}
```
Response Data
```
{
"status": "ok" / "error",
"message": "enqueued" /
}
```

#### getQueues

Request Data

```
{
"operation": "getQueues"
}
```

Response Data

```
{
"status": "ok" / "error",
"value":
}
```

#### getQueuesCount

Request Data

```
{
"operation": "getQueuesCount"
}
```

Response Data

```
{
"status": "ok" / "error",
"value":
}
```

#### getQueueItemsCount

Request Data
```
{
"operation": "getQueueItemsCount",
"payload": {
"queuename":
}
}
```

Response Data
```
{
"status": "ok" / "error",
"value":
}
```

#### check

Request Data
```
{
"operation": "check"
}
```

Response Data
```
{}
```

#### reset

Request Data
```
{
"operation": "reset"
}
```

Response Data
```
{}
```

#### stop

Request Data
```
{
"operation": "stop"
}
```