Crate deadpool_redis 

Deadpool for Redis

Deadpool is a dead simple async pool for connections and objects of any type.

This crate implements a deadpool manager for redis.

Features

Feature	Description	Extra dependencies	Default
rt_tokio_1	Enable support for tokio crate	deadpool/rt_tokio_1, redis/tokio-comp	yes
rt_async-std_1	Enable support for async-std crate	deadpool/rt_async-std_1, redis/async-std-comp	no
serde	Enable support for serde crate	deadpool/serde, serde/derive	no
cluster	Enable support for Redis Cluster	redis/cluster-async	no
sentinel	Enable high-level interfaces for communication with Redis sentinels	redis/sentinel, tokio/sync	no

All of the features of redis are also re-exported. For example, the feature tls-rustls does enable the feature tls-rustls from the redis crate.

Example

use std::env;

use deadpool_redis::{redis::{cmd, FromRedisValue}, Config, Runtime};

#[tokio::main]
async fn main() {
    let mut cfg = Config::from_url(env::var("REDIS__URL").unwrap());
    let pool = cfg.create_pool(Some(Runtime::Tokio1)).unwrap();
    {
        let mut conn = pool.get().await.unwrap();
        cmd("SET")
            .arg(&["deadpool/test_key", "42"])
            .query_async::<()>(&mut conn)
            .await.unwrap();
    }
    {
        let mut conn = pool.get().await.unwrap();
        let value: String = cmd("GET")
            .arg(&["deadpool/test_key"])
            .query_async(&mut conn)
            .await.unwrap();
        assert_eq!(value, "42".to_string());
    }
}

Example with config and dotenvy crate

use deadpool_redis::{redis::{cmd, FromRedisValue}, Runtime};
use dotenvy::dotenv;

#[derive(Debug, serde::Deserialize)]
struct Config {
    #[serde(default)]
    redis: deadpool_redis::Config
}

impl Config {
      pub fn from_env() -> Result<Self, config::ConfigError> {
         config::Config::builder()
            .add_source(config::Environment::default().separator("__"))
            .build()?
            .try_deserialize()
    }
}

#[tokio::main]
async fn main() {
    dotenv().ok();
    let cfg = Config::from_env().unwrap();
    let pool = cfg.redis.create_pool(Some(Runtime::Tokio1)).unwrap();
    {
        let mut conn = pool.get().await.unwrap();
        cmd("SET")
            .arg(&["deadpool/test_key", "42"])
            .query_async::<()>(&mut conn)
            .await.unwrap();
    }
    {
        let mut conn = pool.get().await.unwrap();
        let value: String = cmd("GET")
            .arg(&["deadpool/test_key"])
            .query_async(&mut conn)
            .await.unwrap();
        assert_eq!(value, "42".to_string());
    }
}

Example (Cluster)

use std::env;
use deadpool_redis::{redis::{cmd, FromRedisValue}};
use deadpool_redis::cluster::{Config, Runtime};

#[tokio::main]
async fn main() {
    let redis_urls = env::var("REDIS_CLUSTER__URLS")
        .unwrap()
        .split(',')
        .map(String::from)
        .collect::<Vec<_>>();
    let mut cfg = Config::from_urls(redis_urls);
    let pool = cfg.create_pool(Some(Runtime::Tokio1)).unwrap();
    {
        let mut conn = pool.get().await.unwrap();
        cmd("SET")
            .arg(&["deadpool/test_key", "42"])
            .query_async::<()>(&mut conn)
            .await.unwrap();
    }
    {
        let mut conn = pool.get().await.unwrap();
        let value: String = cmd("GET")
            .arg(&["deadpool/test_key"])
            .query_async(&mut conn)
            .await.unwrap();
        assert_eq!(value, "42".to_string());
    }
}

Example with config and dotenvy crate

use deadpool_redis::redis::{cmd, FromRedisValue};
use deadpool_redis::cluster::{Runtime};
use dotenvy::dotenv;

#[derive(Debug, serde::Deserialize)]
struct Config {
    #[serde(default)]
    redis_cluster: deadpool_redis::cluster::Config
}

impl Config {
      pub fn from_env() -> Result<Self, config::ConfigError> {
         config::Config::builder()
            .add_source(
                config::Environment::default()
                .separator("__")
                .try_parsing(true)
                .list_separator(","),
            )
            .build()?
            .try_deserialize()
    }
}

#[tokio::main]
async fn main() {
    dotenv().ok();
    let cfg = Config::from_env().unwrap();
    let pool = cfg.redis_cluster.create_pool(Some(Runtime::Tokio1)).unwrap();
    {
        let mut conn = pool.get().await.unwrap();
        cmd("SET")
            .arg(&["deadpool/test_key", "42"])
            .query_async::<()>(&mut conn)
            .await.unwrap();
    }
    {
        let mut conn = pool.get().await.unwrap();
        let value: String = cmd("GET")
            .arg(&["deadpool/test_key"])
            .query_async(&mut conn)
            .await.unwrap();
        assert_eq!(value, "42".to_string());
    }
}

License

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Re-exports

pub use redis;

Modules

clustercluster

This module extends the library to support Redis Cluster.

sentinelsentinel

This module extends the library to support Redis Cluster.

Structs

Config

Configuration object.

Connection

Wrapper around redis::aio::MultiplexedConnection.

ConnectionInfo

This is a 1:1 copy of the redis::ConnectionInfo struct. This is duplicated here in order to add support for the serde::Deserialize trait which is required for the serde support.

Manager

Manager for creating and recycling redis connections.

Metrics

Statistics regarding an object returned by the pool

PoolConfig

Pool configuration.

RedisConnectionInfo

This is a 1:1 copy of the redis::RedisConnectionInfo struct. This is duplicated here in order to add support for the serde::Deserialize trait which is required for the serde support.

Status

The current pool status.

Timeouts

Timeouts when getting Objects from a Pool.

Enums

ConfigError

This error is returned if the configuration contains an error

ConnectionAddr

This is a 1:1 copy of the redis::ConnectionAddr enumeration (excluding tls_params since it is entirely opaque to consumers).

ProtocolVersion

This is a 1:1 copy of the redis::ProtocolVersion struct. Enum representing the communication protocol with the server. This enum represents the types of data that the server can send to the client, and the capabilities that the client can use.

Runtime

Enumeration for picking a runtime implementation.

Type Aliases

BuildError

Type alias for using deadpool::managed::BuildError with redis.

CreatePoolError

Type alias for using deadpool::managed::CreatePoolError with redis.

Hook

Type alias for using deadpool::managed::Hook with redis.

HookError

Type alias for using deadpool::managed::HookError with redis.

Object

Type alias for using deadpool::managed::Object with redis.

Pool

Type alias for using deadpool::managed::Pool with redis.

PoolBuilder

Type alias for using deadpool::managed::PoolBuilder with redis.

PoolError

Type alias for using deadpool::managed::PoolError with redis.