use crate::error::Error;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RetryPolicy {
pub timeout_ticks: u16,
pub max_retries: u8,
}
impl RetryPolicy {
pub const DEFAULT: Self = Self::new(1000, 5);
pub const fn new(timeout_ticks: u16, max_retries: u8) -> Self {
RetryPolicy {
timeout_ticks,
max_retries,
}
}
}
impl Default for RetryPolicy {
fn default() -> Self {
Self::DEFAULT
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct IdleBudget {
limit: Option<u32>,
idle: u32,
}
impl IdleBudget {
pub const DEFAULT: Self = Self::new(1_000_000);
pub const fn unbounded() -> Self {
IdleBudget {
limit: None,
idle: 0,
}
}
pub const fn new(max_idle_ticks: u32) -> Self {
IdleBudget {
limit: Some(max_idle_ticks),
idle: 0,
}
}
pub fn reset(&mut self) {
self.idle = 0;
}
pub fn tick<E>(&mut self) -> Result<(), Error<E>> {
let Some(limit) = self.limit else {
return Ok(());
};
self.idle = self.idle.saturating_add(1);
if self.idle > limit {
Err(Error::IdleBudgetExhausted)
} else {
Ok(())
}
}
}
impl Default for IdleBudget {
fn default() -> Self {
Self::DEFAULT
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_is_conservative_but_bounded() {
let policy = RetryPolicy::default();
assert!(policy.timeout_ticks > 0);
assert!(policy.max_retries > 0);
}
#[test]
fn zero_retries_means_send_once() {
let policy = RetryPolicy::new(10, 0);
assert_eq!(policy.max_retries, 0);
}
#[test]
fn idle_budget_trips_after_limit() {
let mut b = IdleBudget::new(2);
assert_eq!(b.tick::<()>(), Ok(()));
assert_eq!(b.tick::<()>(), Ok(()));
assert_eq!(b.tick::<()>(), Err(Error::IdleBudgetExhausted));
}
#[test]
fn idle_budget_reset_clears_streak() {
let mut b = IdleBudget::new(1);
assert_eq!(b.tick::<()>(), Ok(()));
b.reset();
assert_eq!(b.tick::<()>(), Ok(()));
assert_eq!(b.tick::<()>(), Err(Error::IdleBudgetExhausted));
}
#[test]
fn unbounded_idle_budget_never_trips() {
let mut b = IdleBudget::unbounded();
for _ in 0..10_000 {
assert_eq!(b.tick::<()>(), Ok(()));
}
}
}