k8s-crds-cluster-api 1.12.5

// WARNING: generated by kopium - manual changes will be overwritten
// kopium command: kopium -f machinedrainrules.yml --schema=derived --docs -b --derive=Default --derive=PartialEq --smart-derive-elision
// kopium version: 0.23.0

#[allow(unused_imports)]
mod prelude {
    pub use kube_derive::CustomResource;
    #[cfg(feature = "schemars")]
    pub use schemars::JsonSchema;
    pub use serde::{Deserialize, Serialize};
    pub use std::collections::BTreeMap;
    #[cfg(feature = "builder")]
    pub use typed_builder::TypedBuilder;
}

use self::prelude::*;

/// spec defines the spec of a MachineDrainRule.
#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[cfg_attr(not(feature = "schemars"), kube(schema = "disabled"))]
#[kube(
    group = "cluster.x-k8s.io",
    version = "v1beta2",
    kind = "MachineDrainRule",
    plural = "machinedrainrules"
)]
#[kube(namespaced)]
#[kube(derive = "PartialEq")]
pub struct MachineDrainRuleSpec {
    /// drain configures if and how Pods are drained.
    pub drain: MachineDrainRuleDrain,
    /// machines defines to which Machines this MachineDrainRule should be applied.
    ///
    /// If machines is not set, the MachineDrainRule applies to all Machines in the Namespace.
    /// If machines contains multiple selectors, the results are ORed.
    /// Within a single Machine selector the results of selector and clusterSelector are ANDed.
    /// Machines will be selected from all Clusters in the Namespace unless otherwise
    /// restricted with the clusterSelector.
    ///
    /// Example: Selects control plane Machines in all Clusters or
    ///          Machines with label "os" == "linux" in Clusters with label
    ///          "stage" == "production".
    ///
    ///  - selector:
    ///      matchExpressions:
    ///      - key: cluster.x-k8s.io/control-plane
    ///        operator: Exists
    ///  - selector:
    ///      matchLabels:
    ///        os: linux
    ///    clusterSelector:
    ///      matchExpressions:
    ///      - key: stage
    ///        operator: In
    ///        values:
    ///        - production
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub machines: Option<Vec<MachineDrainRuleMachines>>,
    /// pods defines to which Pods this MachineDrainRule should be applied.
    ///
    /// If pods is not set, the MachineDrainRule applies to all Pods in all Namespaces.
    /// If pods contains multiple selectors, the results are ORed.
    /// Within a single Pod selector the results of selector and namespaceSelector are ANDed.
    /// Pods will be selected from all Namespaces unless otherwise
    /// restricted with the namespaceSelector.
    ///
    /// Example: Selects Pods with label "app" == "logging" in all Namespaces or
    ///          Pods with label "app" == "prometheus" in the "monitoring"
    ///          Namespace.
    ///
    ///  - selector:
    ///      matchExpressions:
    ///      - key: app
    ///        operator: In
    ///        values:
    ///        - logging
    ///  - selector:
    ///      matchLabels:
    ///        app: prometheus
    ///    namespaceSelector:
    ///      matchLabels:
    ///        kubernetes.io/metadata.name: monitoring
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub pods: Option<Vec<MachineDrainRulePods>>,
}

/// drain configures if and how Pods are drained.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRuleDrain {
    /// behavior defines the drain behavior.
    /// Can be either "Drain", "Skip", or "WaitCompleted".
    /// "Drain" means that the Pods to which this MachineDrainRule applies will be drained.
    /// If behavior is set to "Drain" the order in which Pods are drained can be configured
    /// with the order field. When draining Pods of a Node the Pods will be grouped by order
    /// and one group after another will be drained (by increasing order). Cluster API will
    /// wait until all Pods of a group are terminated / removed from the Node before starting
    /// with the next group.
    /// "Skip" means that the Pods to which this MachineDrainRule applies will be skipped during drain.
    /// "WaitCompleted" means that the pods to which this MachineDrainRule applies will never be evicted
    /// and we wait for them to be completed, it is enforced that pods marked with this behavior always have Order=0.
    pub behavior: MachineDrainRuleDrainBehavior,
    /// order defines the order in which Pods are drained.
    /// Pods with higher order are drained after Pods with lower order.
    /// order can only be set if behavior is set to "Drain".
    /// If order is not set, 0 will be used.
    /// Valid values for order are from -2147483648 to 2147483647 (inclusive).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub order: Option<i32>,
}

