Struct quickwit_actors::ActorContext

pub struct ActorContext<A: Actor> { /* private fields */ }

Implementations

impl<A: Actor> ActorContext<A>

pub fn mailbox(&self) -> &Mailbox<A>

pub fn actor_instance_id(&self) -> &str

pub fn protect_zone(&self) -> ProtectedZoneGuard

This function returns a guard that prevents any supervisor from identifying the actor as dead. The protection ends when the ProtectZoneGuard is dropped.

In an ideal world, you should never need to call this function. It is only useful in some corner cases, like calling a long blocking from an external library that you trust.

pub fn kill_switch(&self) -> &KillSwitch

Gets a copy of the actor kill switch. This should rarely be used.

For instance, when quitting from the process_message function, prefer simply returning Error(ActorExitStatus::Failure(..))

pub fn progress(&self) -> &Progress

pub fn spawn_actor<SpawnedActor: Actor>(
    &self,
    actor: SpawnedActor
) -> SpawnBuilder<SpawnedActor>

pub fn record_progress(&self)

Records some progress. This function is only useful when implementing actors that may take more than HEARTBEAT to process a single message. In that case, you can call this function in the middle of the process_message method to prevent the actor from being identified as blocked or dead.

impl<A: Actor> ActorContext<A>

pub async fn send_message<DestActor: Actor, M>(
    &self,
    mailbox: &Mailbox<DestActor>,
    msg: M
) -> Result<Receiver<DestActor::Reply>, SendError> where
    DestActor: Handler<M>,
    M: 'static + Send + Sync + Debug, 

Posts a message in an actor’s mailbox.

This method does not wait for the message to be handled by the target actor. However, it returns a oneshot receiver that the caller that makes it possible to .await it. If the reply is important, chances are the .ask(...) method is more indicated.

Droppping the receiver channel will not cancel the processing of the messsage. It is a very common usage. In fact most actors are expected to send message in a fire-and-forget fashion.

Regular messages (as opposed to commands) are queued and guaranteed to be processed in FIFO order.

This method hides logic to prevent an actor from being identified as frozen if the destination actor channel is saturated, and we are simply experiencing back pressure.

pub async fn ask<DestActor: Actor, M, T>(
    &self,
    mailbox: &Mailbox<DestActor>,
    msg: M
) -> Result<T, AskError<Infallible>> where
    DestActor: Handler<M, Reply = T>,
    M: 'static + Send + Sync + Debug, 

pub async fn ask_for_res<DestActor: Actor, M, T, E: Debug>(
    &self,
    mailbox: &Mailbox<DestActor>,
    msg: M
) -> Result<T, AskError<E>> where
    DestActor: Handler<M, Reply = Result<T, E>>,
    M: 'static + Send + Sync + Debug, 

Similar to send_message, except this method waits asynchronously for the actor reply.

pub async fn send_exit_with_success<Dest: Actor>(
    &self,
    mailbox: &Mailbox<Dest>
) -> Result<(), SendError>

Send the Success message to terminate the destination actor with the Success exit status.

The message is queued like any regular message, so that pending messages will be processed first.

pub async fn send_self_message<M>(
    &self,
    msg: M
) -> Result<Receiver<A::Reply>, SendError> where
    A: Handler<M>,
    M: 'static + Sync + Send + Debug, 

async version of send_self_message.

pub async fn schedule_self_msg<M>(&self, after_duration: Duration, msg: M) where
    A: Handler<M>,
    M: 'static + Send + Sync + Debug, 

Trait Implementations

impl<A: Actor> Clone for ActorContext<A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Actor> Deref for ActorContext<A>

type Target = ActorContextInner<A>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.