[−][src]Struct actix::Supervisor
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.
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 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("example"); let addr = actix::Supervisor::start(|_| MyActor); addr.do_send(Die); sys.run(); }
Implementations
impl<A> Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
[src]
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>>,
[src]
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: &Arbiter, f: F) -> Addr<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.
Trait Implementations
impl<A: Debug> Debug for Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
[src]
A: Supervised + Actor<Context = Context<A>>,
impl<A> PinnedDrop for Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
[src]
A: Supervised + Actor<Context = Context<A>>,
impl<'pin, A> Unpin for Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
__Supervisor<'pin, A>: Unpin,
[src]
A: Supervised + Actor<Context = Context<A>>,
__Supervisor<'pin, A>: Unpin,
impl<A> UnsafeUnpin for Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
[src]
A: Supervised + Actor<Context = Context<A>>,
Auto Trait Implementations
impl<A> !RefUnwindSafe for Supervisor<A>
impl<A> !Send for Supervisor<A>
impl<A> !Sync for Supervisor<A>
impl<A> !UnwindSafe for Supervisor<A>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> From<T> for T
[src]
impl<T> FutureExt for T where
T: Future + ?Sized,
[src]
T: Future + ?Sized,
fn map<U, F>(self, f: F) -> Map<Self, F>ⓘ where
F: FnOnce(Self::Output) -> U,
[src]
F: FnOnce(Self::Output) -> U,
fn map_into<U>(self) -> MapInto<Self, U>ⓘ where
Self::Output: Into<U>,
[src]
Self::Output: Into<U>,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>ⓘ where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
[src]
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
fn left_future<B>(self) -> Either<Self, B>ⓘ where
B: Future<Output = Self::Output>,
[src]
B: Future<Output = Self::Output>,
fn right_future<A>(self) -> Either<A, Self>ⓘ where
A: Future<Output = Self::Output>,
[src]
A: Future<Output = Self::Output>,
fn into_stream(self) -> IntoStream<Self>
[src]
fn flatten(self) -> Flatten<Self>ⓘ where
Self::Output: Future,
[src]
Self::Output: Future,
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
[src]
Self::Output: Stream,
fn fuse(self) -> Fuse<Self>ⓘ
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘ where
F: FnOnce(&Self::Output),
[src]
F: FnOnce(&Self::Output),
fn catch_unwind(self) -> CatchUnwind<Self>ⓘNotable traits for CatchUnwind<Fut>
impl<Fut> Future for CatchUnwind<Fut> where
Fut: Future + UnwindSafe, type Output = Result<<Fut as Future>::Output, Box<dyn Any + 'static + Send>>;
where
Self: UnwindSafe,
[src]
Notable traits for CatchUnwind<Fut>
impl<Fut> Future for CatchUnwind<Fut> where
Fut: Future + UnwindSafe, type Output = Result<<Fut as Future>::Output, Box<dyn Any + 'static + Send>>;
Self: UnwindSafe,
fn shared(self) -> Shared<Self>ⓘ where
Self::Output: Clone,
[src]
Self::Output: Clone,
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)
[src]
fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send>>ⓘ where
Self: Send + 'a,
[src]
Self: Send + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>ⓘ where
Self: 'a,
[src]
Self: 'a,
fn unit_error(self) -> UnitError<Self>ⓘ
[src]
fn never_error(self) -> NeverError<Self>ⓘNotable traits for NeverError<Fut>
impl<Fut> Future for NeverError<Fut> where
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
[src]
Notable traits for NeverError<Fut>
impl<Fut> Future for NeverError<Fut> where
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
[src]
Self: Unpin,
fn now_or_never(self) -> Option<Self::Output>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,
fn vzip(self) -> V
impl<F, A> WrapFuture<A> for F where
A: Actor,
F: Future,
[src]
A: Actor,
F: Future,
type Future = FutureWrap<F, A>
The future that this type can be converted into.
type Output = <F as Future>::Output
The item that the future may resolve with.