redsync 1.0.1

A Rust implementation of Redlock for distributed locks with Redis
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

use crate::instance::Instance;
use crate::redsync::Redsync;

use std::time::Duration;

/// `RedsyncBuilder` is a builder for configuring and constructing a Redsync instance.
pub struct RedsyncBuilder<I: Instance> {
    cluster: Vec<I>,
    retry_count: u32,
    retry_delay: Duration,
}

impl<I: Instance> RedsyncBuilder<I> {
    pub fn new(cluster: Vec<I>) -> Self {
        Self {
            cluster,
            retry_count: 3,
            retry_delay: Duration::from_millis(200),
        }
    }

    pub fn retry_count(mut self, retry_count: u32) -> Self {
        self.retry_count = retry_count;
        self
    }

    pub fn retry_delay(mut self, retry_delay: Duration) -> Self {
        self.retry_delay = retry_delay;
        self
    }

    pub fn build(self) -> Redsync<I> {
        let quorum = (self.cluster.len() as u32) / 2 + 1;
        let retry_jitter = self.retry_delay.as_millis() as f64 * 0.5;

        Redsync {
            cluster: self.cluster,
            quorum,
            retry_count: self.retry_count,
            retry_delay: self.retry_delay,
            retry_jitter,
            drift_factor: 0.01,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::errors::RedsyncError;
    use crate::instance::RedisInstance;

    #[test]
    fn default() -> Result<(), RedsyncError> {
        let cluster = vec![RedisInstance::new("redis://127.0.0.1:6379")?];
        let redsync = RedsyncBuilder::new(cluster).build();

        assert_eq!(redsync.cluster.len(), 1);
        assert_eq!(redsync.quorum, 1);
        assert_eq!(redsync.retry_count, 3);
        assert_eq!(redsync.retry_delay, Duration::from_millis(200));
        assert_eq!(redsync.retry_jitter, 100.0);
        assert_eq!(redsync.drift_factor, 0.01);

        Ok(())
    }

    #[test]
    fn retry_count() -> Result<(), RedsyncError> {
        let cluster = vec![RedisInstance::new("redis://127.0.0.1:6379")?];
        let redsync = RedsyncBuilder::new(cluster).retry_count(5).build();

        assert_eq!(redsync.cluster.len(), 1);
        assert_eq!(redsync.quorum, 1);
        assert_eq!(redsync.retry_count, 5);
        assert_eq!(redsync.retry_delay, Duration::from_millis(200));
        assert_eq!(redsync.retry_jitter, 100.0);
        assert_eq!(redsync.drift_factor, 0.01);

        Ok(())
    }

    #[test]
    fn retry_delay() -> Result<(), RedsyncError> {
        let cluster = vec![RedisInstance::new("redis://127.0.0.1:6379")?];
        let redsync = RedsyncBuilder::new(cluster)
            .retry_delay(Duration::from_millis(100))
            .build();

        assert_eq!(redsync.cluster.len(), 1);
        assert_eq!(redsync.quorum, 1);
        assert_eq!(redsync.retry_count, 3);
        assert_eq!(redsync.retry_delay, Duration::from_millis(100));
        assert_eq!(redsync.retry_jitter, 50.0);
        assert_eq!(redsync.drift_factor, 0.01);

        Ok(())
    }
}