Skip to main content

k8s_openapi/v1_36/api/apps/v1/
deployment_condition.rs

1// Generated from definition io.k8s.api.apps.v1.DeploymentCondition
2
3/// DeploymentCondition describes the state of a deployment at a certain point.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct DeploymentCondition {
6    /// Last time the condition transitioned from one status to another.
7    pub last_transition_time: Option<crate::apimachinery::pkg::apis::meta::v1::Time>,
8
9    /// The last time this condition was updated.
10    pub last_update_time: Option<crate::apimachinery::pkg::apis::meta::v1::Time>,
11
12    /// A human readable message indicating details about the transition.
13    pub message: Option<std::string::String>,
14
15    /// The reason for the condition's last transition.
16    pub reason: Option<std::string::String>,
17
18    /// Status of the condition, one of True, False, Unknown.
19    pub status: std::string::String,
20
21    /// Type of deployment condition.
22    pub type_: std::string::String,
23}
24
25impl crate::DeepMerge for DeploymentCondition {
26    fn merge_from(&mut self, other: Self) {
27        crate::DeepMerge::merge_from(&mut self.last_transition_time, other.last_transition_time);
28        crate::DeepMerge::merge_from(&mut self.last_update_time, other.last_update_time);
29        crate::DeepMerge::merge_from(&mut self.message, other.message);
30        crate::DeepMerge::merge_from(&mut self.reason, other.reason);
31        crate::DeepMerge::merge_from(&mut self.status, other.status);
32        crate::DeepMerge::merge_from(&mut self.type_, other.type_);
33    }
34}
35
36impl<'de> crate::serde::Deserialize<'de> for DeploymentCondition {
37    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
38        #[allow(non_camel_case_types)]
39        enum Field {
40            Key_last_transition_time,
41            Key_last_update_time,
42            Key_message,
43            Key_reason,
44            Key_status,
45            Key_type_,
46            Other,
47        }
48
49        impl<'de> crate::serde::Deserialize<'de> for Field {
50            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
51                struct Visitor;
52
53                impl crate::serde::de::Visitor<'_> for Visitor {
54                    type Value = Field;
55
56                    fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
57                        f.write_str("field identifier")
58                    }
59
60                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
61                        Ok(match v {
62                            "lastTransitionTime" => Field::Key_last_transition_time,
63                            "lastUpdateTime" => Field::Key_last_update_time,
64                            "message" => Field::Key_message,
65                            "reason" => Field::Key_reason,
66                            "status" => Field::Key_status,
67                            "type" => Field::Key_type_,
68                            _ => Field::Other,
69                        })
70                    }
71                }
72
73                deserializer.deserialize_identifier(Visitor)
74            }
75        }
76
77        struct Visitor;
78
79        impl<'de> crate::serde::de::Visitor<'de> for Visitor {
80            type Value = DeploymentCondition;
81
82            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
83                f.write_str("DeploymentCondition")
84            }
85
86            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
87                let mut value_last_transition_time: Option<crate::apimachinery::pkg::apis::meta::v1::Time> = None;
88                let mut value_last_update_time: Option<crate::apimachinery::pkg::apis::meta::v1::Time> = None;
89                let mut value_message: Option<std::string::String> = None;
90                let mut value_reason: Option<std::string::String> = None;
91                let mut value_status: Option<std::string::String> = None;
92                let mut value_type_: Option<std::string::String> = None;
93
94                while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
95                    match key {
96                        Field::Key_last_transition_time => value_last_transition_time = crate::serde::de::MapAccess::next_value(&mut map)?,
97                        Field::Key_last_update_time => value_last_update_time = crate::serde::de::MapAccess::next_value(&mut map)?,
98                        Field::Key_message => value_message = crate::serde::de::MapAccess::next_value(&mut map)?,
99                        Field::Key_reason => value_reason = crate::serde::de::MapAccess::next_value(&mut map)?,
100                        Field::Key_status => value_status = crate::serde::de::MapAccess::next_value(&mut map)?,
101                        Field::Key_type_ => value_type_ = crate::serde::de::MapAccess::next_value(&mut map)?,
102                        Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
103                    }
104                }
105
106                Ok(DeploymentCondition {
107                    last_transition_time: value_last_transition_time,
108                    last_update_time: value_last_update_time,
109                    message: value_message,
110                    reason: value_reason,
111                    status: value_status.unwrap_or_default(),
112                    type_: value_type_.unwrap_or_default(),
113                })
114            }
115        }
116
117        deserializer.deserialize_struct(
118            "DeploymentCondition",
119            &[
120                "lastTransitionTime",
121                "lastUpdateTime",
122                "message",
123                "reason",
124                "status",
125                "type",
126            ],
127            Visitor,
128        )
129    }
130}
131
132impl crate::serde::Serialize for DeploymentCondition {
133    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
134        let mut state = serializer.serialize_struct(
135            "DeploymentCondition",
136            2 +
137            self.last_transition_time.as_ref().map_or(0, |_| 1) +
138            self.last_update_time.as_ref().map_or(0, |_| 1) +
139            self.message.as_ref().map_or(0, |_| 1) +
140            self.reason.as_ref().map_or(0, |_| 1),
141        )?;
142        if let Some(value) = &self.last_transition_time {
143            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "lastTransitionTime", value)?;
144        }
145        if let Some(value) = &self.last_update_time {
146            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "lastUpdateTime", value)?;
147        }
148        if let Some(value) = &self.message {
149            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "message", value)?;
150        }
151        if let Some(value) = &self.reason {
152            crate::serde::ser::SerializeStruct::serialize_field(&mut state, "reason", value)?;
153        }
154        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "status", &self.status)?;
155        crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", &self.type_)?;
156        crate::serde::ser::SerializeStruct::end(state)
157    }
158}
159
160#[cfg(feature = "schemars")]
161impl crate::schemars::JsonSchema for DeploymentCondition {
162    fn schema_name() -> std::borrow::Cow<'static, str> {
163        "io.k8s.api.apps.v1.DeploymentCondition".into()
164    }
165
166    fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
167        crate::schemars::json_schema!({
168            "description": "DeploymentCondition describes the state of a deployment at a certain point.",
169            "type": "object",
170            "properties": {
171                "lastTransitionTime": ({
172                    let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::Time>();
173                    schema_obj.ensure_object().insert("description".into(), "Last time the condition transitioned from one status to another.".into());
174                    schema_obj
175                }),
176                "lastUpdateTime": ({
177                    let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::Time>();
178                    schema_obj.ensure_object().insert("description".into(), "The last time this condition was updated.".into());
179                    schema_obj
180                }),
181                "message": {
182                    "description": "A human readable message indicating details about the transition.",
183                    "type": "string",
184                },
185                "reason": {
186                    "description": "The reason for the condition's last transition.",
187                    "type": "string",
188                },
189                "status": {
190                    "description": "Status of the condition, one of True, False, Unknown.",
191                    "type": "string",
192                },
193                "type": {
194                    "description": "Type of deployment condition.",
195                    "type": "string",
196                },
197            },
198            "required": [
199                "status",
200                "type",
201            ],
202        })
203    }
204}
205
206#[cfg(feature = "schemars08")]
207impl crate::schemars08::JsonSchema for DeploymentCondition {
208    fn schema_name() -> std::string::String {
209        "io.k8s.api.apps.v1.DeploymentCondition".into()
210    }
211
212    fn json_schema(__gen: &mut crate::schemars08::gen::SchemaGenerator) -> crate::schemars08::schema::Schema {
213        crate::schemars08::schema::Schema::Object(crate::schemars08::schema::SchemaObject {
214            metadata: Some(std::boxed::Box::new(crate::schemars08::schema::Metadata {
215                description: Some("DeploymentCondition describes the state of a deployment at a certain point.".into()),
216                ..Default::default()
217            })),
218            instance_type: Some(crate::schemars08::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars08::schema::InstanceType::Object))),
219            object: Some(std::boxed::Box::new(crate::schemars08::schema::ObjectValidation {
220                properties: [
221                    (
222                        "lastTransitionTime".into(),
223                        {
224                            let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::Time>().into_object();
225                            schema_obj.metadata = Some(std::boxed::Box::new(crate::schemars08::schema::Metadata {
226                                description: Some("Last time the condition transitioned from one status to another.".into()),
227                                ..Default::default()
228                            }));
229                            crate::schemars08::schema::Schema::Object(schema_obj)
230                        },
231                    ),
232                    (
233                        "lastUpdateTime".into(),
234                        {
235                            let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::Time>().into_object();
236                            schema_obj.metadata = Some(std::boxed::Box::new(crate::schemars08::schema::Metadata {
237                                description: Some("The last time this condition was updated.".into()),
238                                ..Default::default()
239                            }));
240                            crate::schemars08::schema::Schema::Object(schema_obj)
241                        },
242                    ),
243                    (
244                        "message".into(),
245                        crate::schemars08::schema::Schema::Object(crate::schemars08::schema::SchemaObject {
246                            metadata: Some(std::boxed::Box::new(crate::schemars08::schema::Metadata {
247                                description: Some("A human readable message indicating details about the transition.".into()),
248                                ..Default::default()
249                            })),
250                            instance_type: Some(crate::schemars08::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars08::schema::InstanceType::String))),
251                            ..Default::default()
252                        }),
253                    ),
254                    (
255                        "reason".into(),
256                        crate::schemars08::schema::Schema::Object(crate::schemars08::schema::SchemaObject {
257                            metadata: Some(std::boxed::Box::new(crate::schemars08::schema::Metadata {
258                                description: Some("The reason for the condition's last transition.".into()),
259                                ..Default::default()
260                            })),
261                            instance_type: Some(crate::schemars08::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars08::schema::InstanceType::String))),
262                            ..Default::default()
263                        }),
264                    ),
265                    (
266                        "status".into(),
267                        crate::schemars08::schema::Schema::Object(crate::schemars08::schema::SchemaObject {
268                            metadata: Some(std::boxed::Box::new(crate::schemars08::schema::Metadata {
269                                description: Some("Status of the condition, one of True, False, Unknown.".into()),
270                                ..Default::default()
271                            })),
272                            instance_type: Some(crate::schemars08::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars08::schema::InstanceType::String))),
273                            ..Default::default()
274                        }),
275                    ),
276                    (
277                        "type".into(),
278                        crate::schemars08::schema::Schema::Object(crate::schemars08::schema::SchemaObject {
279                            metadata: Some(std::boxed::Box::new(crate::schemars08::schema::Metadata {
280                                description: Some("Type of deployment condition.".into()),
281                                ..Default::default()
282                            })),
283                            instance_type: Some(crate::schemars08::schema::SingleOrVec::Single(std::boxed::Box::new(crate::schemars08::schema::InstanceType::String))),
284                            ..Default::default()
285                        }),
286                    ),
287                ].into(),
288                required: [
289                    "status".into(),
290                    "type".into(),
291                ].into(),
292                ..Default::default()
293            })),
294            ..Default::default()
295        })
296    }
297}