Skip to main content

k8s_openapi/v1_37/api/scheduling/v1beta1/
pod_group_scheduling_policy.rs

1// Generated from definition io.k8s.api.scheduling.v1beta1.PodGroupSchedulingPolicy
2
3/// PodGroupSchedulingPolicy defines the scheduling configuration for a PodGroup. Exactly one policy must be set. The policy is chosen at creation time by setting either the Basic or Gang field. The PodGroup may not change policy after creation. Fields within chosen policy may be updated after creation when their individual fields allow it.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct PodGroupSchedulingPolicy {
6    /// basic specifies that the pods in this group should be scheduled using standard Kubernetes scheduling behavior. Setting this field at group creation time opts this group to basic scheduling; this field cannot be changed afterward.
7    pub basic: Option<crate::api::scheduling::v1beta1::BasicSchedulingPolicy>,
8
9    /// gang specifies that the pods in this group should be scheduled using all-or-nothing semantics. Setting this field at group creation time opts this group to gang scheduling; this field cannot be set or unset afterward. The minCount field within Gang scheduling policy remains mutable after group creation.
10    pub gang: Option<crate::api::scheduling::v1beta1::GangSchedulingPolicy>,
11}
12
13impl crate::DeepMerge for PodGroupSchedulingPolicy {
14    fn merge_from(&mut self, other: Self) {
15        crate::DeepMerge::merge_from(&mut self.basic, other.basic);
16        crate::DeepMerge::merge_from(&mut self.gang, other.gang);
17    }
18}
19
20impl<'de> crate::serde::Deserialize<'de> for PodGroupSchedulingPolicy {
21    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
22        #[allow(non_camel_case_types)]
23        enum Field {
24            Key_basic,
25            Key_gang,
26            Other,
27        }
28
29        impl<'de> crate::serde::Deserialize<'de> for Field {
30            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
31                struct Visitor;
32
33                impl crate::serde::de::Visitor<'_> for Visitor {
34                    type Value = Field;
35
36                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
37                        f.write_str("field identifier")
38                    }
39
40                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
41                        Ok(match v {
42                            "basic" => Field::Key_basic,
43                            "gang" => Field::Key_gang,
44                            _ => Field::Other,
45                        })
46                    }
47                }
48
49                deserializer.deserialize_identifier(Visitor)
50            }
51        }
52
53        struct Visitor;
54
55        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
56            type Value = PodGroupSchedulingPolicy;
57
58            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
59                f.write_str("PodGroupSchedulingPolicy")
60            }
61
62            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
63                let mut value_basic: Option<crate::api::scheduling::v1beta1::BasicSchedulingPolicy> = None;
64                let mut value_gang: Option<crate::api::scheduling::v1beta1::GangSchedulingPolicy> = None;
65
66                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
67                    match key {
68                        Field::Key_basic => value_basic = crate::serde::de::MapAccess::next_value(&mut map)?,
69                        Field::Key_gang => value_gang = crate::serde::de::MapAccess::next_value(&mut map)?,
70                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
71                    }
72                }
73
74                Ok(PodGroupSchedulingPolicy {
75                    basic: value_basic,
76                    gang: value_gang,
77                })
78            }
79        }
80
81        deserializer.deserialize_struct(
82            "PodGroupSchedulingPolicy",
83            &[
84                "basic",
85                "gang",
86            ],
87            Visitor,
88        )
89    }
90}
91
92impl crate::serde::Serialize for PodGroupSchedulingPolicy {
93    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
94        let mut state = serializer.serialize_struct(
95            "PodGroupSchedulingPolicy",
96            self.basic.as_ref().map_or(0, |_| 1) +
97            self.gang.as_ref().map_or(0, |_| 1),
98        )?;
99        if let Some(value) = &self.basic {
100            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "basic", value)?;
101        }
102        if let Some(value) = &self.gang {
103            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "gang", value)?;
104        }
105        crate::serde::ser::SerializeStruct::end(state)
106    }
107}
108
109#[cfg(feature = "schemars")]
110impl crate::schemars::JsonSchema for PodGroupSchedulingPolicy {
111    fn schema_name() -> std::borrow::Cow<'static, str> {
112        "io.k8s.api.scheduling.v1beta1.PodGroupSchedulingPolicy".into()
113    }
114
115    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
116        crate::schemars::json_schema!({
117            "description": "PodGroupSchedulingPolicy defines the scheduling configuration for a PodGroup. Exactly one policy must be set. The policy is chosen at creation time by setting either the Basic or Gang field. The PodGroup may not change policy after creation. Fields within chosen policy may be updated after creation when their individual fields allow it.",
118            "type": "object",
119            "properties": {
120                "basic": ({
121                    let mut schema_obj = __gen.subschema_for::<crate::api::scheduling::v1beta1::BasicSchedulingPolicy>();
122                    schema_obj.ensure_object().insert("description".into(), "basic specifies that the pods in this group should be scheduled using standard Kubernetes scheduling behavior. Setting this field at group creation time opts this group to basic scheduling; this field cannot be changed afterward.".into());
123                    schema_obj
124                }),
125                "gang": ({
126                    let mut schema_obj = __gen.subschema_for::<crate::api::scheduling::v1beta1::GangSchedulingPolicy>();
127                    schema_obj.ensure_object().insert("description".into(), "gang specifies that the pods in this group should be scheduled using all-or-nothing semantics. Setting this field at group creation time opts this group to gang scheduling; this field cannot be set or unset afterward. The minCount field within Gang scheduling policy remains mutable after group creation.".into());
128                    schema_obj
129                }),
130            },
131        })
132    }
133}