Struct toad::retry::RetryTimer

pub struct RetryTimer<C: Clock> { /* private fields */ }

A non-blocking timer that allows a fixed-delay or exponential-backoff retry, that lives alongside some operation to retry.

It does not contain the work to be done (e.g. Box<fn()>) because we don’t have the luxury of a memory allocator :)

use embedded_time::clock::Clock;
use embedded_time::duration::Milliseconds;
use toad::retry;

fn main() {
  let mut called = false;
  let mut fails_once = || -> Result<(), ()> {
    // ...
  };

  let clock = toad::std::Clock::new();
  let now = || clock.try_now().unwrap();
  let strategy = retry::Strategy::Delay { min: Milliseconds(1),
                                          max: Milliseconds(2) };
  let mut retry = retry::RetryTimer::new(now(), strategy, retry::Attempts(2));

  while let Err(_) = fails_once() {
    match nb::block!(retry.what_should_i_do(now())) {
      | Ok(retry::YouShould::Retry) => continue,
      | Ok(retry::YouShould::Cry) => panic!("no more attempts! it failed more than once!!"),
      | Err(clock_err) => unreachable!(),
    }
  }
}

Implementations

impl<C> RetryTimer<C>where C: Clock,

pub fn new( start: Instant<C>, strategy: Strategy, max_attempts: Attempts ) -> Self

Create a new retrier

pub fn what_should_i_do( &mut self, now: Instant<C> ) -> Result<YouShould, Infallible>

When the thing we keep trying fails, invoke this to tell the retrytimer “it failed again! what do I do??”

Returns nb::Error::WouldBlock when we have not yet waited the appropriate amount of time to retry.

pub fn first_attempted_at(&self) -> Instant<C>

Get the instant this retry timer was first attempted

pub fn last_attempted_at(&self) -> Instant<C>

Get the instant this retry timer was last attempted (if at all)

pub fn next_attempt_at(&self) -> Instant<C>

Get the next time at which this should be retried

Trait Implementations

impl<C> Clone for RetryTimer<C>where C: Clock,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug + Clock> Debug for RetryTimer<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C> PartialEq<RetryTimer<C>> for RetryTimer<C>where C: Clock,

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C> Copy for RetryTimer<C>where C: Clock,

impl<C> Eq for RetryTimer<C>where C: Clock,