Struct EphemeralAllocation 

pub struct EphemeralAllocation {
    pub metadata: ObjectMeta,
    pub spec: AllocationSpec,
    pub status: Option<AllocationStatus>,
}

Auto-generated derived type for AllocationSpec via CustomResource

Fields

metadata: ObjectMeta

spec: AllocationSpec

status: Option<AllocationStatus>

Implementations

impl EphemeralAllocation

pub fn new(name: &str, spec: AllocationSpec) -> Self

Spec based constructor for derived custom resource

impl EphemeralAllocation

pub fn observed_phase(&self) -> Option<AllocationPhase>

The copy-form status-projection primitive on the phase axis: returns the AllocationPhase the pool reconciler currently persists at status.phase, wrapped in an Option so the missing-status corner collapses to None — the ONE-liner collapse of the paired self.status.as_ref().map(|s| s.phase) incantation the pool reconciler’s AllocationConvergenceCtx:: observe restated by hand pre-lift.

Cross-CRD peer to crate::prelude::Process::observed_phase on the (CRD × phase-slot × observed-status) axis pair — both primitives walk the identical .status.as_ref().map(|s| s. phase) shape, differing only in the Phase type projected (AllocationPhase vs crate::phase::ProcessPhase). The substrate now owns the borrow-form .status.as_ref().map(|s| s.phase) chain axis-uniformly across the two Phase-having CRDs so a future normalization (a generation-filter that returns None for a phase stamped with a stale metadata.generation, a staleness gate that drops a phase whose observing phase_since predates a reconcile deadline, a canonicalization pass that maps a phase outside the CRD’s closed set to None) lands at ONE substrate method per CRD rather than being restated at every observer.

pub fn observed_phase_or_pending(&self) -> AllocationPhase

The copy-form status-projection primitive on the phase axis with the AllocationPhase::Pending sink applied — the ONE-liner collapse of the paired self.observed_phase(). unwrap_or(AllocationPhase::Pending) incantation the pool reconciler’s AllocationConvergenceCtx::observe restated by hand pre-lift as a 5-line .status.as_ref().map(|s| s.phase). unwrap_or(AllocationPhase::Pending) chain.

Pre-lift the chain sat at [tatara-pool-reconciler:: allocation_decide::AllocationConvergenceCtx::observe]’s phase seed. Cross-CRD peer to [crate::prelude::Process:: observed_phase_or_pending] on the (CRD × phase-slot × sink) axis pair — both primitives close the missing-status corner with each CRD’s respective Default-equivalent Pending variant, and both compose on top of their peer Self::observed_phase / [crate::prelude::Process:: observed_phase] borrow-form projections so a future normalization at the underlying observed_phase primitive reaches both the raw-Option accessor and the Pending- sinked composer through the SAME upstream body.

The AllocationPhase::Pending sink is load-bearing as the “not yet observed” default — the pool reconciler’s typed AllocationPhase::needs_pool_routing predicate returns true for Pending, so a freshly-admitted Allocation whose pool reconciler has not yet stamped a .status slot reads as Pending and immediately enters the routing ladder, matching the pre-lift AllocationPhase::Pending fallback semantics verbatim.

Theory anchor: THEORY.md §VI.1 (generation over composition — the two-link .status.as_ref().map(|s| s.phase).unwrap_or (AllocationPhase::Pending) chain recurred at both the crate::prelude::Process site (already lifted onto crate::prelude::Process::observed_phase_or_pending) AND the EphemeralAllocation site by hand, i.e. the SHAPE itself recurs past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger, and is lifted to ONE owner per CRD here). THEORY.md §II.1 invariant 5 (composition preserves proofs — the pins bind the missing-status sink to Pending + populated- status pass-through + every AllocationPhase variant round-trip + byte-identical parity with the pre-lift two-link chain + cross-CRD peer coherence with crate::prelude::Process::observed_phase_or_pending, so a regression that drifted any surface at tests::observed_phase_* rather than as silent operator- facing skew between the allocation observer’s routing seed and the Process observer’s dispatch seed).

pub fn observed_bound_pool(&self) -> Option<&AllocationRef>

The borrow-form status-projection primitive on the bound-pool axis: returns the AllocationRef the pool reconciler currently persists at status.bound_pool (name + namespace of the pool that owns the matched member), with the missing-status corner AND the empty-slot corner BOTH collapsed to None — the ONE-liner collapse of the paired self.status.as_ref().and_then(|s| s.bound_pool.<clone|as_ref>()) incantation the pool reconciler’s AllocationConvergenceCtx:: observe restated by hand pre-lift.

