Enum RestoreClaimPhase 

pub enum RestoreClaimPhase {
    Pending,
    Populating,
    Rebinding,
    Populated,
    AlreadyBound,
    Failed,
    Unknown(String),
}

Lifecycle phase of ONE claiming PVC of a populator Restore (#443).

Deliberately a separate closed enum from RestorePhase: a claim has states the Restore does not (Rebinding, AlreadyBound), and the Restore-level phase is the AGGREGATE over these. Named *Phase on purpose, so cargo xtask check-phases polices every branch on it.

use kopiur_api::RestoreClaimPhase;

assert_eq!(serde_json::to_value(RestoreClaimPhase::Populating).unwrap(), "Populating");
// An unrecognized phase from a newer operator decodes instead of erroring.
let p: RestoreClaimPhase = serde_json::from_value(serde_json::json!("Staging")).unwrap();
assert_eq!(p, RestoreClaimPhase::Unknown("Staging".into()));
assert_eq!(serde_json::to_value(&p).unwrap(), "Staging");
assert!(!p.is_terminal());

Variants

Pending

Observed, but nothing has run for it yet — waiting on a scheduling hint (WaitForFirstConsumer), on the repository, or on the source snapshot.

Populating

A mover Job is writing this claim’s prime PVC.

Rebinding

The prime volume is written and its PersistentVolume was rebound to the claim; waiting for the PV controller to complete the bind.

Populated

The claim is bound to the volume this restore populated. Terminal.

AlreadyBound

The claim was ALREADY bound when first observed, so there was nothing to populate — a CSI volume-populator only fills an UNBOUND claim. A truthful terminal no-op (#233): no prime PVC, no mover run.

Failed

This claim terminally failed; reason/message say why. Terminal for the CLAIM only — siblings keep going, and re-creating this claiming PVC re-arms it.

Unknown(String)

A phase string this build does not recognize (newer operator, or legacy stored data). Decode-compat only — hidden from the CRD schema, never produced by this build, never terminal.

Implementations

impl RestoreClaimPhase

pub fn is_terminal(&self) -> bool

Whether this claim reached an end state and the operator will do no further work on it of its own accord.

Failed IS terminal here, and that is what lets the fan-out stop short-circuiting the WHOLE Restore on Failed: the failure is scoped to this claim, its siblings keep going, and what re-arms it is deleting and re-creating the claiming PVC (which mints a new uid, hence a new record) — never a re-drive of the old one.

Pure + exhaustive, so the single definition lives in one tested place.

use kopiur_api::RestoreClaimPhase;

assert!(RestoreClaimPhase::Populated.is_terminal());
assert!(RestoreClaimPhase::AlreadyBound.is_terminal());
assert!(RestoreClaimPhase::Failed.is_terminal());
assert!(!RestoreClaimPhase::Pending.is_terminal());
assert!(!RestoreClaimPhase::Populating.is_terminal());
assert!(!RestoreClaimPhase::Rebinding.is_terminal());
assert!(!RestoreClaimPhase::Unknown("Staging".into()).is_terminal());

pub fn is_unknown(&self) -> bool

Whether this phase is the decode sentinel — a value the running build cannot interpret, kept verbatim by Unknown instead of failing the whole typed list()/watch for the Kind.

use kopiur_api::RestoreClaimPhase;

assert!(RestoreClaimPhase::Unknown("Staging".into()).is_unknown());
assert!(!RestoreClaimPhase::Populated.is_unknown());

Trait Implementations

impl Clone for RestoreClaimPhase

fn clone(&self) -> RestoreClaimPhase

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RestoreClaimPhase

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

Formats the value using the given formatter.

impl Default for RestoreClaimPhase

fn default() -> RestoreClaimPhase

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RestoreClaimPhase

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Eq for RestoreClaimPhase

impl JsonSchema for RestoreClaimPhase

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

The name of the generated JSON Schema.

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

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

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

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

impl PartialEq for RestoreClaimPhase

fn eq(&self, other: &RestoreClaimPhase) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PhaseLabel for RestoreClaimPhase

const ALL: &'static [Self]

Every canonical variant, in declaration order. Never contains Unknown.

fn label(&self) -> &str

The stable metric/wire label string for this variant (exhaustive match); the Unknown arm echoes the stored value verbatim so a read-modify-write never mutates a phase this build does not understand.

fn unknown(raw: String) -> Self

Build the decode-compat fallback for a non-canonical stored string. Implemented by the phase_serde! macro’s host enum.

fn parse(s: &str) -> Option<Self>

Parse a canonical label; None for anything else (including a value that would decode to Unknown). Derived from ALL + label() so a new variant is parseable the moment it is declared.

fn canonical() -> Vec<&'static str>

The canonical label set, for the CRD schema enum and “valid values” messages. One definition, derived from ALL.

impl Serialize for RestoreClaimPhase

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RestoreClaimPhase