Struct actix::Supervisor

pub struct Supervisor<A>
where
    A: Supervised + Actor<Context = Context<A>>,
{ /* private fields */ }

Actor supervisor

A Supervisor manages incoming messages for an actor. In case of actor failure, the supervisor creates a new execution context and restarts the actor’s lifecycle. A Supervisor does not re-create their actor, it just calls the restarting() method.

Supervisors have the same lifecycle as actors. If all addresses to a supervisor gets dropped and its actor does not execute anything, the supervisor terminates.

Supervisors can not guarantee that their actors successfully processes incoming messages. If the actor fails during message processing, the message can not be recovered. The sender would receive an Err(Cancelled) error in this situation.

Examples

#[derive(Message)]
#[rtype(result = "()")]
struct Die;

struct MyActor;

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

// To use actor with supervisor actor has to implement `Supervised` trait
impl actix::Supervised for MyActor {
    fn restarting(&mut self, ctx: &mut Context<MyActor>) {
        println!("restarting");
    }
}

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

    fn handle(&mut self, _: Die, ctx: &mut Context<MyActor>) {
        ctx.stop();
    }
}

fn main() {
    let mut sys = System::new();

    let addr = sys.block_on(async { actix::Supervisor::start(|_| MyActor) });
    addr.do_send(Die);

    sys.run();
}

Implementations

impl<A> Supervisor<A>

where A: Supervised + Actor<Context = Context<A>>,

pub fn start<F>(f: F) -> Addr<A>

where F: FnOnce(&mut A::Context) -> A + 'static, A: Actor<Context = Context<A>>,

Start new supervised actor in current tokio runtime.

Type of returned address depends on variable type. For example to get Addr<Syn, _> of newly created actor, use explicitly Addr<Syn, _> type as type of a variable.

struct MyActor;

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

// Get `Addr` of a MyActor actor
let addr = actix::Supervisor::start(|_| MyActor);

pub fn start_in_arbiter<F>(sys: &ArbiterHandle, f: F) -> Addr<A>

where A: Actor<Context = Context<A>>, F: FnOnce(&mut Context<A>) -> A + Send + 'static,

Start new supervised actor in arbiter’s thread.

Trait Implementations

impl<A> Debug for Supervisor<A>

where A: Supervised + Actor<Context = Context<A>> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'__pin, A> Unpin for Supervisor<A>

where __Origin<'__pin, A>: Unpin, A: Supervised + Actor<Context = Context<A>>,