Cross-CRD peer to crate::prelude::Process::observed_identity on the (CRD × structured-record-slot × borrow-form) axis pair — both primitives walk the identical .status.as_ref() .and_then(|s| s.<slot>.as_ref()) shape, differing only in the record projected (AllocationRef here, [crate::identity:: Identity] on Process). The substrate now owns the borrow-form .status.as_ref().and_then(|s| s.<slot>.as_ref()) chain on the second structured-record slot across the two status-having CRDs, so a future normalization step (a generation-filter that returns None for a bound-pool reference stamped with a stale metadata.generation, a canonicalization pass that rejects a malformed (name, namespace) pair, a cross-cluster reference-rewrite gate) lands at ONE substrate method per CRD rather than being restated at every observer.

Return-form axis: Option<&AllocationRef> mirrors the borrow-first discipline of [crate::prelude::Process:: observed_identity]. The lone pre-lift consumer ([tatara-pool-reconciler::allocation_decide:: AllocationConvergenceCtx::observe]’s bound_pool seed) spelled the projection as .and_then(|s| s.bound_pool.clone()) — an eager clone allocated inside every reconcile pass even when the downstream branch (the Release-composition arm) needed only the borrow for the .as_ref() re-projection two lines later. Post-lift the consumer reaches the primitive borrow-first (alloc.observed_bound_pool().cloned()) and the empty-borrow corner clones nothing (Option::cloned on None is None); the composition point where the owned AllocationRef fallback is required (the AllocationConvergenceCtx snapshot slot, still Option<AllocationRef>-typed for serde stability) is the ONLY site that materializes an owned copy.

The missing-status corner AND the populated-status-with- bound_pool=None corner BOTH collapse to None so .is_some() / if let Some(_) / .cloned() behave identically on an EphemeralAllocation whose status field is None and on one whose status carries an unpopulated bound_pool slot — matching what the pre-lift .and_then(...) chain produced. Consumers that need to tell those corners apart reach for Self::status directly, exactly as the existing peer accessors Self::observed_phase + Self::observed_phase_or_pending admit.

Theory anchor: THEORY.md §VI.1 (generation over composition — the .status.as_ref().and_then(|s| s.<structured-record> .<clone|as_ref>()) shape recurred as ONE hand-authored .and_then(|s| s.bound_pool.clone()) chain in [tatara-pool-reconciler::allocation_decide:: AllocationConvergenceCtx::observe] AND as the peer crate::prelude::Process::observed_identity primitive already owned on the Process CRD’s status.identity slot, past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger at substrate-shape level. THEORY.md §II.1 invariant 5 (composition preserves proofs — the pins bind the missing- status corner + the empty-bound_pool-slot corner + the borrow-form &AllocationRef lifetime + the zero-copy projection contract + byte-identical parity with the pre-lift .and_then(|s| s.bound_pool.clone()) chain across the full corner set + cross-CRD peer coherence with crate::prelude::Process::observed_identity, so a regression that drifted any surface at tests::observed_bound_pool_* rather than as silent operator- facing skew between the allocation observer’s Release- composition seed and the Process observer’s FORK-time identity seed on the SAME reconcile tick).

pub fn observed_expires_at(&self) -> Option<DateTime<Utc>>

The copy-form status-projection primitive on the TTL-expiry axis: returns the wall-clock deadline the pool reconciler currently persists at status.expires_at (derived from spec.ttl + allocated_at at Bind time), wrapped in an Option so both the missing-status corner AND the populated-status-with-expires_at =None corner collapse to None — the ONE-liner collapse of the paired self.status.as_ref().and_then(|s| s.expires_at) incantation the pool reconciler’s AllocationConvergenceCtx:: observe restated by hand pre-lift.

Same-CRD peer to Self::observed_phase on the (CRD × copy-form × status-slot) axis pair — both primitives walk the identical .status.as_ref().<map|and_then>(|s| s.<Copy-field>) shape, differing only in the record projected (DateTime<Utc> here, AllocationPhase on the phase axis) and in the outer combinator (and_then here because the persisted field is itself an Option<DateTime<Utc>>, map there because the persisted phase is bare). The substrate now owns the copy-form .status.as_ref().<map|and_then>(|s| s.<Copy-field>) chain axis-uniformly across every Copy-valued slot on AllocationStatus, so a future normalization (a clock-skew guard that drops an expires_at stamped before its owning allocation’s observed allocated_at, a canonicalization pass that clamps a deadline to a monotonic upper bound, a stale- timestamp gate that returns None on an expires_at older than a controller-configured horizon) lands at ONE substrate method rather than being restated at every observer.

Return-form axis: Option<DateTime<Utc>> mirrors the copy-first discipline of Self::observed_phase. The lone pre-lift consumer ([tatara-pool-reconciler::allocation_decide:: AllocationConvergenceCtx::observe]’s expires_at seed) spelled the projection as .status.as_ref().and_then(|s| s.expires_at) — a 3-link hand-authored chain the observer walked on every reconcile pass. Post-lift the consumer reaches the primitive once and the whole missing-status + empty-slot corner cross collapses at the substrate rather than at the callsite.

The missing-status corner AND the populated-status-with- expires_at=None corner BOTH collapse to None so .is_some() / if let Some(_) / any >= deadline comparison behave identically on an EphemeralAllocation whose status field is None and on one whose status carries an unpopulated expires_at slot — matching what the pre-lift .and_then(...) chain produced. Consumers that need to tell those corners apart reach for Self::status directly, exactly as the existing peer accessors Self::observed_phase + Self::observed_phase_or_pending admit.

Theory anchor: THEORY.md §VI.1 (generation over composition — the .status.as_ref().and_then(|s| s.<Copy-field>) shape recurred as ONE hand-authored chain in [tatara-pool-reconciler::allocation_decide:: AllocationConvergenceCtx::observe] AND as the copy-form peer Self::observed_phase primitive already owned on the same CRD’s status.phase slot, past the substrate-shape recurrence trigger; the substrate now owns the third status-projection primitive on EphemeralAllocation, closing the copy-form family alongside the borrow-form Self::observed_bound_pool). THEORY.md §II.1 invariant 5 (composition preserves proofs — the pins bind the missing-status corner + the empty-expires_at- slot corner + the copy-form DateTime<Utc> return + byte- identical parity with the pre-lift .and_then(|s| s.expires_at) chain across the full corner set, so a regression that drifted any surface surfaces at tests::observed_expires_at_* rather than as silent operator-facing skew between the allocation observer’s Release-composition TTL gate and any future consumer that reaches for the same slot).

Trait Implementations

impl Clone for EphemeralAllocation

fn clone(&self) -> EphemeralAllocation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CustomResourceExt for EphemeralAllocation

fn crd() -> CustomResourceDefinition

Helper to generate the CRD including the JsonSchema

fn crd_name() -> &'static str

Helper to return the name of this CustomResourceDefinition in kubernetes.

fn api_resource() -> ApiResource

Helper to generate the api information type for use with the dynamic Api

fn shortnames() -> &'static [&'static str]

