Struct AllocationStatus 

pub struct AllocationStatus {
    pub phase: AllocationPhase,
    pub phase_since: Option<DateTime<Utc>>,
    pub bound_pool: Option<AllocationRef>,
    pub assigned_process: Option<AllocationRef>,
    pub allocated_at: Option<DateTime<Utc>>,
    pub expires_at: Option<DateTime<Utc>>,
    pub message: Option<String>,
    pub conditions: Vec<AllocationCondition>,
}

EphemeralAllocation.status — observed allocation state.

Fields

phase: AllocationPhase

Current lifecycle phase.

phase_since: Option<DateTime<Utc>>

When the phase last changed.

bound_pool: Option<AllocationRef>

Pool that owns the matched member. Set as soon as routing resolves; not cleared on release (audit trail).

assigned_process: Option<AllocationRef>

The Process backing this allocation, if Bound.

allocated_at: Option<DateTime<Utc>>

When the allocation was matched to a Process.

expires_at: Option<DateTime<Utc>>

Wall-clock expiry derived from spec.ttl + allocated_at. The pool reconciler force-returns the member at this point.

message: Option<String>

Operator-visible message.

conditions: Vec<AllocationCondition>

Standard Conditions.

The empty case is skipped at serialization so a merge-patch body built from a caller-supplied AllocationStatus whose conditions slot has not been touched does NOT emit "conditions": [] on the wire — under RFC-7396 JSON Merge Patch (the shape Patch::Merge sends) an empty array REPLACES the persisted list rather than merges into it, so a controller round-trip that reused a scratch AllocationStatus as a patch body would silently clobber whatever conditions the prior status carried. Peer to phase_since / bound_pool / assigned_process / allocated_at / expires_at above, each already skip-serialized on its Default-equivalent variant.

Implementations

impl AllocationStatus

pub fn transition( phase: AllocationPhase, message: impl Into<String>, now: DateTime<Utc>, ) -> Self

Substrate composer for a phase-transition AllocationStatus seed: stamps the THREE always-present slots (phase + phase_since = Some(now) + message = Some(<supplied>)) and defaults every other slot (bound_pool / assigned_process / allocated_at / expires_at = None, conditions = vec![]). Caller-branches attach the extra slots via struct-update syntax onto the seed.

Pre-lift the 4-slot phase-transition seed

json!({
    "status": {
        "phase": <AllocationPhase-variant>,
        "phaseSince": Utc::now(),
        "message": "<transition-reason>",
        …optional caller-attached slots…
    }
})

was hand-authored at FOUR sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold in tatara-pool-reconciler::controller_allocation::reconcile_inner, each restating the SAME phase + phase_since + message invariant triplet on a different AllocationPhase variant:

• AllocationDecision::NoMatchingPool — the “no Pool selector matched this Requestor” fallthrough (AllocationPhase::NoMatchingPool).
• AllocationDecision::Wait — the “pool matched; no Free member available” queued path (AllocationPhase::Queued) with a bound_pool addition.
• AllocationDecision::Bind — the “bound to pool member” allocation path (AllocationPhase::Bound) with bound_pool + assigned_process + allocated_at + expires_at additions.
• AllocationDecision::Release — the “released; pool reconciler will return the member” release path (AllocationPhase::Released) with bound_pool + assigned_process additions.

All four hand-authored the SAME phaseSince: Utc::now() stamp alongside the phase transition, and all four spelled the invariant triplet as bare JSON keys inside a json!({...}) literal — a fragile shape where any drift in the underlying AllocationStatus field naming (a rename from phaseSince to phase_since at the serde surface, a promotion of message to a structured envelope) silently stops the JSON keys from mapping to the typed struct’s fields and the K8s API server merges an ill-shaped patch. Post-lift the four callers build a typed AllocationStatus via AllocationStatus::transition, attach any branch-specific slots via struct-update syntax, and wrap the result in json!({ "status": s }) — the serde rename_all = "camelCase" derive on AllocationStatus owns the wire-shape composition, so a field rename lands at ONE site (the derive) and every emit site inherits the upgrade mechanically.

