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

Example

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

#[tokio::main]
async fn main() {
    let mut cfg = Config::from_url("redis://127.0.0.1/");
    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 `dotenv` crate

use deadpool_redis::{redis::{cmd, FromRedisValue}, Runtime};
use dotenv::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());
    }
}

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.

This macro creates all the type aliases usually reexported by deadpool-* crates. Crates that implement a deadpool manager should be considered stand alone crates and users of it should not need to use deadpool directly.

Structs

Config

Configuration object.

Connection

Wrapper around redis::aio::Connection.

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. This is duplicated here in order to add support for the serde::Deserialize trait which is required for the serde support.

Runtime

Enumeration for picking a runtime implementation.