/// drain configures if and how Pods are drained.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub enum MachineDrainRuleDrainBehavior {
    Drain,
    Skip,
    WaitCompleted,
}

/// MachineDrainRuleMachineSelector defines to which Machines this MachineDrainRule should be applied.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRuleMachines {
    /// clusterSelector is a label selector which selects Machines by the labels of
    /// their Clusters.
    /// This field follows standard label selector semantics; if not present or
    /// empty, it selects Machines of all Clusters.
    ///
    /// If selector is also set, then the selector as a whole selects
    /// Machines matching selector belonging to Clusters selected by clusterSelector.
    /// If selector is not set, it selects all Machines belonging to Clusters
    /// selected by clusterSelector.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "clusterSelector"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub cluster_selector: Option<MachineDrainRuleMachinesClusterSelector>,
    /// selector is a label selector which selects Machines by their labels.
    /// This field follows standard label selector semantics; if not present or
    /// empty, it selects all Machines.
    ///
    /// If clusterSelector is also set, then the selector as a whole selects
    /// Machines matching selector belonging to Clusters selected by clusterSelector.
    /// If clusterSelector is not set, it selects all Machines matching selector in
    /// all Clusters.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub selector: Option<MachineDrainRuleMachinesSelector>,
}

/// clusterSelector is a label selector which selects Machines by the labels of
/// their Clusters.
/// This field follows standard label selector semantics; if not present or
/// empty, it selects Machines of all Clusters.
///
/// If selector is also set, then the selector as a whole selects
/// Machines matching selector belonging to Clusters selected by clusterSelector.
/// If selector is not set, it selects all Machines belonging to Clusters
/// selected by clusterSelector.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRuleMachinesClusterSelector {
    /// matchExpressions is a list of label selector requirements. The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchExpressions"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_expressions: Option<Vec<MachineDrainRuleMachinesClusterSelectorMatchExpressions>>,
    /// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
    /// map is equivalent to an element of matchExpressions, whose key field is "key", the
    /// operator is "In", and the values array contains only "value". The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchLabels"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_labels: Option<BTreeMap<String, String>>,
}

/// A label selector requirement is a selector that contains values, a key, and an operator that
/// relates the key and values.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRuleMachinesClusterSelectorMatchExpressions {
    /// key is the label key that the selector applies to.
    pub key: String,
    /// operator represents a key's relationship to a set of values.
    /// Valid operators are In, NotIn, Exists and DoesNotExist.
    pub operator: String,
    /// values is an array of string values. If the operator is In or NotIn,
    /// the values array must be non-empty. If the operator is Exists or DoesNotExist,
    /// the values array must be empty. This array is replaced during a strategic
    /// merge patch.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub values: Option<Vec<String>>,
}

/// selector is a label selector which selects Machines by their labels.
/// This field follows standard label selector semantics; if not present or
/// empty, it selects all Machines.
///
/// If clusterSelector is also set, then the selector as a whole selects
/// Machines matching selector belonging to Clusters selected by clusterSelector.
/// If clusterSelector is not set, it selects all Machines matching selector in
/// all Clusters.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRuleMachinesSelector {
    /// matchExpressions is a list of label selector requirements. The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchExpressions"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_expressions: Option<Vec<MachineDrainRuleMachinesSelectorMatchExpressions>>,
    /// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
    /// map is equivalent to an element of matchExpressions, whose key field is "key", the
    /// operator is "In", and the values array contains only "value". The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchLabels"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_labels: Option<BTreeMap<String, String>>,
}

/// A label selector requirement is a selector that contains values, a key, and an operator that
/// relates the key and values.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRuleMachinesSelectorMatchExpressions {
    /// key is the label key that the selector applies to.
    pub key: String,
    /// operator represents a key's relationship to a set of values.
    /// Valid operators are In, NotIn, Exists and DoesNotExist.
    pub operator: String,
    /// values is an array of string values. If the operator is In or NotIn,
    /// the values array must be non-empty. If the operator is Exists or DoesNotExist,
    /// the values array must be empty. This array is replaced during a strategic
    /// merge patch.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub values: Option<Vec<String>>,
}

