Crate rustis

source ·

Expand description

rustis is a Redis client for Rust.

Philosophy

Low allocations
Full async library
Lock free implementation
Rust idiomatic API

Features

Support all Redis Commands until Redis 7.0
Async support (tokio or async-std)
Different client types:
- Single client
- Multiplexed client
- Pooled client manager (based on bb8)
Automatic command batching
Pipelining support
Configuration with Redis URL or dedicated builder
TLS support
Transaction support
Pub/sub support
Sentinel support
LUA Scripts/Functions support
Cluster support
Redis Stack support:
- RedisJSON v2.4 support
- RedisSearch v2.6 support
- RedisGraph v2.10 support
- RedisBloom v2.4 support
- RedisTimeSeries v1.8 support

Optional Features

tokio-runtime - Tokio runime (default)
async-std-runtime - async-std runtime (optional)
tokio-tls - Tokio TLS support (optional)
async-std-tls- async-std TLS support (optional)
pool - Pooled client manager (optional)
redis-json- RedisJSON v2.4 support (optional)
redis-search - RedisSearch v2.6 support (optional)
redis-graph - RedisGraph v2.10 support (optional)
redis-bloom - RedisBloom v2.4 support (optional)
redis-time-series - RedisTimeSeries v1.8 support (optional)
redis-stack - activate redis-json, redis-search, redis-graph, redis-bloom & redis-time-series at the same time (optional)

Basic Usage

Client

The central object in rustis is the client. There are 3 kinds of clients.

The single client

The single Client maintains a unique connection to a Redis Server or cluster and is not thread-safe.

use rustis::{
    Client, FlushingMode,
    Result, ServerCommands, StringCommands
};

#[tokio::main]
async fn main() -> Result<()> {
    let mut client = Client::connect("127.0.0.1:6379").await?;
    client.flushdb(FlushingMode::Sync).await?;

    client.set("key", "value").await?;
    let value: String = client.get("key").await?;
    println!("value: {value:?}");

    Ok(())
}

The multiplexed client

A multiplexed client can be cloned, allowing requests to be be sent concurrently on the same underlying connection.

Compared to a single client, a multiplexed client cannot offers access to all existing Redis commands. Transactions and blocking commands are not compatible with a multiplexed client because they monopolize the whole connection which cannot be shared anymore. It means other consumers of the same multiplexed client will be blocked each time a transaction or a blocking command is in progress, losing the advantage of a shared connection.

The pooled client manager

The pooled client manager holds a pool of client, based on bb8.

Each time a new command must be sent to the Redis Server, a client will be borrowed temporarily to the manager and automatic given back to it at the end of the operation.

The manager can be configured via bb8 with a various of options like maximum size, maximum lifetime, etc.

For you convenience, bb8 is reexport from the rustis crate.

use rustis::{
    PooledClientManager, Result, StringCommands
};
 
#[tokio::main]
async fn main() -> Result<()> {
    let manager = PooledClientManager::new("127.0.0.1:6379")?;
    let pool = rustis::bb8::Pool::builder()
        .max_size(10)
        .build(manager).await?;
 
    let mut client1 = pool.get().await.unwrap();
    client1.set("key1", "value1").await?;
    let value: String = client1.get("key1").await?;
    println!("value: {value:?}");
 
    let mut client2 = pool.get().await.unwrap();
    client2.set("key2", "value2").await?;
    let value: String = client2.get("key2").await?;
    println!("value: {value:?}");
 
    Ok(())
}