Struct Condition 

#[non_exhaustive]
pub struct Condition {
    pub type: String,
    pub state: State,
    pub message: String,
    pub last_transition_time: Option<Timestamp>,
    pub severity: Severity,
    pub reasons: Option<Reasons>,
    /* private fields */
}

Defines a status condition for a resource.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

type: String

type is used to communicate the status of the reconciliation process. See also: https://github.com/knative/serving/blob/main/docs/spec/errors.md#error-conditions-and-reporting Types common to all resources include:

• “Ready”: True when the Resource is ready.

state: State

State of the condition.

message: String

Human readable message indicating details about the current status.

last_transition_time: Option<Timestamp>

Last time the condition transitioned from one status to another.

severity: Severity

How to interpret failures of this condition, one of Error, Warning, Info

reasons: Option<Reasons>

The reason for this condition. Depending on the condition type, it will populate one of these fields. Successful conditions cannot have a reason.

Implementations

impl Condition

pub fn new() -> Self

pub fn set_type<T: Into<String>>(self, v: T) -> Self

Sets the value of r#type.

Example

let x = Condition::new().set_type("example");

pub fn set_state<T: Into<State>>(self, v: T) -> Self

Sets the value of state.

Example

use google_cloud_run_v2::model::condition::State;
let x0 = Condition::new().set_state(State::ConditionPending);
let x1 = Condition::new().set_state(State::ConditionReconciling);
let x2 = Condition::new().set_state(State::ConditionFailed);

pub fn set_message<T: Into<String>>(self, v: T) -> Self

Sets the value of message.

Example

let x = Condition::new().set_message("example");

pub fn set_last_transition_time<T>(self, v: T) -> Self

where T: Into<Timestamp>,

Sets the value of last_transition_time.

Example

use wkt::Timestamp;
let x = Condition::new().set_last_transition_time(Timestamp::default()/* use setters */);

pub fn set_or_clear_last_transition_time<T>(self, v: Option<T>) -> Self

where T: Into<Timestamp>,

Sets or clears the value of last_transition_time.

Example

use wkt::Timestamp;
let x = Condition::new().set_or_clear_last_transition_time(Some(Timestamp::default()/* use setters */));
let x = Condition::new().set_or_clear_last_transition_time(None::<Timestamp>);

pub fn set_severity<T: Into<Severity>>(self, v: T) -> Self

Sets the value of severity.

Example

use google_cloud_run_v2::model::condition::Severity;
let x0 = Condition::new().set_severity(Severity::Error);
let x1 = Condition::new().set_severity(Severity::Warning);
let x2 = Condition::new().set_severity(Severity::Info);

pub fn set_reasons<T: Into<Option<Reasons>>>(self, v: T) -> Self

Sets the value of reasons.

Note that all the setters affecting reasons are mutually exclusive.

Example

use google_cloud_run_v2::model::condition::CommonReason;
let x0 = Condition::new().set_reasons(Some(
    google_cloud_run_v2::model::condition::Reasons::Reason(CommonReason::Unknown)));
let x1 = Condition::new().set_reasons(Some(
    google_cloud_run_v2::model::condition::Reasons::Reason(CommonReason::RevisionFailed)));
let x2 = Condition::new().set_reasons(Some(
    google_cloud_run_v2::model::condition::Reasons::Reason(CommonReason::ProgressDeadlineExceeded)));

pub fn reason(&self) -> Option<&CommonReason>

The value of reasons if it holds a Reason, None if the field is not set or holds a different branch.

pub fn set_reason<T: Into<CommonReason>>(self, v: T) -> Self

Sets the value of reasons to hold a Reason.

Note that all the setters affecting reasons are mutually exclusive.

Example

use google_cloud_run_v2::model::condition::CommonReason;
let x0 = Condition::new().set_reason(CommonReason::Unknown);
let x1 = Condition::new().set_reason(CommonReason::RevisionFailed);
let x2 = Condition::new().set_reason(CommonReason::ProgressDeadlineExceeded);
assert!(x0.reason().is_some());
assert!(x0.revision_reason().is_none());
assert!(x0.execution_reason().is_none());
assert!(x1.reason().is_some());
assert!(x1.revision_reason().is_none());
assert!(x1.execution_reason().is_none());
assert!(x2.reason().is_some());
assert!(x2.revision_reason().is_none());
assert!(x2.execution_reason().is_none());

pub fn revision_reason(&self) -> Option<&RevisionReason>

The value of reasons if it holds a RevisionReason, None if the field is not set or holds a different branch.

pub fn set_revision_reason<T: Into<RevisionReason>>(self, v: T) -> Self

Sets the value of reasons to hold a RevisionReason.

Note that all the setters affecting reasons are mutually exclusive.

Example

use google_cloud_run_v2::model::condition::RevisionReason;
let x0 = Condition::new().set_revision_reason(RevisionReason::Pending);
let x1 = Condition::new().set_revision_reason(RevisionReason::Reserve);
let x2 = Condition::new().set_revision_reason(RevisionReason::Retired);
assert!(x0.revision_reason().is_some());
assert!(x0.reason().is_none());
assert!(x0.execution_reason().is_none());
assert!(x1.revision_reason().is_some());
assert!(x1.reason().is_none());
assert!(x1.execution_reason().is_none());
assert!(x2.revision_reason().is_some());
assert!(x2.reason().is_none());
assert!(x2.execution_reason().is_none());

pub fn execution_reason(&self) -> Option<&ExecutionReason>

The value of reasons if it holds a ExecutionReason, None if the field is not set or holds a different branch.

pub fn set_execution_reason<T: Into<ExecutionReason>>(self, v: T) -> Self

Sets the value of reasons to hold a ExecutionReason.

Note that all the setters affecting reasons are mutually exclusive.

Example

use google_cloud_run_v2::model::condition::ExecutionReason;
let x0 = Condition::new().set_execution_reason(ExecutionReason::JobStatusServicePollingError);
let x1 = Condition::new().set_execution_reason(ExecutionReason::NonZeroExitCode);
let x2 = Condition::new().set_execution_reason(ExecutionReason::Cancelled);
assert!(x0.execution_reason().is_some());
assert!(x0.reason().is_none());
assert!(x0.revision_reason().is_none());
assert!(x1.execution_reason().is_some());
assert!(x1.reason().is_none());
assert!(x1.revision_reason().is_none());
assert!(x2.execution_reason().is_some());
assert!(x2.reason().is_none());
assert!(x2.revision_reason().is_none());

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl Default for Condition

fn default() -> Condition

Returns the “default value” for a type.

impl Message for Condition

fn typename() -> &'static str

The typename of this message.

impl PartialEq for Condition

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