Struct PoolSpec 

pub struct PoolSpec {
    pub desired_size: u32,
    pub min_size: u32,
    pub max_size: u32,
    pub return_policy: ReturnPolicy,
    pub selector: PoolSelector,
    pub template: EphemeralSpec,
    pub free_ttl: String,
    pub max_allocation_ttl: String,
    pub desired: u32,
    pub replacement_policy: ReplacementPolicy,
    pub stable_name_claim: bool,
}

EphemeralPool CRD spec — typed pool of warm Processes.

apiVersion: tatara.pleme.io/v1alpha1
kind: EphemeralPool
metadata:
  name: akeyless-attest-pool
  namespace: ephemeral-pools
spec:
  desiredSize: 3
  minSize: 1
  maxSize: 5
  returnPolicy: Reset
  selector:
    repos: ["pleme-io/akeyless-*"]
    branches: ["main", "release-*"]
    prLabels: ["needs-akeyless"]
  template:
    aplicacao:
      chartRef: "oci://ghcr.io/pleme-io/charts/lareira-akeyless-deployment"
      version: "0.5.5"
      profile: "gateway-with-internal-saas"
      …
    ttl: "2h"
    teardown: OnAttested
    postconditions: [ … ]

Fields

desired_size: u32

Target number of warm Processes the pool maintains in Free state (sum of Free + Spawning targets desired_size).

min_size: u32

Hard floor on the free count. The reconciler refuses to scale below this even on cost-pressure signals. Default = 0.

max_size: u32

Hard ceiling on total pool members (free + allocated + spawning). 0 = no cap. Default = 0.

return_policy: ReturnPolicy

What to do when an allocation releases.

selector: PoolSelector

Routing selector — which allocation requests this pool serves. The reconciler matches incoming EphemeralAllocation CRs against this selector (most-specific wins across pools sharing a namespace).

template: EphemeralSpec

Template for each pool member — a typed EphemeralSpec that the reconciler lowers to ProcessSpec and instantiates. While in the free list each member’s lifetime is overridden to Permanent; allocation flips it back to Ephemeral with the requestor’s TTL.

free_ttl: String

How long a pool member may sit in Free before the reconciler recycles it (humantime). Defends against drift / stale state. Default "24h".

max_allocation_ttl: String

Max time the reconciler allows a single allocation to hold a member before forcibly returning it (humantime). Hard cap independent of the allocation’s own TTL. Default "4h".

desired: u32

R5 desired-count loop — when set non-zero, the pool reconciler maintains exactly this many healthy (Running or Attested) Processes regardless of allocation pressure. Drives the “always seeking stability” property: failed members are replaced per replacement_policy. 0 keeps the legacy allocation-driven sizing (desired = floor of free + allocated).

Operator usage: desired: 5 means “always have 5 of these running”; failures auto-replace.

replacement_policy: ReplacementPolicy

R5 — what the pool reconciler does when a member reaches Failed phase.

stable_name_claim: bool

R5 — when true, exactly one healthy member of the pool holds the unprefixed-form DNS hostnames declared in template.routing at any moment. The claim arbiter (see tatara-reconciler::claim) transfers atomically when the holder fails.

Trait Implementations

impl Clone for PoolSpec

fn clone(&self) -> PoolSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PoolSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PoolSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for PoolSpec

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 PoolSpec

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

where __S: Serializer,

Serialize this value into the given Serde serializer.