redis_universal_client/
lib.rsuse redis::{cluster::ClusterClient, Client, ErrorKind, RedisError, RedisResult};
#[derive(Clone)]
pub enum UniversalClient {
Client(Client),
Cluster(ClusterClient),
}
impl UniversalClient {
pub fn get_connection(&self) -> redis::RedisResult<UniversalConnection> {
match self {
Self::Client(cli) => cli.get_connection().map(UniversalConnection::Client),
Self::Cluster(cli) => cli.get_connection().map(UniversalConnection::Cluster),
}
}
pub fn open<T: redis::IntoConnectionInfo + Clone>(
addrs: Vec<T>,
) -> RedisResult<UniversalClient> {
let mut addrs = addrs;
if addrs.is_empty() {
return Err(RedisError::from((
ErrorKind::InvalidClientConfig,
"No address specified",
)));
}
if addrs.len() == 1 {
Client::open(addrs.remove(0)).map(Self::Client)
} else {
ClusterClient::open(addrs).map(Self::Cluster)
}
}
}
pub struct UniversalBuilder<T> {
addrs: Vec<T>,
cluster: bool,
}
impl<T> UniversalBuilder<T> {
pub fn new(addrs: Vec<T>) -> UniversalBuilder<T> {
UniversalBuilder {
addrs,
cluster: false,
}
}
pub fn cluster(mut self, flag: bool) -> UniversalBuilder<T> {
self.cluster = flag;
self
}
pub fn build(self) -> RedisResult<UniversalClient>
where
T: redis::IntoConnectionInfo + Clone,
{
let UniversalBuilder { mut addrs, cluster } = self;
if addrs.is_empty() {
return Err(RedisError::from((
ErrorKind::InvalidClientConfig,
"No address specified",
)));
}
if cluster {
ClusterClient::open(addrs).map(UniversalClient::Cluster)
} else {
Client::open(addrs.remove(0)).map(UniversalClient::Client)
}
}
}
pub enum UniversalConnection {
Client(redis::Connection),
Cluster(redis::cluster::ClusterConnection),
}
impl redis::ConnectionLike for UniversalConnection {
fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<redis::Value> {
match self {
Self::Client(conn) => conn.req_packed_command(cmd),
Self::Cluster(conn) => conn.req_packed_command(cmd),
}
}
fn req_packed_commands(
&mut self,
cmd: &[u8],
offset: usize,
count: usize,
) -> RedisResult<Vec<redis::Value>> {
match self {
Self::Client(conn) => conn.req_packed_commands(cmd, offset, count),
Self::Cluster(conn) => conn.req_packed_commands(cmd, offset, count),
}
}
fn get_db(&self) -> i64 {
match self {
Self::Client(conn) => conn.get_db(),
Self::Cluster(conn) => conn.get_db(),
}
}
fn is_open(&self) -> bool {
match self {
Self::Client(conn) => conn.is_open(),
Self::Cluster(conn) => conn.is_open(),
}
}
fn check_connection(&mut self) -> bool {
match self {
Self::Client(conn) => conn.check_connection(),
Self::Cluster(conn) => conn.check_connection(),
}
}
}