/// MachineDrainRulePodSelector defines to which Pods this MachineDrainRule should be applied.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRulePods {
    /// namespaceSelector is a label selector which selects Pods by the labels of
    /// their Namespaces.
    /// This field follows standard label selector semantics; if not present or
    /// empty, it selects Pods of all Namespaces.
    ///
    /// If selector is also set, then the selector as a whole selects
    /// Pods matching selector in Namespaces selected by namespaceSelector.
    /// If selector is not set, it selects all Pods in Namespaces selected by
    /// namespaceSelector.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "namespaceSelector"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub namespace_selector: Option<MachineDrainRulePodsNamespaceSelector>,
    /// selector is a label selector which selects Pods by their labels.
    /// This field follows standard label selector semantics; if not present or
    /// empty, it selects all Pods.
    ///
    /// If namespaceSelector is also set, then the selector as a whole selects
    /// Pods matching selector in Namespaces selected by namespaceSelector.
    /// If namespaceSelector is not set, it selects all Pods matching selector in
    /// all Namespaces.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub selector: Option<MachineDrainRulePodsSelector>,
}

/// namespaceSelector is a label selector which selects Pods by the labels of
/// their Namespaces.
/// This field follows standard label selector semantics; if not present or
/// empty, it selects Pods of all Namespaces.
///
/// If selector is also set, then the selector as a whole selects
/// Pods matching selector in Namespaces selected by namespaceSelector.
/// If selector is not set, it selects all Pods in Namespaces selected by
/// namespaceSelector.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRulePodsNamespaceSelector {
    /// matchExpressions is a list of label selector requirements. The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchExpressions"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_expressions: Option<Vec<MachineDrainRulePodsNamespaceSelectorMatchExpressions>>,
    /// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
    /// map is equivalent to an element of matchExpressions, whose key field is "key", the
    /// operator is "In", and the values array contains only "value". The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchLabels"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_labels: Option<BTreeMap<String, String>>,
}

/// A label selector requirement is a selector that contains values, a key, and an operator that
/// relates the key and values.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRulePodsNamespaceSelectorMatchExpressions {
    /// key is the label key that the selector applies to.
    pub key: String,
    /// operator represents a key's relationship to a set of values.
    /// Valid operators are In, NotIn, Exists and DoesNotExist.
    pub operator: String,
    /// values is an array of string values. If the operator is In or NotIn,
    /// the values array must be non-empty. If the operator is Exists or DoesNotExist,
    /// the values array must be empty. This array is replaced during a strategic
    /// merge patch.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub values: Option<Vec<String>>,
}

/// selector is a label selector which selects Pods by their labels.
/// This field follows standard label selector semantics; if not present or
/// empty, it selects all Pods.
///
/// If namespaceSelector is also set, then the selector as a whole selects
/// Pods matching selector in Namespaces selected by namespaceSelector.
/// If namespaceSelector is not set, it selects all Pods matching selector in
/// all Namespaces.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRulePodsSelector {
    /// matchExpressions is a list of label selector requirements. The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchExpressions"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_expressions: Option<Vec<MachineDrainRulePodsSelectorMatchExpressions>>,
    /// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
    /// map is equivalent to an element of matchExpressions, whose key field is "key", the
    /// operator is "In", and the values array contains only "value". The requirements are ANDed.
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        rename = "matchLabels"
    )]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub match_labels: Option<BTreeMap<String, String>>,
}

/// A label selector requirement is a selector that contains values, a key, and an operator that
/// relates the key and values.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "builder", derive(TypedBuilder))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct MachineDrainRulePodsSelectorMatchExpressions {
    /// key is the label key that the selector applies to.
    pub key: String,
    /// operator represents a key's relationship to a set of values.
    /// Valid operators are In, NotIn, Exists and DoesNotExist.
    pub operator: String,
    /// values is an array of string values. If the operator is In or NotIn,
    /// the values array must be non-empty. If the operator is Exists or DoesNotExist,
    /// the values array must be empty. This array is replaced during a strategic
    /// merge patch.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "builder", builder(default, setter(strip_option)))]
    pub values: Option<Vec<String>>,
}