hasp-core 0.2.0-alpha

Core contracts, errors, and traits for hasp.
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use crate::{Backend, Error, SecretString};
use std::sync::Arc;
use std::time::Duration;
use url::Url;

/// Decorator backend that retries transient failures with exponential backoff.
pub struct RetryBackend {
    inner: Arc<dyn Backend>,
    max_retries: u32,
    base_delay: Duration,
}

impl RetryBackend {
    /// Create a new retry decorator.
    pub fn new(inner: Arc<dyn Backend>) -> Self {
        Self {
            inner,
            max_retries: 3,
            base_delay: Duration::from_millis(100),
        }
    }

    /// Set the maximum number of retry attempts.
    pub fn max_retries(mut self, n: u32) -> Self {
        self.max_retries = n;
        self
    }

    /// Set the base delay between retries (doubles each attempt).
    pub fn base_delay(mut self, d: Duration) -> Self {
        self.base_delay = d;
        self
    }

    fn retry(
        &self,
        mut op: impl FnMut() -> Result<SecretString, Error>,
    ) -> Result<SecretString, Error> {
        let mut last_err = None;
        for attempt in 0..=self.max_retries {
            match op() {
                Ok(val) => return Ok(val),
                Err(e) => {
                    if !e.is_transient() || attempt == self.max_retries {
                        return Err(e);
                    }
                    let delay = Self::backoff(attempt);
                    std::thread::sleep(delay);
                    last_err = Some(e);
                }
            }
        }
        Err(last_err.unwrap())
    }

    fn retry_void(&self, mut op: impl FnMut() -> Result<(), Error>) -> Result<(), Error> {
        let mut last_err = None;
        for attempt in 0..=self.max_retries {
            match op() {
                Ok(()) => return Ok(()),
                Err(e) => {
                    if !e.is_transient() || attempt == self.max_retries {
                        return Err(e);
                    }
                    let delay = Self::backoff(attempt);
                    std::thread::sleep(delay);
                    last_err = Some(e);
                }
            }
        }
        Err(last_err.unwrap())
    }

    fn retry_bool(&self, mut op: impl FnMut() -> Result<bool, Error>) -> Result<bool, Error> {
        let mut last_err = None;
        for attempt in 0..=self.max_retries {
            match op() {
                Ok(val) => return Ok(val),
                Err(e) => {
                    if !e.is_transient() || attempt == self.max_retries {
                        return Err(e);
                    }
                    let delay = Self::backoff(attempt);
                    std::thread::sleep(delay);
                    last_err = Some(e);
                }
            }
        }
        Err(last_err.unwrap())
    }

    fn retry_vec(
        &self,
        mut op: impl FnMut() -> Result<Vec<crate::Entry>, Error>,
    ) -> Result<Vec<crate::Entry>, Error> {
        let mut last_err = None;
        for attempt in 0..=self.max_retries {
            match op() {
                Ok(val) => return Ok(val),
                Err(e) => {
                    if !e.is_transient() || attempt == self.max_retries {
                        return Err(e);
                    }
                    let delay = Self::backoff(attempt);
                    std::thread::sleep(delay);
                    last_err = Some(e);
                }
            }
        }
        Err(last_err.unwrap())
    }

    /// Exponential backoff with deterministic jitter.
    ///
    /// delay = base_delay * 2^attempt + jitter
    /// where jitter = (attempt * 7) % 50 to avoid adding rand.
    fn backoff(attempt: u32) -> Duration {
        let base = Duration::from_millis(100);
        let multiplier = 2_u128.pow(attempt);
        let exponential = base.as_millis().saturating_mul(multiplier);
        let jitter = (attempt.wrapping_mul(7) % 50) as u128;
        Duration::from_millis(u64::try_from(exponential.saturating_add(jitter)).unwrap_or(u64::MAX))
    }
}

impl Backend for RetryBackend {
    fn scheme(&self) -> &'static str {
        self.inner.scheme()
    }

    fn get(&self, url: &Url) -> Result<SecretString, Error> {
        self.retry(|| self.inner.get(url))
    }

    fn put(&self, url: &Url, value: &SecretString) -> Result<(), Error> {
        self.retry_void(|| self.inner.put(url, value))
    }

    fn list(&self, url: &Url) -> Result<Vec<crate::Entry>, Error> {
        self.retry_vec(|| self.inner.list(url))
    }

    fn delete(&self, url: &Url) -> Result<(), Error> {
        self.retry_void(|| self.inner.delete(url))
    }

    fn exists(&self, url: &Url) -> Result<bool, Error> {
        self.retry_bool(|| self.inner.exists(url))
    }
}