Crate actix_signal

Manage the lifecycle of an actix actor with its address.

If you want to stop/terminate an actor, you call ActorContext::stop or ActorContext::terminate within its execution context.

However, sometimes you have access to its address only. This crate adds a bunch of methods to the address so that you may stop or terminate the actor outside its running context.

Minimum supported rust version: 1.50.0

Example

use actix::{Actor, Context};
use actix_signal::{AddrSignalExt, SignalHandler};

#[derive(SignalHandler)]
struct MyActor;

impl Actor for MyActor {
    type Context = Context<Self>;
}

let actor = MyActor;
let addr = actor.start();

addr.stop();        // Stop the actor
addr.terminate();   // Terminate the actor

You may also implement handlers by hand if you don’t want to use the proc macro or need custom behaviors.

use actix::{Actor, Context, Handler, ActorContext};
use actix_signal::{AddrSignalExt, StopSignal, TerminateSignal};

struct MyActor;

impl Actor for MyActor {
    type Context = Context<Self>;
}

impl Handler<StopSignal> for MyActor {
    type Result = ();

    fn handle(&mut self, _msg: StopSignal, ctx: &mut Self::Context) -> Self::Result {
        ctx.stop();
    }
}

impl Handler<TerminateSignal> for MyActor {
    type Result = ();

    fn handle(&mut self, _msg: TerminateSignal, ctx: &mut Self::Context) -> Self::Result {
        ctx.terminate();
    }
}

let actor = MyActor;
let addr = actor.start();

addr.stop();        // Stop the actor
addr.terminate();   // Terminate the actor

Feature flags

derive - Provide #[derive(SignalHandler)] proc-macro.

Re-exports

pub use signals::*;

Modules

signals

Signals that can be handled by actors implementing SignalHandler.

Traits

AddrSignalExt

An extension trait for Addrs that provides convenient methods to control associated actors’ lifecycle.

SignalHandler

Actors that are able to handle signals.

ToSignalEnvelope

Execution contexts that are able to handle signals.