Struct Context

pub struct Context<C = (), K = Singleton, S = ()> { /* private fields */ }

An actor execution context.

Implementations

impl<C, K, S> Context<C, K, S>

pub fn addr(&self) -> Addr

Returns the actor’s address.

pub fn group(&self) -> Addr

Returns the current group’s address.

pub fn config(&self) -> &C

Returns the actual config.

pub fn key(&self) -> &K

Returns the actor’s key.

pub fn with<S1>(self, source: S1) -> Context<C, K, Combined<S, S1>>

Transforms the context to another one with the provided source.

pub fn set_status(&self, status: ActorStatus)

Updates the actor’s status.

ctx.set_status(ActorStatus::ALARMING.with_details("something wrong"));

pub fn close(&self) -> bool

Closes the mailbox, that leads to returning None from recv() and try_recv() after handling all available messages in the mailbox.

Returns true if the mailbox has just been closed.

pub async fn send<M: Message>(&self, message: M) -> Result<(), SendError<M>>

Sends a message using the routing system.

Returns Err if the message hasn’t reached any mailboxes.

Example

// Fire and forget.
let _ = ctx.send(SomethingHappened).await;

// Fire or fail.
ctx.send(SomethingHappened).await?;

// Fire or log.
if let Ok(err) = ctx.send(SomethingHappened).await {
    warn!("...", error = err);
}

pub fn try_send<M: Message>(&self, message: M) -> Result<(), TrySendError<M>>

Tries to send a message using the routing system.

Returns

• Ok(()) if the message has been added to any mailbox.
• Err(Full(_)) if some mailboxes are full.
• Err(Closed(_)) otherwise.

Example

// Fire and forget.
let _ = ctx.try_send(SomethingHappened);

// Fire or fail.
ctx.try_send(SomethingHappened)?;

// Fire or log.
if let Err(err) = ctx.try_send(SomethingHappened) {
    warn!("...", error = err);
}

pub fn request<R: Request>( &self, request: R, ) -> RequestBuilder<'_, C, K, S, R, Any>

Returns a request builder.

Example

// Request and wait for a response.
let response = ctx.request(SomeCommand).resolve().await?;

// Request and wait for all responses.
for result in ctx.request(SomeCommand).all().resolve().await {
    // ...
}

pub fn request_to<R: Request>( &self, recipient: Addr, request: R, ) -> RequestBuilder<'_, C, K, S, R, Any>

Returns a request builder to the specified recipient.

Example

// Request and wait for a response.
let response = ctx.request_to(addr, SomeCommand).resolve().await?;

// Request and wait for all responses.
for result in ctx.request_to(addr, SomeCommand).all().resolve().await {
    // ...
}

pub async fn send_to<M: Message>( &self, recipient: Addr, message: M, ) -> Result<(), SendError<M>>

Sends a message to the specified recipient.

Returns Err if the message hasn’t reached any mailboxes.

Example

// Fire and forget.
let _ = ctx.send_to(addr, SomethingHappened).await;

// Fire or fail.
ctx.send_to(addr, SomethingHappened).await?;

// Fire or log.
if let Some(err) = ctx.send_to(addr, SomethingHappened).await {
    warn!("...", error = err);
}

pub fn try_send_to<M: Message>( &self, recipient: Addr, message: M, ) -> Result<(), TrySendError<M>>

Tries to send a message to the specified recipient.

Returns Err if the message hasn’t reached mailboxes or they are full.

Example

// Fire and forget.
let _ = ctx.send(SomethingHappened).await;

// Fire or fail.
ctx.send(SomethingHappened).await?;

// Fire or log.
if let Some(err) = ctx.send(SomethingHappened).await {
    warn!("...", error = err);
}

pub fn respond<R: Request>(&self, token: ResponseToken<R>, message: R::Response)

Responds to the requester with the provided response.

The token can be used only once.

msg!(match envelope {
    (SomeRequest, token) => {
        ctx.respond(token, SomeResponse);
    }
})

pub async fn recv(&mut self) -> Option<Envelope>

where C: 'static, S: Source,

Receives the next envelope.

Panics

If the method is called again after returning None.

Examples

while let Some(envelope) = ctx.recv().await {
    msg!(match envelope {
        SomethingHappened => /* ... */,
    })
}

pub fn try_recv(&mut self) -> Result<Envelope, TryRecvError>

where C: 'static,

Receives the next envelope without waiting.

Panics

If the method is called again after returning Err(TryRecvError::Closed).

Examples

// Iterate over all available messages.
while let Ok(envelope) = ctx.try_recv() {
    msg!(match envelope {
        SomethingHappened => /* ... */,
    })
}

pub fn unpack_config<'c>(&self, config: &'c AnyConfig) -> &'c C

where C: for<'de> Deserialize<'de> + 'static,

Used to get the typed config from ValidateConfig.

msg!(match envelope {
    (ValidateConfig { config, .. }, token) => {
        let new_config = ctx.unpack_config(&config);
        ctx.respond(token, Err("oops".into()));
    }
})

pub fn pruned(&self) -> Context

Produces a new context that can be used for sending messages only.

Pruned contexts are likely to be removed in favor of Output.

Trait Implementations

impl<C, K: Clone> Clone for Context<C, K>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.