Struct actix::Supervisor
[−]
[src]
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
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)] 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 sys = System::new("test"); let addr: Addr<Unsync, _> = actix::Supervisor::start(|_| MyActor); addr.do_send(Die); sys.run(); }
Methods
impl<A> Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
[src]
A: Supervised + Actor<Context = Context<A>>,
pub fn start<Addr, F>(f: F) -> Addr where
F: FnOnce(&mut A::Context) -> A + 'static,
A: Actor<Context = Context<A>> + ActorAddress<A, Addr>,
[src]
F: FnOnce(&mut A::Context) -> A + 'static,
A: Actor<Context = Context<A>> + ActorAddress<A, Addr>,
Start new supervised actor in current Arbiter.
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<Unsync, _>` of a MyActor actor let addr1: Addr<Unsync, _> = actix::Supervisor::start(|_| MyActor); // Get `Addr<Syn, _>` of a MyActor actor let addr2: Addr<Syn, _> = actix::Supervisor::start(|_| MyActor);
pub fn start_in<F>(addr: &Addr<Syn, Arbiter>, f: F) -> Addr<Syn, A> where
A: Actor<Context = Context<A>>,
F: FnOnce(&mut Context<A>) -> A + Send + 'static,
[src]
A: Actor<Context = Context<A>>,
F: FnOnce(&mut Context<A>) -> A + Send + 'static,
Start new supervised actor in arbiter's thread.