Shortnames of this resource type.

impl Debug for EphemeralAllocation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EphemeralAllocation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl HasSpec for EphemeralAllocation

type Spec = AllocationSpec

The type of the spec of this resource

fn spec(&self) -> &AllocationSpec

Returns a reference to the spec of the object

fn spec_mut(&mut self) -> &mut AllocationSpec

Returns a mutable reference to the spec of the object

impl HasStatus for EphemeralAllocation

type Status = AllocationStatus

The type of the status object

fn status(&self) -> Option<&AllocationStatus>

Returns an optional reference to the status of the object

fn status_mut(&mut self) -> &mut Option<AllocationStatus>

Returns an optional mutable reference to the status of the object

impl JsonSchema for EphemeralAllocation

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 Resource for EphemeralAllocation

type DynamicType = ()

Type information for types that do not know their resource information at compile time.

type Scope = NamespaceResourceScope

Type information for the api scope of the resource when known at compile time

fn group(_: &()) -> Cow<'_, str>

Returns group of this object

fn kind(_: &()) -> Cow<'_, str>

Returns kind of this object

fn version(_: &()) -> Cow<'_, str>

Returns version of this object

fn api_version(_: &()) -> Cow<'_, str>

Returns apiVersion of this object

fn plural(_: &()) -> Cow<'_, str>

Returns the plural name of the kind

fn meta(&self) -> &ObjectMeta

Metadata that all persisted resources must have

fn meta_mut(&mut self) -> &mut ObjectMeta

Metadata that all persisted resources must have

fn url_path(dt: &Self::DynamicType, namespace: Option<&str>) -> String

Creates a url path for http requests for this resource

fn object_ref(&self, dt: &Self::DynamicType) -> ObjectReference

Generates an object reference for the resource

fn controller_owner_ref(&self, dt: &Self::DynamicType) -> Option<OwnerReference>

Generates a controller owner reference pointing to this resource

fn owner_ref(&self, dt: &Self::DynamicType) -> Option<OwnerReference>

Generates an owner reference pointing to this resource

impl Serialize for EphemeralAllocation

fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.