Struct RetryNode

pub struct RetryNode<N, Context, A = DefaultAction>
where
    N: Node<Context, A>,
    Context: Send + Sync + 'static,
    A: ActionType + Send + Sync + 'static,
{ /* private fields */ }

A node that retries another node if it fails

Implementations

impl<N, Context, A> RetryNode<N, Context, A>

where N: Node<Context, A>, Context: Send + Sync + 'static, A: ActionType + Send + Sync + 'static,

pub fn with_constant_backoff( inner_node: N, max_retries: usize, delay: Duration, ) -> Self

Create a new retry node with a constant backoff

pub fn with_linear_backoff( inner_node: N, max_retries: usize, base: Duration, increment: Duration, ) -> Self

Create a new retry node with linear backoff

pub fn with_exponential_backoff( inner_node: N, max_retries: usize, base: Duration, max: Duration, ) -> Self

Create a new retry node with exponential backoff

pub fn with_custom_backoff<F>(inner_node: N, max_retries: usize, f: F) -> Self

where F: Fn(usize) -> Duration + Send + Sync + 'static,

Create a new retry node with a custom backoff strategy

Trait Implementations

impl<N, Context, A> Node<Context, A> for RetryNode<N, Context, A>

where N: Node<Context, A> + Debug + Send + Sync, Context: Debug + Send + Sync + 'static, A: ActionType + Default + Debug + Send + Sync + 'static, N::Output: Clone + Send + Sync + 'static,

type Output = <N as Node<Context, A>>::Output

The output type produced by this node

fn id(&self) -> NodeId

Get the unique identifier for this node

fn process<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut Context, ) -> Pin<Box<dyn Future<Output = Result<NodeOutcome<Self::Output, A>, FloxideError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Process the node asynchronously