Struct StructuralGate 

pub struct StructuralGate {
    pub applies_to: GateScope,
    pub condition: &'static str,
    pub blocked_status: &'static str,
    pub reason: &'static str,
    pub severity: GateSeverity,
}

One human-actionable structural gate: a condition type, the status that means BLOCKED, the reason the writer stamps, the CR kinds it appears on, and how loudly to report it.

Polarity is per-row rather than implied, because kopiur has gates of both shapes: MoverPermitted=False blocks, and so does DeletionHeld=True.

Fields

applies_to: GateScope

The CR kinds this gate’s condition is written on.

condition: &'static str

The condition type (a consts string, never a literal at the call site).

blocked_status: &'static str

The condition status that means BLOCKED — CONDITION_FALSE or CONDITION_TRUE.

reason: &'static str

The reason the reconciler stamps when it writes the blocked condition.

severity: GateSeverity

How loudly a tripped gate is reported.

Implementations

impl StructuralGate

pub fn matches(&self, condition_type: &str, status: &str, reason: &str) -> bool

Whether a live condition is this gate: type, status, AND reason all match.

This is the matcher consumers should reach for. condition + status alone do not identify a row — CredentialsAvailable=False is written with several different reasons and therefore has several rows — so filtering the registry on trips alone yields multiple hits for one live condition and double-reports it. matches selects exactly one row per live condition, which is the property gate_rows_are_unique_and_internally_consistent pins.

use kopiur_api::gates::STRUCTURAL_GATES;

// One live condition off a wedged Snapshot ⇒ exactly one registry row.
let hits: Vec<_> = STRUCTURAL_GATES
    .iter()
    .filter(|g| g.matches("CredentialsAvailable", "False", "MissingCredentialsSecret"))
    .collect();
assert_eq!(hits.len(), 1);
assert_eq!(hits[0].reason, "MissingCredentialsSecret");
// The other reason selects the other row, never both.
assert!(!hits[0].matches("CredentialsAvailable", "False", "MissingServiceAccount"));

pub fn trips(&self, condition_type: &str, status: &str) -> bool

The reason-agnostic coarse filter: whether a live condition’s type/status pair is the blocked polarity of this gate’s condition.

The polarity comparison lives here so no consumer re-derives it (the != "True" / == "True" mix-ups this registry exists to prevent). Use it to answer “is this condition one of the ones we gate on at all?” — notably when a live condition carries a reason NO row covers (a newer operator’s reason string), where matches would silently report nothing. To identify WHICH row a condition is, use matches: trips can match several rows sharing a condition+polarity.

use kopiur_api::gates::{STRUCTURAL_GATES, GateScope};

let mover = STRUCTURAL_GATES
    .iter()
    .find(|g| g.condition == "MoverPermitted")
    .expect("the privileged-mover gate is registered");
assert!(mover.trips("MoverPermitted", "False"));
assert!(!mover.trips("MoverPermitted", "True"));
assert!(!mover.trips("Ready", "False"));
assert_eq!(mover.applies_to, GateScope::SnapshotOrRestore);

// Coarse by design: an unregistered reason still flags the condition.
assert!(mover.trips("MoverPermitted", "False"));

pub fn blocked_is_true(&self) -> bool

blocked_status as the bool a condition writer passes when it writes this gate as BLOCKED — true for CONDITION_TRUE, false for CONDITION_FALSE.

The controller’s upsert_condition takes a bool, so without this every registry-driven writer would hand-translate the status string at its own call site — exactly the per-site re-derivation this registry exists to remove. Any other string reads as false; the every_gate_row_is_well_formed tripwire makes that unreachable.

use kopiur_api::gates::STRUCTURAL_GATES;

let mover = STRUCTURAL_GATES
    .iter()
    .find(|g| g.condition == "MoverPermitted")
    .expect("registered");
assert!(!mover.blocked_is_true()); // MoverPermitted=False blocks

let held = STRUCTURAL_GATES
    .iter()
    .find(|g| g.condition == "DeletionHeld")
    .expect("registered");
assert!(held.blocked_is_true()); // DeletionHeld=True blocks

Trait Implementations

impl Clone for StructuralGate

fn clone(&self) -> StructuralGate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StructuralGate

impl Debug for StructuralGate

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

Formats the value using the given formatter.

impl Eq for StructuralGate

impl PartialEq for StructuralGate

fn eq(&self, other: &StructuralGate) -> 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 StructuralPartialEq for StructuralGate