salak_factory 0.3.0

Salak factory to package initialization.
Documentation 
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
116
117
118
119
120
121
122
123
124

//! Redis cluster configuration.
use crate::{
    pool::{PoolConfig, PoolCustomizer},
    Buildable,
};
use ::redis::cluster::*;
use ::redis::*;
use r2d2::{ManageConnection, Pool};
use salak::*;
use std::{str::FromStr, time::Duration};

/// Redis Connection Pool Configuration.
///
/// |property|required|default|
/// |-|-|-|
/// |redis_cluster.url|true||
/// |redis_cluster.password|false||
/// |redis_cluster.readonly|false||
/// |redis_cluster.read_timeout|false||
/// |redis_cluster.write_timeout|false||
/// |redis_cluster.auto_reconnect|false||
/// |redis_cluster.pool.max_size|false|${pool.max_size:}|
/// |redis_cluster.pool.min_idle|false|${pool.min_idle:}|
/// |redis_cluster.pool.thread_name|false|${pool.thread_name:}|
/// |redis_cluster.pool.thread_nums|false|${pool.thread_nums:}|
/// |redis_cluster.pool.test_on_check_out|false|${pool.test_on_check_out:}|
/// |redis_cluster.pool.max_lifetime|false|${pool.max_lifetime:}|
/// |redis_cluster.pool.idle_timeout|false|${pool.idle_timeout:}|
/// |redis_cluster.pool.connection_timeout|false|${pool.connection_timeout:5s}|
/// |redis_cluster.pool.wait_for_init|false|${pool.wait_for_init:false}|
#[cfg_attr(docsrs, doc(cfg(feature = "redis_cluster")))]
#[derive(FromEnvironment, Debug)]
#[salak(prefix = "redis_cluster")]
pub struct RedisClusterConfig {
    url: NonEmptyVec<String>,
    password: Option<String>,
    readonly: Option<bool>,
    read_timeout: Option<Duration>,
    write_timeout: Option<Duration>,
    auto_reconnect: Option<bool>,
    pool: PoolConfig,
}

/// Redis connection manager
#[cfg_attr(docsrs, doc(cfg(feature = "redis_cluster")))]
#[allow(missing_debug_implementations)]
pub struct RedisClusterConnectionManager {
    client: ClusterClient,
    read_timeout: Option<Duration>,
    write_timeout: Option<Duration>,
    auto_reconnect: Option<bool>,
}

impl ManageConnection for RedisClusterConnectionManager {
    type Connection = ClusterConnection;
    type Error = RedisError;

    fn connect(&self) -> Result<Self::Connection, Self::Error> {
        let conn = self.client.get_connection()?;
        if let Some(auto_reconnect) = self.auto_reconnect {
            conn.set_auto_reconnect(auto_reconnect);
        }
        conn.set_read_timeout(self.read_timeout)?;
        conn.set_write_timeout(self.write_timeout)?;
        Ok(conn)
    }

    fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
        cmd("PING").query(conn)
    }

    fn has_broken(&self, conn: &mut Self::Connection) -> bool {
        !conn.check_connection()
    }
}

impl Buildable for RedisClusterConfig {
    type Product = Pool<RedisClusterConnectionManager>;
    type Customizer = PoolCustomizer<RedisClusterConnectionManager>;

    fn build_with_key(
        self,
        _: &impl Environment,
        customizer: Self::Customizer,
    ) -> Result<Self::Product, PropertyError> {
        let mut config = vec![];
        for url in self.url.0 {
            config.push(ConnectionInfo::from_str(&url)?)
        }
        let mut builder = ClusterClientBuilder::new(config);
        if let Some(password) = self.password {
            builder = builder.password(password);
        }
        if let Some(readonly) = self.readonly {
            builder = builder.readonly(readonly);
        }
        let client = builder.open()?;

        self.pool.build_pool(
            RedisClusterConnectionManager {
                client,
                read_timeout: self.read_timeout,
                write_timeout: self.write_timeout,
                auto_reconnect: self.auto_reconnect,
            },
            customizer,
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn redis_tests() {
        let env = Salak::builder()
            .set("redis_cluster.url[0]", "redis://127.0.0.1/")
            .unwrap_build();
        let pool = env.get::<RedisClusterConfig>();
        assert_eq!(true, pool.is_ok());

        // print_keys::<RedisClusterConfig>();
    }
}