[][src]Struct actix_web::actix::Supervisor

pub struct Supervisor<A> where
    A: Supervised<Context = Context<A>> + Actor
{ /* 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)]
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() {
    System::run(|| {
        let addr = actix::Supervisor::start(|_| MyActor);

        addr.do_send(Die);
    });
}

Methods

impl<A> Supervisor<A> where
    A: Supervised<Context = Context<A>> + Actor
[src]

pub fn start<F>(f: F) -> Addr<A> where
    A: Actor<Context = Context<A>>,
    F: FnOnce(&mut <A as Actor>::Context) -> A + 'static, 
[src]

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: &Addr<Arbiter>, f: F) -> Addr<A> where
    A: Actor<Context = Context<A>>,
    F: FnOnce(&mut Context<A>) -> A + Send + 'static, 
[src]

Start new supervised actor in arbiter's thread.

Trait Implementations

impl<A> Debug for Supervisor<A> where
    A: Debug + Supervised<Context = Context<A>> + Actor
[src]

Auto Trait Implementations

impl<A> !Send for Supervisor<A>

impl<A> !Sync for Supervisor<A>

Blanket Implementations

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> From for T[src]

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<F> IntoFuture for F where
    F: Future
[src]

type Future = F

The future that this type can be converted into.

type Item = <F as Future>::Item

The item that the future may resolve with.

type Error = <F as Future>::Error

The error that the future may resolve with.

impl<T> Erased for T

impl<T> FutureExt for T where
    T: Future + ?Sized
[src]

fn timeout(self, timeout: Duration) -> Timeout<Self>[src]

Creates a new future which allows self until timeout. Read more

impl<F, A> WrapFuture for F where
    A: Actor,
    F: Future
[src]

type Future = FutureWrap<F, A>

The future that this type can be converted into.

type Item = <F as Future>::Item

The item that the future may resolve with.

type Error = <F as Future>::Error

The error that the future may resolve with.