use core::time::Duration;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Backoff {
pub wait_minimum: Duration,
pub random_range: Duration,
pub repeat_times: u32,
}
impl Default for Backoff {
fn default() -> Self {
Self {
wait_minimum: Duration::from_secs(10),
random_range: Duration::from_secs(10),
repeat_times: 3,
}
}
}
impl Backoff {
#[must_use]
pub const fn immediate() -> Self {
Self {
wait_minimum: Duration::ZERO,
random_range: Duration::ZERO,
repeat_times: 0,
}
}
#[must_use]
pub const fn delay(&self, attempt: u32, jitter: Jitter) -> Duration {
let doublings = if attempt < self.repeat_times {
attempt
} else {
self.repeat_times
};
let factor = 1u64 << if doublings < 32 { doublings } else { 32 };
#[allow(clippy::cast_possible_truncation)]
let base = self
.wait_minimum
.saturating_mul(if factor > u32::MAX as u64 {
u32::MAX
} else {
factor as u32
});
let spread = jitter.of_millis(self.random_range.as_millis());
base.saturating_add(Duration::from_millis(spread))
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
pub struct Jitter(u32);
impl Jitter {
pub const NONE: Self = Self(0);
pub const FULL: Self = Self(u32::MAX);
#[must_use]
pub const fn from_random_u32(value: u32) -> Self {
Self(value)
}
#[must_use]
pub const fn from_ratio(numerator: u32, denominator: u32) -> Self {
assert!(denominator != 0, "a jitter ratio needs a denominator");
if numerator >= denominator {
return Self::FULL;
}
let scaled =
(numerator as u64 * u32::MAX as u64 + denominator as u64 / 2) / denominator as u64;
#[allow(clippy::cast_possible_truncation)]
Self(scaled as u32)
}
const fn of_millis(self, millis: u128) -> u64 {
let whole = u32::MAX as u128;
let scaled = (millis * self.0 as u128 + whole / 2) / whole;
#[allow(clippy::cast_possible_truncation)]
if scaled > u64::MAX as u128 {
u64::MAX
} else {
scaled as u64
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn doubles_then_plateaus_per_part_4_5_4() {
let backoff = Backoff::default();
let seconds = |attempt| backoff.delay(attempt, Jitter::NONE).as_secs();
assert_eq!(seconds(0), 10);
assert_eq!(seconds(1), 20);
assert_eq!(seconds(2), 40);
assert_eq!(seconds(3), 80);
assert_eq!(seconds(4), 80);
assert_eq!(seconds(50), 80);
}
#[test]
fn jitter_is_added_on_top_of_every_wait() {
let backoff = Backoff::default();
assert_eq!(backoff.delay(0, Jitter::FULL).as_secs(), 20);
assert_eq!(
backoff.delay(0, Jitter::from_ratio(1, 2)).as_millis(),
15_000
);
assert_eq!(backoff.delay(3, Jitter::FULL).as_secs(), 90);
}
}