Struct scrappy_actor::Supervisor

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

Actor supervisor

Supervisor manages incoming message for actor. In case of actor failure, supervisor creates new execution context and restarts actor lifecycle. Supervisor does not re-create actor, it just calls restarting() method.

Supervisor has same lifecycle as actor. In situation when all addresses to supervisor get dropped and actor does not execute anything, supervisor terminates.

Supervisor can not guarantee that actor successfully process incoming message. If actor fails during message processing, this message can not be recovered. Sender would receive Err(Cancelled) error in this situation.

Example

#[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 scrappy_actor::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() {
    System::run(|| {
        let addr = scrappy_actor::Supervisor::start(|_| MyActor);

        addr.do_send(Die);
    });
}

Methods

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 = scrappy_actor::Supervisor::start(|_| MyActor);

pub fn start_in_arbiter<F>(sys: &Arbiter, 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> Debug for Supervisor<A> where
    A: Supervised + Actor<Context = Context<A>>, 

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

Formats the value using the given formatter.