Struct PoolMember 

pub struct PoolMember {
    pub process_name: String,
    pub state: MemberState,
    pub entered_state_at: DateTime<Utc>,
    pub allocation_ref: Option<AllocationRef>,
}

One pool slot’s state.

Fields

process_name: String

metadata.name of the backing Process.

state: MemberState

Pool member’s current slot state.

entered_state_at: DateTime<Utc>

When the member entered the current state.

allocation_ref: Option<AllocationRef>

If allocated: the AllocationRef holding this slot.

Implementations

impl PoolMember

pub fn state_count_fanout(members: &[Self]) -> (u32, u32, u32, u32)

Substrate primitive: single-pass closed-set fold over a [PoolMember] slice producing the (ready, allocated, spawning, returning) 4-tuple every PoolStatus seed stamps at its four counter slots. The Failed arm is a no-op (no PoolStatus counter tracks failed members — they surface via PoolPhase::Degraded instead), pinned by the closed-set match so a future variant that SHOULD count toward one of the four buckets triggers the compiler’s exhaustiveness check here rather than silently falling through.

Consumed by PoolStatus::observed. A caller that needs a single per-variant count outside the status-seed fanout should keep spelling members.iter().filter(...).count() rather than walking this 4-tuple — the fanout is shaped for the PoolStatus fill, not for arbitrary per-variant queries.

pub fn process_names_set(members: &[Self]) -> HashSet<String>

Substrate primitive: single-pass closed-set collection of the process_name axis over a [PoolMember] slice into an owned HashSet<String> — the O(1)-lookup shape every spawn-arm on the workspace builds pre-collision-check against a candidate crate::pool::PoolMember::process_name produced by [tatara-pool-reconciler::naming::member_process_name].

Pre-lift the 2-line members.iter().map(|m| m.process_name.clone()).collect() chain was hand-authored at TWO sites past the ★★ PRIME- DIRECTIVE ≥ 2 duplication threshold in tatara-pool-reconciler::controller_pool, both restating the SAME process_name projection through the SAME iter → map → collect shape and both feeding a .contains (&candidate) probe:

• reconcile_inner’s legacy allocation-driven PoolDecision::Spawn arm (desired == 0 path) — collision-set for member_process_name(&pool_name, &pool_uid, slot) per spawn slot.
• apply_convergence_actions — collision-set for the SAME composer inside the R11 desired-count ConvergenceAction::CreateMember loop.

Post-lift both consumers share ONE substrate owner; the composed HashSet<String> still feeds the same HashSet::<String>::contains(&candidate) probe at each callsite unchanged. A future normalization step on the occupied-name axis (case-fold before insertion, a per-cluster prefix strip, deduplication against a sibling stale-name registry, exclusion of Returning/Failed members that no longer own their slot) lands at ONE substrate method rather than being restated at each callsite.

Sibling to Self::state_count_fanout on the (collection shape × slice-owned fold) axis: both primitives fold a [PoolMember] slice into one caller-shaped aggregate in a single pass, both are #[must_use], both take the slice by reference so no caller has to reshape its Vec<PoolMember> or Vec<PoolMember> slice upstream.

Theory anchor: THEORY.md §VI.1 (generation over composition — the HashSet<String> collision-set shape recurred at TWO hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger, and is lifted to ONE owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — the pins bind the axis (process_name), the aggregate shape (HashSet<String>), the empty-slice corner, and the duplicate-name deduplication semantics HashSet provides implicitly, so a regression at any of those surfaces at tests::process_names_set_* rather than as silent occupied- slot skew at either spawn arm).

pub fn unallocated( process_name: impl Into<String>, state: MemberState, entered_state_at: DateTime<Utc>, ) -> Self

Substrate composer for the unallocated PoolMember seed: the 4-slot { process_name, state, entered_state_at, allocation_ref: None } fixture literal every non-Allocated-role callsite stamped by hand pre-lift.

Pre-lift the 4-slot struct literal PoolMember { process_name, state, entered_state_at, allocation_ref: None } was hand-authored at FIVE workspace-wide sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold across TWO crates:

• tatara-pool-reconciler::controller_pool::reconcile_inner — the production per-owned-Process seed built inside the for p in all_processes.items walk; entered_state_at rides in from crate::prelude::Process::observed_phase_since with the Utc::now fallback at the callsite.
• tatara-pool-reconciler::pool_decide::tests::member — test helper for the pool decision suite; entered_state_at rides in from crate::time::seconds_ago.
• tatara-pool-reconciler::allocation_decide::tests::member — test helper for the allocation decision suite; entered_state_at rides in from Utc::now.
• tatara-process::pool::tests::member — test helper for the fanout / status suite; entered_state_at rides in from the epoch anchor DateTime::<Utc>::from_timestamp(0, 0).
• tatara-process::pool::tests::named_member — test helper for the process_names_set suite; same epoch anchor.

Every one of those FIVE sites pinned allocation_ref: None verbatim — no PoolMember construction site in the workspace pairs allocation_ref: Some(<ref>) with a hand-authored 4-slot struct literal, so this composer’s None slot is safe by construction (the compiler exhaustiveness check on the struct’s four fields catches a future 5th slot addition here rather than at any of the callsites).

Post-lift every consumer writes PoolMember::unallocated(<name>, <state>, <anchor>) and shares ONE substrate owner; a future promotion of the unallocated shape (a per-cluster clock-skew guard on the entered_state_at anchor, a canonical rename of the None-slot to a typed Unallocated marker, a lint-friendly closed-set restriction to the four MemberState variants that legitimately carry no allocation_ref) lands at ONE substrate site and every downstream consumer inherits the upgrade mechanically.

impl Into<String> accepts both &str literals (every test helper site) and owned String produced by crate::prelude::Process::owned_name_or_empty (the production controller-pool site) without widening the signature.

Sibling to AllocationRef::new on the substrate-composer axis: both take impl Into<String>-gated identity slots and return their owner-type by value; AllocationRef::new owns the (name, namespace) pair, this composer owns the four-slot unallocated-member seed.

Theory anchor: THEORY.md §VI.1 (generation over composition — the 4-slot unallocated-PoolMember seed recurred at FIVE hand- authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger, and is lifted to ONE owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — the pins bind the four-slot fill AND the allocation_ref: None invariant AND the caller-clock-injectability of entered_state_at, so a regression that drifts any surface fails at tests::pool_member_unallocated_* rather than as silent operator-facing skew between the production controller-pool seed and the three test-suite helpers on the SAME PoolMember shape).

Trait Implementations

impl Clone for PoolMember

fn clone(&self) -> PoolMember

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PoolMember

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PoolMember

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for PoolMember

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Serialize for PoolMember

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.