sabi_redis 0.7.0

The sabi data access library for Redis in Rust
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

// Copyright (C) 2026 Takayuki Sato. All Rights Reserved.
// This program is free software under MIT License.
// See the file LICENSE in this distribution for more details.

use tokio::time;

pub(crate) struct Retry {
    max_count: u32,
    init_delay_ms: u64,
    max_delay_ms: u64,
    current_count: u32,
}

impl Retry {
    pub(crate) fn new() -> Self {
        Self {
            max_count: 30,
            init_delay_ms: 1000,
            max_delay_ms: 5000,
            current_count: 0,
        }
    }

    pub(crate) fn with_params(max_count: u32, init_delay_ms: u64, max_delay_ms: u64) -> Self {
        Self {
            max_count,
            init_delay_ms,
            max_delay_ms,
            current_count: 0,
        }
    }

    pub(crate) fn reset(&mut self) {
        self.current_count = 0;
    }

    pub(crate) async fn wait_with_backoff_async(&mut self) -> bool {
        if self.current_count >= self.max_count {
            return false;
        }
        let count = self.current_count + 1;
        let wait_ms = self
            .init_delay_ms
            .saturating_mul(2u64.saturating_pow(self.current_count))
            .min(self.max_delay_ms);
        time::sleep(time::Duration::from_millis(wait_ms)).await;
        self.current_count = count;
        true
    }
}

#[cfg(test)]
mod unit_tests {
    use super::*;
    use tokio::time::Instant;

    #[test]
    fn test_new() {
        let retry = Retry::new();
        assert_eq!(retry.max_count, 30);
        assert_eq!(retry.init_delay_ms, 1000);
        assert_eq!(retry.max_delay_ms, 5000);
        assert_eq!(retry.current_count, 0);
    }

    #[test]
    fn test_with_params() {
        let retry = Retry::with_params(5, 100, 1000);
        assert_eq!(retry.max_count, 5);
        assert_eq!(retry.init_delay_ms, 100);
        assert_eq!(retry.max_delay_ms, 1000);
        assert_eq!(retry.current_count, 0);
    }

    #[tokio::test]
    async fn test_wait_with_backoff() {
        let mut retry = Retry::with_params(6, 100, 1000);

        let tm = Instant::now();
        assert!(retry.wait_with_backoff_async().await);
        let d = tm.elapsed().as_millis();
        assert!(d > 90);
        assert!(d < 200);

        let tm = Instant::now();
        assert!(retry.wait_with_backoff_async().await);
        let d = tm.elapsed().as_millis();
        assert!(d > 190);
        assert!(d < 300);

        let tm = Instant::now();
        assert!(retry.wait_with_backoff_async().await);
        let d = tm.elapsed().as_millis();
        assert!(d > 390);
        assert!(d < 500);

        let tm = Instant::now();
        assert!(retry.wait_with_backoff_async().await);
        let d = tm.elapsed().as_millis();
        assert!(d > 790);
        assert!(d < 900);

        let tm = Instant::now();
        assert!(retry.wait_with_backoff_async().await);
        let d = tm.elapsed().as_millis();
        assert!(d > 990);
        assert!(d < 1100);

        let tm = Instant::now();
        assert!(retry.wait_with_backoff_async().await);
        let d = tm.elapsed().as_millis();
        assert!(d > 990);
        assert!(d < 1100);

        assert!(!retry.wait_with_backoff_async().await);
    }
}