Struct bastion::supervisor::SupervisorRef [−][src]
A "reference" to a Supervisor
, allowing to
communicate with it.
Implementations
impl SupervisorRef
[src]
pub fn id(&self) -> &BastionId
[src]
Returns the identifier of the supervisor this SupervisorRef
is referencing.
Note that the supervisor's identifier is reset when it is restarted.
Example
let supervisor_ref = Bastion::supervisor(|sp| { // ... }).expect("Couldn't create the supervisor."); let supervisor_id: &BastionId = supervisor_ref.id();
pub fn supervisor<S>(&self, init: S) -> Result<Self, ()> where
S: FnOnce(Supervisor) -> Supervisor,
[src]
S: FnOnce(Supervisor) -> Supervisor,
Creates a new Supervisor
, passes it through the specified
init
closure and then sends it to the supervisor this
SupervisorRef
is referencing to supervise it.
This method returns a SupervisorRef
referencing the newly
created supervisor if it succeeded, or Err(())
otherwise.
Arguments
init
- The closure taking the newSupervisor
as an argument and returning it once configured.
Example
let sp_ref: SupervisorRef = parent_ref.supervisor(|sp| { // Configure the supervisor... sp.with_strategy(SupervisionStrategy::OneForOne) // ...and return it. }).expect("Couldn't create the supervisor.");
pub fn children<C>(&self, init: C) -> Result<ChildrenRef, ()> where
C: FnOnce(Children) -> Children,
[src]
C: FnOnce(Children) -> Children,
Creates a new Children
, passes it through the specified
init
closure and then sends it to the supervisor this
SupervisorRef
is referencing to supervise it.
This methods returns a ChildrenRef
referencing the newly
created children group if it succeeded, or Err(())
otherwise.
Arguments
init
- The closure taking the newChildren
as an argument and returning it once configured.
Example
let children_ref: ChildrenRef = sp_ref.children(|children| { children.with_exec(|ctx: BastionContext| { async move { // Send and receive messages... let opt_msg: Option<SignedMessage> = ctx.try_recv().await; // ...and return `Ok(())` or `Err(())` when you are done... Ok(()) // Note that if `Err(())` was returned, the supervisor would // restart the children group. } }) }).expect("Couldn't create the children group.");
pub fn strategy(&self, strategy: SupervisionStrategy) -> Result<(), ()>
[src]
Sends to the supervisor this SupervisorRef
is
referencing the strategy that it should start
using when one of its supervised children groups or
supervisors dies (in the case of a children group,
it could be because one of its elements panicked or
returned an error).
The default strategy Supervisor
is
SupervisionStrategy::OneForOne
.
This method returns ()
if it succeeded, or Err(())
otherwise.
Arguments
strategy
- The strategy to use:SupervisionStrategy::OneForOne
would only restart the supervised children groups or supervisors that fault.SupervisionStrategy::OneForAll
would restart all the supervised children groups or supervisors (even those which were stopped) when one of them faults, respecting the order in which they were added.SupervisionStrategy::RestForOne
would restart the supervised children groups or supervisors that fault along with all the other supervised children groups or supervisors that were added after them (even the stopped ones), respecting the order in which they were added.
Example
// Note that "one-for-one" is the default strategy. sp_ref.strategy(SupervisionStrategy::OneForOne);
pub fn broadcast<M: Message>(&self, msg: M) -> Result<(), M>
[src]
Sends a message to the supervisor this SupervisorRef
is referencing which will then send it to all of its
supervised children groups and supervisors.
This method returns ()
if it succeeded, or Err(msg)
otherwise.
Arguments
msg
- The message to send.
Example
let msg = "A message containing data."; sp_ref.broadcast(msg).expect("Couldn't send the message."); // And then in every future of the elements of the children // groups that are supervised by this supervisor or one of // its supervised supervisors (etc.)... msg! { ctx.recv().await?, ref msg: &'static str => { assert_eq!(msg, &"A message containing data."); }; // We are only broadcasting a `&'static str` in this // example, so we know that this won't happen... _: _ => (); }
pub fn stop(&self) -> Result<(), ()>
[src]
Sends a message to the supervisor this SupervisorRef
is referencing to tell it to stop every running children
groups and supervisors that it is supervising.
This method returns ()
if it succeeded, or Err(())
otherwise.
Example
sp_ref.stop().expect("Couldn't send the message.");
pub fn kill(&self) -> Result<(), ()>
[src]
Sends a message to the supervisor this SupervisorRef
is referencing to tell it to kill every running children
groups and supervisors that it is supervising.
This method returns ()
if it succeeded, or Err(())
otherwise.
Example
sp_ref.kill().expect("Couldn't send the message.");
Trait Implementations
impl Clone for SupervisorRef
[src]
fn clone(&self) -> SupervisorRef
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for SupervisorRef
[src]
impl Eq for SupervisorRef
[src]
impl PartialEq<SupervisorRef> for SupervisorRef
[src]
Auto Trait Implementations
impl !RefUnwindSafe for SupervisorRef
[src]
impl Send for SupervisorRef
[src]
impl Sync for SupervisorRef
[src]
impl Unpin for SupervisorRef
[src]
impl !UnwindSafe for SupervisorRef
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> AsAny for T where
T: Any,
[src]
T: Any,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Message for T where
T: Any + Send + Sync + Debug,
[src]
T: Any + Send + Sync + Debug,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> State for T where
T: Send + Sync + 'static,
[src]
T: Send + Sync + 'static,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
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.
pub 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.
pub 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>,