Struct KeyedWorkerPool 

pub struct KeyedWorkerPool<A: Address, K, J, R, C, S>
where
    K: Eq,
    C: Behavior<Addr = A, Msg = PoolAssignment<J>, Ph = Never>,
    S: AffinitySelector<K, A::Nonce>,
{ /* private fields */ }

A worker pool whose admitted keys remain bound to stable worker slots.

The selector chooses a stable proxy nonce only when a key is first admitted. Replacement incarnations remain behind that proxy, so they do not alter affinity. KeyedPoolMessage::Rebalance is the sole transition that changes an established binding, and jobs accepted before it retain their original target.

Keys must have a concrete equality relation; a key type without Eq cannot form an affinity table:

use behavior::{Actions, Delivery, KeyedWorkerPool, MailAddr, Never, NoBirths};
struct NonKey(f64);
struct Worker;
#[behavior::behavior(
    addr = MailAddr,
    message = behavior::PoolAssignment<u8>,
    sends = Vec<Delivery<MailAddr, Never>>,
    births = NoBirths,
    error = Never,
)]
impl Worker {
    fn init(&mut self) -> behavior::Acted<MailAddr, Never, Vec<Delivery<MailAddr, Never>>, NoBirths, Never> {
        Ok(Actions::cont())
    }
    fn receive(&mut self, _: MailAddr, _: behavior::PoolAssignment<u8>) -> behavior::Acted<MailAddr, Never, Vec<Delivery<MailAddr, Never>>, NoBirths, Never> {
        Ok(Actions::cont())
    }
}
let _: Option<KeyedWorkerPool<MailAddr, NonKey, u8, (), Worker, fn(&NonKey) -> u64>> = None;

Implementations

impl<A, K, J, R, C, S> KeyedWorkerPool<A, K, J, R, C, S>

where A: Address, K: Eq, C: Behavior<Addr = A, Msg = PoolAssignment<J>, Ph = Never>, S: AffinitySelector<K, A::Nonce>,

pub fn new( nonces: fn(usize) -> A::Nonce, count: usize, build: fn(usize) -> C, backlog_capacity: usize, interruption: InterruptionPolicy, restart_policy: RestartPolicy, max_restarts: u32, restart_window: Duration, selector: S, ) -> Result<Self, PoolConfigError<A::Nonce>>

Construct a key-persistent pool over the same fixed supervised slots as WorkerPool. The selector is pure and is consulted once per previously unseen key. It chooses behavior policy; runtime route resolution remains outside this type.

Errors

Returns PoolConfigError::NoWorkers for an empty topology or PoolConfigError::DuplicateWorker for a repeated stable nonce.

pub fn affinity(&self, key: &K) -> Option<A::Nonce>

Return the stable slot currently bound to key.

pub fn backlog_len(&self) -> usize

pub fn worker_phase(&self, worker: A::Nonce) -> Option<WorkerPhase>

Trait Implementations

impl<A, K, J, R, C, S> Behavior for KeyedWorkerPool<A, K, J, R, C, S>

where A: Address, A::Nonce: From<u64>, K: Eq, J: Clone, C: Behavior<Addr = A, Msg = PoolAssignment<J>, Ph = Never>, S: AffinitySelector<K, A::Nonce>,

type Addr = A

type Msg = KeyedPoolMessage<A, K, J, R>

type Event = SupervisionEvent<User<A, KeyedPoolMessage<A, K, J, R>>>

type Sends = SupervisorSends<A, PoolBehaviorSends<A, J, R, C>, C>

type Ph = Never

type Error = PoolError<<A as Address>::Nonce>

type Birth = Births<Proxy<C>>

fn init(&mut self) -> BehaviorActed<Self>

Produce initialization actions before the first event is accepted.

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

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

fn receive( &mut self, from: Self::Addr, message: Self::Msg, ) -> BehaviorActed<Self>

where Self: Sized,

Fold one user communication through the composed protocol.

fn on<Input>(&mut self, input: Input) -> BehaviorActed<Self>

where Self: Sized, Self::Event: EventInput<Input>,

Inject one supported semantic input and fold it through this behavior.