Struct ShutdownCoordinator 

pub struct ShutdownCoordinator<B: Behavior, C: Behavior, Occurrence>
where
    C::Protocol: Protocol<Addr = BehaviorAddr<B>>,
{ /* private fields */ }

Pure phased shutdown wrapper over an explicitly validated homogeneous child topology.

B is the wrapped coordinator behavior and C is the one concrete child protocol selected by every creation ID in the plan. Starting a phase emits one typed ShutdownChild<C, Occurrence> request per member in plan order. A phase advances only after every matching ChildStopped fact arrives. An acceptance rejection returns ShutdownCoordinatorError::ChildRejected without changing the phase. A stale or foreign child fact is returned intact as a typed error. This is Bombay lifecycle policy, not an actor-model allocation or ordering guarantee.

The fold introduces no panic conditions.

A child protocol without the shutdown input cannot form an executable coordinator:

struct Plain;
impl behavior::Protocol for Plain {
    type Addr = behavior::MailAddr;
    type Msg = ();
}
impl behavior::Behavior for Plain {
    type Protocol = Self;
    type Event = behavior::User<behavior::MailAddr, ()>;
    type Sends = Vec<behavior::Never>;
    type Ph = behavior::Never;
    type Error = behavior::Never;
    type Birth = behavior::NoBirths;
    fn transition(&mut self, _: behavior::ActiveTurn, _: Self::Event) -> behavior::BehaviorActed<Self> {
        Ok(behavior::Actions::cont())
    }
}

fn require_behavior<B: behavior::Behavior>(_: B) {}
let child = behavior::CreationSequence::new()
    .issue()
    .expect("the first child creation ID exists");
let plan = behavior_actors::ShutdownPlan::new([vec![child]]).unwrap();
require_behavior(behavior_actors::ShutdownCoordinator::<Plain, Plain, behavior::ChildHead>::new(Plain, plan));

Implementations

impl<B: Behavior, C: Behavior, Occurrence> ShutdownCoordinator<B, C, Occurrence>

where C::Protocol: Protocol<Addr = BehaviorAddr<B>>,

pub const fn new(inner: B, plan: ShutdownPlan<CreationId>) -> Self

pub const fn awaiting_plan(inner: B) -> Self

Start the wrapper before committed child creation can supply its plan.

InstallShutdownPlan later installs exactly one validated plan. A shutdown request received first is retained by the state machine and begins that plan immediately on installation.

pub fn state(&self) -> &ShutdownState<ShutdownPlan<CreationId>, CreationId>

Trait Implementations

impl<B, C, Occurrence, A, Ph, S, Br> Behavior for ShutdownCoordinator<B, C, Occurrence>

where A: Address, S: SendEffects + SendsFor<B::Event>, Br: BirthMode, B: Behavior<Ph = Ph, Sends = S, Birth = Br>, B::Protocol: Protocol<Addr = A>, C: Behavior, C::Protocol: Protocol<Addr = A>, C::Event: InjectEvent<ShutdownRequested, Here>,

type Protocol = <B as Behavior>::Protocol

Stable public communication identity owned by this actor template.

type Event = ShutdownCoordinatorEvent<<B as Behavior>::Event, ShutdownPlan<CreationId>>

type Sends = SendLayer<InterpreterRequests<ShutdownChild<C, Occurrence>>, S>

type Ph = Ph

type Error = ShutdownCoordinatorError<<B as Behavior>::Error, A, ShutdownPlan<CreationId>>

type Birth = Br

fn init(&mut self, _: InitializationTurn) -> BehaviorActed<Self>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> BehaviorActed<Self>

Fold exactly one event into explicit actions and the next behavior.

fn layer<L>(self, layer: L) -> <L as BehaviorLayer<Self>>::Output

where Self: Sized, L: BehaviorLayer<Self>,

Apply one statically dispatched construction layer.

impl<B, C, Occurrence> BehaviorBase for ShutdownCoordinator<B, C, Occurrence>

where B: Behavior + BehaviorBase, C: Behavior, C::Protocol: Protocol<Addr = BehaviorAddr<B>>,

type Base = <B as BehaviorBase>::Base

fn base(&self) -> &Self::Base

impl<B, C, Occurrence> StashStatus for ShutdownCoordinator<B, C, Occurrence>

where B: Behavior + StashStatus, C: Behavior, C::Protocol: Protocol<Addr = BehaviorAddr<B>>,

fn stashed_messages(&self) -> usize