Struct Rule 

pub struct Rule {
    pub rule: String,
    pub message: Option<Message>,
    pub field_path: Option<String>,
    pub reason: Option<Reason>,
    pub optional_old_self: Option<bool>,
}

Rule is a CEL validation rule for the CRD field

Fields

rule: String

rule represents the expression which will be evaluated by CEL. The self variable in the CEL expression is bound to the scoped value.

message: Option<Message>

message represents CEL validation message for the provided type If unset, the message is “failed rule: {Rule}”.

field_path: Option<String>

fieldPath represents the field path returned when the validation fails. It must be a relative JSON path, scoped to the location of the field in the schema

reason: Option<Reason>

reason is a machine-readable value providing more detail about why a field failed the validation.

optional_old_self: Option<bool>

optionalOldSelf allows transition rules (using oldSelf) to also evaluate during object creation When enabled, oldSelf becomes a CEL optional_type. You must use functions like optMap(), hasValue(), or orValue() to safely compare it against self.

Implementations

impl Rule

pub fn new(rule: impl Into<String>) -> Self

Initialize the rule

use kube_core::Rule;
let r = Rule::new("self == oldSelf");

assert_eq!(r.rule, "self == oldSelf".to_string())

pub fn message(self, message: impl Into<Message>) -> Self

Set the rule message.

use kube_core::Rule;

use kube_core::{Rule, Message};

let r = Rule::new("self == oldSelf").message("is immutable");
assert_eq!(r.rule, "self == oldSelf".to_string());
assert_eq!(r.message, Some(Message::Message("is immutable".to_string())));

pub fn reason(self, reason: impl Into<Reason>) -> Self

Set the failure reason.

use kube_core::Rule;

use kube_core::{Rule, Reason};

let r = Rule::new("self == oldSelf").reason(Reason::default());
assert_eq!(r.rule, "self == oldSelf".to_string());
assert_eq!(r.reason, Some(Reason::FieldValueInvalid));

pub fn field_path(self, field_path: impl Into<String>) -> Self

Set the failure field_path.

use kube_core::Rule;

use kube_core::Rule;

let r = Rule::new("self == oldSelf").field_path("obj.field");
assert_eq!(r.rule, "self == oldSelf".to_string());
assert_eq!(r.field_path, Some("obj.field".to_string()));

pub fn optional_old_self(self, optional: bool) -> Self

Set the optionalOldSelf configuration.

use kube_core::Rule;

let r = Rule::new("oldSelf.optMap(o, o == self).orValue(true)").optional_old_self(true);
assert_eq!(r.optional_old_self, Some(true));

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.

impl Default for Rule

fn default() -> Rule

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&str> for Rule

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<(&str, &str)> for Rule

fn from((rule, msg): (&str, &str)) -> Self

Converts to this type from the input type.

impl Serialize for Rule

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

where __S: Serializer,

Serialize this value into the given Serde serializer.