Cross-CRD peer to crate::pool::PoolStatus::observed on the same <CRD>Status substrate-composer axis — both primitives stamp phase_since = Some(now) from a caller-supplied now timestamp so the composer stays clock-injectable rather than implicitly reading wall time, and both close every optional slot with its Default-equivalent variant so a future slot addition on either status shape plugs into the composer at ONE site and every downstream emit site inherits the new slot mechanically.

Cross-CRD peer to the tatara-reconciler::patch::phase_status_msg primitive on the (CRD × phase-transition-with-message) axis — both primitives own the three-slot phase + phase_since + message invariant on their respective CRDs’ status subresource, and both accept impl Into<String> for the message so the callsite carries &'static str literal reasons and format!(...)-owned strings without widening the signature.

Theory anchor: THEORY.md §VI.1 (generation over composition — the 4-slot phase-transition status-seed incantation recurred at four 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 three always-present slots + the Default-defaulted rest + byte-identical parity with the pre-lift json!({...}) triplet through serde round-trip, so a regression that drifted any surface at tests::allocation_status_transition_* rather than as silent operator-visible skew between the four allocation-decision patch sites).

pub fn bound_transition( phase: AllocationPhase, message: impl Into<String>, now: DateTime<Utc>, bound_pool: AllocationRef, assigned_process: AllocationRef, ) -> Self

Substrate composer for a phase-transition AllocationStatus seed whose bound_pool + assigned_process axis-pair is stamped alongside the base Self::transition triplet (phase + phase_since = Some(now) + message = Some(<supplied>)). Every other slot lands at its Default-equivalent variant so a caller-branch that attaches an optional slot via struct-update syntax (a Bind arm’s allocated_at / expires_at addenda, say) does not silently inherit a pre-populated non-None value.

Pre-lift the bound_pool: Some(pool) + assigned_process: Some(AllocationRef::new(name, ns)) pair rode struct-update syntax onto Self::transition at TWO sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication threshold in tatara-pool-reconciler::controller_allocation::reconcile_inner — the AllocationDecision::Bind arm (AllocationPhase::Bound with two extra allocated_at / expires_at addenda) and the AllocationDecision::Release arm (AllocationPhase::Released with no addenda). Both restated the SAME pair-of-Some-slot invariant against the SAME struct-update seed and funneled the resulting body through the SAME patch_status call on Api<EphemeralAllocation>. Post-lift both callers reach the pair through ONE substrate composer; a future normalization on the bound-set axis (a symmetry gate that the assigned_process’s namespace matches the bound_pool’s namespace, a canonicalization that closes the pair against a stale audit record, a backwards-compatibility rename of either slot at the serde surface) lands at ONE substrate site rather than at each callsite in the two-arm allocation reconciler.

Composes atop Self::transition so any future evolution to the base three-slot invariant triplet (a phase_since rename, a message promotion to a structured envelope, a fourth always-stamped diagnostic slot) reaches this composer through ONE substrate site and both consumers inherit the upgrade mechanically. Sibling composition discipline to crate::pool::PoolStatus::observed’s state_count_fanout + Utc::now() fold — the compound composer names its axis + calls the substrate primitive on the invariant it wraps rather than restating the wrapped shape inline.

Theory anchor: THEORY.md §VI.1 (generation over composition — the bound_pool + assigned_process pair 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 pair + the composed base triplet + byte-identical parity with the pre-lift struct-update shape through serde round-trip, so a regression that drifted any surface at tests::allocation_status_bound_transition_* rather than as silent operator-visible skew between the two Bind / Release patch sites).

Trait Implementations

impl Clone for AllocationStatus

fn clone(&self) -> AllocationStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AllocationStatus

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

Formats the value using the given formatter.

impl Default for AllocationStatus

fn default() -> AllocationStatus

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AllocationStatus

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for AllocationStatus

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 AllocationStatus

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

where __S: Serializer,

Serialize this value into the given Serde serializer.