Crate deadpool_redis

Expand description

§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

§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());
    }
}

§FAQ

How can I enable features of the redis crate?

Make sure that you depend on the same version of redis as deadpool-redis does and enable the needed features in your own Crate.toml file:
```
[dependencies]
deadpool-redis = { version = "0.9", features = ["serde"] }
redis = { version = "0.21", default-features = false, features = ["tls"] }
```

§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§

cluster: This module extends the library to support Redis Cluster.
sentinel: 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.

Crate deadpool_redisCopy item path

§Deadpool for Redis

§Features

§Example

§Example with config and dotenvy crate

§Example (Cluster)

§Example with config and dotenvy crate

§FAQ

§License

Re-exports§

Modules§

Structs§

Enums§

Type Aliases§

Crate deadpool_redis

§Example with `config` and `dotenvy` crate

§Example with `config` and `dotenvy` crate