Struct RetryActor 

pub struct RetryActor<T>
where
    T: Actor + Handler<T> + Clone + NotPersistentActor,
{ /* private fields */ }

Retry actor.

RetryActor re-sends the same message to a managed child actor according to the configured schedule. A successful tell() does not end the sequence by itself; retries continue until:

• RetryMessage::End is received
• max_retries is reached
• the target child can no longer accept messages

The retry cycle can only be started once with RetryMessage::Retry. Any later Retry messages are ignored.

RetryMessage::End is always terminal:

• before the cycle starts, it stops the actor without sending the target message
• while a retry is scheduled, it cancels the pending retry and finishes the cycle

Implementations

impl<T> RetryActor<T>

where T: Actor + Handler<T> + Clone + NotPersistentActor,

pub const fn new( target: T, message: T::Message, retry_strategy: Strategy, ) -> Self

Create a new RetryActor.

pub fn new_with_parent_message<P>( target: T, message: T::Message, retry_strategy: Strategy, completion_message: P::Message, ) -> Self

where P: Actor + Handler<P>,

Creates a RetryActor that notifies its parent with completion_message when the retry cycle finishes, either because:

• the retry budget is exhausted
• RetryMessage::End stops it explicitly
• the managed child no longer accepts messages

Trait Implementations

impl<T> Actor for RetryActor<T>

where T: Actor + Handler<T> + Clone + NotPersistentActor,

type Message = RetryMessage

The type of messages this actor accepts.

type Response = ()

The type returned by the actor in response to each message.

type Event = ()

The type of events this actor can broadcast to subscribers.

fn get_span(id: &str, _parent_span: Option<Span>) -> Span

Creates the tracing span for this actor instance.

fn pre_start<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Called once before the actor begins processing messages.

fn pre_stop<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Called when the actor is about to stop, before children are stopped.

fn drain_timeout() -> Duration

Maximum time to spend processing critical messages during shutdown before dropping them.

fn startup_timeout() -> Option<Duration>

Maximum time to wait for pre_start to complete; None disables the startup timeout.

fn stop_timeout() -> Option<Duration>

Maximum time a parent waits for this actor to acknowledge a stop request; None disables the stop timeout.

fn supervision_strategy() -> SupervisionStrategy

Returns the supervision strategy applied when this actor fails at startup.

fn pre_restart<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext<Self>, _error: Option<&'life2 Error>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Called when the actor is about to be restarted after a failure.

fn post_stop<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Called after all children have stopped and the actor is fully shut down. Override for final cleanup.

fn from_response(_response: Self::Response) -> Result<Self::Event, Error>

Maps a handler response to an event; call explicitly when you need that conversion.

impl<T> Handler<RetryActor<T>> for RetryActor<T>

where T: Actor + Handler<T> + Clone + NotPersistentActor,

fn handle_message<'life0, 'life1, 'async_trait>( &'life0 mut self, _path: ActorPath, message: RetryMessage, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Processes msg sent by sender and returns a response.

fn on_event<'life0, 'life1, 'async_trait>( &'life0 mut self, _event: A::Event, _ctx: &'life1 mut ActorContext<A>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Called when the actor wants to apply an event to its own state; not invoked automatically by the runtime.

fn on_child_error<'life0, 'life1, 'async_trait>( &'life0 mut self, error: Error, _ctx: &'life1 mut ActorContext<A>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Called when a child actor reports an error via ActorContext::emit_error.

fn on_child_fault<'life0, 'life1, 'async_trait>( &'life0 mut self, error: Error, _ctx: &'life1 mut ActorContext<A>, ) -> Pin<Box<dyn Future<Output = ChildAction> + Send + 'async_trait>>

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

Called when a child actor fails unrecoverably (panics or exhausts retries).

impl<T> NotPersistentActor for RetryActor<T>

where T: Actor + Handler<T> + Clone + NotPersistentActor,