-
Notifications
You must be signed in to change notification settings - Fork 107
/
lib.rs
81 lines (73 loc) · 2.23 KB
/
lib.rs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
//! Redis support for the `bb8` connection pool.
//!
//! # Example
//!
//! ```
//! use futures_util::future::join_all;
//! use bb8_redis::{
//! bb8,
//! redis::{cmd, AsyncCommands},
//! RedisConnectionManager
//! };
//!
//! #[tokio::main]
//! async fn main() {
//! let manager = RedisConnectionManager::new("redis://localhost").unwrap();
//! let pool = bb8::Pool::builder().build(manager).await.unwrap();
//!
//! let mut handles = vec![];
//!
//! for _i in 0..10 {
//! let pool = pool.clone();
//!
//! handles.push(tokio::spawn(async move {
//! let mut conn = pool.get().await.unwrap();
//!
//! let reply: String = cmd("PING").query_async(&mut *conn).await.unwrap();
//!
//! assert_eq!("PONG", reply);
//! }));
//! }
//!
//! join_all(handles).await;
//! }
//! ```
#![allow(clippy::needless_doctest_main)]
#![deny(missing_docs, missing_debug_implementations)]
pub use bb8;
pub use redis;
use async_trait::async_trait;
use redis::{aio::MultiplexedConnection, ErrorKind};
use redis::{Client, IntoConnectionInfo, RedisError};
/// A `bb8::ManageConnection` for `redis::Client::get_async_connection`.
#[derive(Clone, Debug)]
pub struct RedisConnectionManager {
client: Client,
}
impl RedisConnectionManager {
/// Create a new `RedisConnectionManager`.
/// See `redis::Client::open` for a description of the parameter types.
pub fn new<T: IntoConnectionInfo>(info: T) -> Result<Self, RedisError> {
Ok(Self {
client: Client::open(info.into_connection_info()?)?,
})
}
}
#[async_trait]
impl bb8::ManageConnection for RedisConnectionManager {
type Connection = MultiplexedConnection;
type Error = RedisError;
async fn connect(&self) -> Result<Self::Connection, Self::Error> {
self.client.get_multiplexed_async_connection().await
}
async fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
let pong: String = redis::cmd("PING").query_async(conn).await?;
match pong.as_str() {
"PONG" => Ok(()),
_ => Err((ErrorKind::ResponseError, "ping request").into()),
}
}
fn has_broken(&self, _: &mut Self::Connection) -> bool {
false
}
}