Struct actix::Supervisor
source · [−]pub struct Supervisor<A> where
A: Supervised,
A: Actor<Context = Context<A>>, { /* private fields */ }
Expand description
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
sourceimpl<A> Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
impl<A> Supervisor<A> where
A: Supervised + Actor<Context = Context<A>>,
sourcepub fn start<F>(f: F) -> Addr<A> where
F: FnOnce(&mut A::Context) -> A + 'static,
A: 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);
sourcepub 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,
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
sourceimpl<A: Debug> Debug for Supervisor<A> where
A: Supervised,
A: Actor<Context = Context<A>>,
impl<A: Debug> Debug for Supervisor<A> where
A: Supervised,
A: Actor<Context = Context<A>>,
impl<'__pin, A> Unpin for Supervisor<A> where
__Origin<'__pin, A>: Unpin,
A: Supervised,
A: 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
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> FutureExt for T where
T: Future + ?Sized,
impl<T> FutureExt for T where
T: Future + ?Sized,
sourcefn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,
fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Output) -> U,
Map this future’s output to a different type, returning a new future of the resulting type. Read more
sourcefn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>,
fn map_into<U>(self) -> MapInto<Self, U> where
Self::Output: Into<U>,
Map this future’s output to a different type, returning a new future of the resulting type. Read more
sourcefn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
Chain on a computation for when a future finished, passing the result of
the future to the provided closure f
. Read more
sourcefn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,
fn left_future<B>(self) -> Either<Self, B> where
B: Future<Output = Self::Output>,
Wrap this future in an Either
future, making it the left-hand variant
of that Either
. Read more
sourcefn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,
fn right_future<A>(self) -> Either<A, Self> where
A: Future<Output = Self::Output>,
Wrap this future in an Either
future, making it the right-hand variant
of that Either
. Read more
sourcefn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
Convert this future into a single element stream. Read more
sourcefn flatten(self) -> Flatten<Self> where
Self::Output: Future,
fn flatten(self) -> Flatten<Self> where
Self::Output: Future,
Flatten the execution of this future when the output of this future is itself another future. Read more
sourcefn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
fn flatten_stream(self) -> FlattenStream<Self> where
Self::Output: Stream,
Flatten the execution of this future when the successful result of this future is a stream. Read more
sourcefn fuse(self) -> Fuse<Self>
fn fuse(self) -> Fuse<Self>
Fuse a future such that poll
will never again be called once it has
completed. This method can be used to turn any Future
into a
FusedFuture
. Read more
sourcefn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnOnce(&Self::Output),
Do something with the output of a future before passing it on. Read more
sourcefn unit_error(self) -> UnitError<Self>
fn unit_error(self) -> UnitError<Self>
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = ()
>. Read more
sourcefn never_error(self) -> NeverError<Self>
fn never_error(self) -> NeverError<Self>
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = Never
>. Read more
sourcefn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
A convenience for calling Future::poll
on Unpin
future types.
sourcefn now_or_never(self) -> Option<Self::Output>
fn now_or_never(self) -> Option<Self::Output>
Evaluates and consumes the future, returning the resulting output if
the future is ready after the first call to Future::poll
. Read more
sourceimpl<F> IntoFuture for F where
F: Future,
impl<F> IntoFuture for F where
F: Future,
type Output = <F as Future>::Output
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
type Future = F
into_future
)Which kind of future are we turning this into?
sourcepub fn into_future(self) -> <F as IntoFuture>::Future
pub fn into_future(self) -> <F as IntoFuture>::Future
into_future
)Creates a future from a value.
sourceimpl<F, A> WrapFuture<A> for F where
F: Future,
A: Actor,
impl<F, A> WrapFuture<A> for F where
F: Future,
A: Actor,
type Future = FutureWrap<F, A>
type Future = FutureWrap<F, A>
The future that this type can be converted into.
sourcefn into_actor(self, _: &A) -> Self::Future
fn into_actor(self, _: &A) -> Self::Future
Convert normal future to a ActorFuture