Struct MaybeBackoff 

pub struct MaybeBackoff { /* private fields */ }

MaybeBackoff provides a simplified way to manage an optional exponential backoff while giving control over when to wait.

Example

let mut backoff = MaybeBackoff::default();

// Loop that runs fallible operation that should be retried with backoff.
loop {
    backoff.sleep().await; // Does nothing when not armed (disarmed by default).
    backoff.arm();

    while let Some(event) = event_source.next().await {
        match event {
            Ok(Event::Open) => debug!("Connected!"),
            Ok(Event::Message(event)) => match parse(event) {
                Ok(data) => {
                    backoff.disarm();
                    forward_data(data).await;
                    break;
                }
                Err(error) => {
                    error!("Parsing failed: {error:?}");
                    event_source.close();
                    continue;
                }
            },
            Err(error) => {
                error!("Event source failed: {error:?}");
                event_source.close();
                continue;
            }
        }
    }
}

Implementations

impl MaybeBackoff

pub fn arm(&mut self)

pub fn disarm(&mut self)

pub async fn sleep(&mut self)

Trait Implementations

impl Default for MaybeBackoff

fn default() -> MaybeBackoff

Returns the “default value” for a type.