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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
use futures::future::{self, Future};
use redis::{aio::ConnectionLike, ErrorKind, RedisFuture, Value};
use crate::pool_internal::Managed;
use crate::Poolable;
pub struct RedisConnection {
pub(crate) connection_state_ok: bool,
pub(crate) managed: Managed<ConnectionFlavour>,
}
impl ConnectionLike for RedisConnection {
fn req_packed_command(mut self, cmd: Vec<u8>) -> RedisFuture<(Self, Value)> {
if let Some(conn) = self.managed.value.take() {
self.connection_state_ok = false;
Box::new(conn.req_packed_command(cmd).map(|(conn, value)| {
self.managed.value = Some(conn);
self.connection_state_ok = true;
(self, value)
}))
} else {
Box::new(future::err(
(ErrorKind::IoError, "no connection - this is a bug of reool").into(),
))
}
}
fn req_packed_commands(
mut self,
cmd: Vec<u8>,
offset: usize,
count: usize,
) -> RedisFuture<(Self, Vec<Value>)> {
if let Some(conn) = self.managed.value.take() {
self.connection_state_ok = false;
Box::new(
conn.req_packed_commands(cmd, offset, count)
.map(|(conn, values)| {
self.managed.value = Some(conn);
self.connection_state_ok = true;
(self, values)
}),
)
} else {
Box::new(future::err(
(ErrorKind::IoError, "no connection - this is a bug of reool").into(),
))
}
}
fn get_db(&self) -> i64 {
if let Some(conn) = self.managed.value.as_ref() {
conn.get_db()
} else {
-1
}
}
}
impl Drop for RedisConnection {
fn drop(&mut self) {
if !self.connection_state_ok {
self.managed.value.take();
}
}
}
pub enum ConnectionFlavour {
RedisRs(redis::aio::Connection),
}
impl Poolable for ConnectionFlavour {}
impl ConnectionLike for ConnectionFlavour {
fn req_packed_command(self, cmd: Vec<u8>) -> RedisFuture<(Self, Value)> {
match self {
ConnectionFlavour::RedisRs(conn) => Box::new(
conn.req_packed_command(cmd)
.map(|(conn, v)| (ConnectionFlavour::RedisRs(conn), v)),
),
}
}
fn req_packed_commands(
self,
cmd: Vec<u8>,
offset: usize,
count: usize,
) -> RedisFuture<(Self, Vec<Value>)> {
match self {
ConnectionFlavour::RedisRs(conn) => Box::new(
conn.req_packed_commands(cmd, offset, count)
.map(|(conn, v)| (ConnectionFlavour::RedisRs(conn), v)),
),
}
}
fn get_db(&self) -> i64 {
match self {
ConnectionFlavour::RedisRs(ref conn) => conn.get_db(),
}
}
}