1#[derive(Clone, Debug, Default, PartialEq)]
5pub struct PodStatus {
6 pub conditions: Option<std::vec::Vec<crate::api::core::v1::PodCondition>>,
8
9 pub container_statuses: Option<std::vec::Vec<crate::api::core::v1::ContainerStatus>>,
11
12 pub ephemeral_container_statuses: Option<std::vec::Vec<crate::api::core::v1::ContainerStatus>>,
14
15 pub host_ip: Option<std::string::String>,
17
18 pub host_ips: Option<std::vec::Vec<crate::api::core::v1::HostIP>>,
20
21 pub init_container_statuses: Option<std::vec::Vec<crate::api::core::v1::ContainerStatus>>,
23
24 pub message: Option<std::string::String>,
26
27 pub nominated_node_name: Option<std::string::String>,
29
30 pub phase: Option<std::string::String>,
36
37 pub pod_ip: Option<std::string::String>,
39
40 pub pod_ips: Option<std::vec::Vec<crate::api::core::v1::PodIP>>,
42
43 pub qos_class: Option<std::string::String>,
45
46 pub reason: Option<std::string::String>,
48
49 pub resize: Option<std::string::String>,
51
52 pub resource_claim_statuses: Option<std::vec::Vec<crate::api::core::v1::PodResourceClaimStatus>>,
54
55 pub start_time: Option<crate::apimachinery::pkg::apis::meta::v1::Time>,
57}
58
59impl crate::DeepMerge for PodStatus {
60 fn merge_from(&mut self, other: Self) {
61 crate::merge_strategies::list::map(
62 &mut self.conditions,
63 other.conditions,
64 &[|lhs, rhs| lhs.type_ == rhs.type_],
65 |current_item, other_item| {
66 crate::DeepMerge::merge_from(current_item, other_item);
67 },
68 );
69 crate::merge_strategies::list::atomic(&mut self.container_statuses, other.container_statuses);
70 crate::merge_strategies::list::atomic(&mut self.ephemeral_container_statuses, other.ephemeral_container_statuses);
71 crate::DeepMerge::merge_from(&mut self.host_ip, other.host_ip);
72 crate::merge_strategies::list::map(
73 &mut self.host_ips,
74 other.host_ips,
75 &[|lhs, rhs| lhs.ip == rhs.ip],
76 |current_item, other_item| {
77 crate::DeepMerge::merge_from(current_item, other_item);
78 },
79 );
80 crate::merge_strategies::list::atomic(&mut self.init_container_statuses, other.init_container_statuses);
81 crate::DeepMerge::merge_from(&mut self.message, other.message);
82 crate::DeepMerge::merge_from(&mut self.nominated_node_name, other.nominated_node_name);
83 crate::DeepMerge::merge_from(&mut self.phase, other.phase);
84 crate::DeepMerge::merge_from(&mut self.pod_ip, other.pod_ip);
85 crate::merge_strategies::list::map(
86 &mut self.pod_ips,
87 other.pod_ips,
88 &[|lhs, rhs| lhs.ip == rhs.ip],
89 |current_item, other_item| {
90 crate::DeepMerge::merge_from(current_item, other_item);
91 },
92 );
93 crate::DeepMerge::merge_from(&mut self.qos_class, other.qos_class);
94 crate::DeepMerge::merge_from(&mut self.reason, other.reason);
95 crate::DeepMerge::merge_from(&mut self.resize, other.resize);
96 crate::merge_strategies::list::map(
97 &mut self.resource_claim_statuses,
98 other.resource_claim_statuses,
99 &[|lhs, rhs| lhs.name == rhs.name],
100 |current_item, other_item| {
101 crate::DeepMerge::merge_from(current_item, other_item);
102 },
103 );
104 crate::DeepMerge::merge_from(&mut self.start_time, other.start_time);
105 }
106}
107
108impl<'de> crate::serde::Deserialize<'de> for PodStatus {
109 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
110 #[allow(non_camel_case_types)]
111 enum Field {
112 Key_conditions,
113 Key_container_statuses,
114 Key_ephemeral_container_statuses,
115 Key_host_ip,
116 Key_host_ips,
117 Key_init_container_statuses,
118 Key_message,
119 Key_nominated_node_name,
120 Key_phase,
121 Key_pod_ip,
122 Key_pod_ips,
123 Key_qos_class,
124 Key_reason,
125 Key_resize,
126 Key_resource_claim_statuses,
127 Key_start_time,
128 Other,
129 }
130
131 impl<'de> crate::serde::Deserialize<'de> for Field {
132 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
133 struct Visitor;
134
135 impl crate::serde::de::Visitor<'_> for Visitor {
136 type Value = Field;
137
138 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
139 f.write_str("field identifier")
140 }
141
142 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
143 Ok(match v {
144 "conditions" => Field::Key_conditions,
145 "containerStatuses" => Field::Key_container_statuses,
146 "ephemeralContainerStatuses" => Field::Key_ephemeral_container_statuses,
147 "hostIP" => Field::Key_host_ip,
148 "hostIPs" => Field::Key_host_ips,
149 "initContainerStatuses" => Field::Key_init_container_statuses,
150 "message" => Field::Key_message,
151 "nominatedNodeName" => Field::Key_nominated_node_name,
152 "phase" => Field::Key_phase,
153 "podIP" => Field::Key_pod_ip,
154 "podIPs" => Field::Key_pod_ips,
155 "qosClass" => Field::Key_qos_class,
156 "reason" => Field::Key_reason,
157 "resize" => Field::Key_resize,
158 "resourceClaimStatuses" => Field::Key_resource_claim_statuses,
159 "startTime" => Field::Key_start_time,
160 _ => Field::Other,
161 })
162 }
163 }
164
165 deserializer.deserialize_identifier(Visitor)
166 }
167 }
168
169 struct Visitor;
170
171 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
172 type Value = PodStatus;
173
174 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
175 f.write_str("PodStatus")
176 }
177
178 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
179 let mut value_conditions: Option<std::vec::Vec<crate::api::core::v1::PodCondition>> = None;
180 let mut value_container_statuses: Option<std::vec::Vec<crate::api::core::v1::ContainerStatus>> = None;
181 let mut value_ephemeral_container_statuses: Option<std::vec::Vec<crate::api::core::v1::ContainerStatus>> = None;
182 let mut value_host_ip: Option<std::string::String> = None;
183 let mut value_host_ips: Option<std::vec::Vec<crate::api::core::v1::HostIP>> = None;
184 let mut value_init_container_statuses: Option<std::vec::Vec<crate::api::core::v1::ContainerStatus>> = None;
185 let mut value_message: Option<std::string::String> = None;
186 let mut value_nominated_node_name: Option<std::string::String> = None;
187 let mut value_phase: Option<std::string::String> = None;
188 let mut value_pod_ip: Option<std::string::String> = None;
189 let mut value_pod_ips: Option<std::vec::Vec<crate::api::core::v1::PodIP>> = None;
190 let mut value_qos_class: Option<std::string::String> = None;
191 let mut value_reason: Option<std::string::String> = None;
192 let mut value_resize: Option<std::string::String> = None;
193 let mut value_resource_claim_statuses: Option<std::vec::Vec<crate::api::core::v1::PodResourceClaimStatus>> = None;
194 let mut value_start_time: Option<crate::apimachinery::pkg::apis::meta::v1::Time> = None;
195
196 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
197 match key {
198 Field::Key_conditions => value_conditions = crate::serde::de::MapAccess::next_value(&mut map)?,
199 Field::Key_container_statuses => value_container_statuses = crate::serde::de::MapAccess::next_value(&mut map)?,
200 Field::Key_ephemeral_container_statuses => value_ephemeral_container_statuses = crate::serde::de::MapAccess::next_value(&mut map)?,
201 Field::Key_host_ip => value_host_ip = crate::serde::de::MapAccess::next_value(&mut map)?,
202 Field::Key_host_ips => value_host_ips = crate::serde::de::MapAccess::next_value(&mut map)?,
203 Field::Key_init_container_statuses => value_init_container_statuses = crate::serde::de::MapAccess::next_value(&mut map)?,
204 Field::Key_message => value_message = crate::serde::de::MapAccess::next_value(&mut map)?,
205 Field::Key_nominated_node_name => value_nominated_node_name = crate::serde::de::MapAccess::next_value(&mut map)?,
206 Field::Key_phase => value_phase = crate::serde::de::MapAccess::next_value(&mut map)?,
207 Field::Key_pod_ip => value_pod_ip = crate::serde::de::MapAccess::next_value(&mut map)?,
208 Field::Key_pod_ips => value_pod_ips = crate::serde::de::MapAccess::next_value(&mut map)?,
209 Field::Key_qos_class => value_qos_class = crate::serde::de::MapAccess::next_value(&mut map)?,
210 Field::Key_reason => value_reason = crate::serde::de::MapAccess::next_value(&mut map)?,
211 Field::Key_resize => value_resize = crate::serde::de::MapAccess::next_value(&mut map)?,
212 Field::Key_resource_claim_statuses => value_resource_claim_statuses = crate::serde::de::MapAccess::next_value(&mut map)?,
213 Field::Key_start_time => value_start_time = crate::serde::de::MapAccess::next_value(&mut map)?,
214 Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
215 }
216 }
217
218 Ok(PodStatus {
219 conditions: value_conditions,
220 container_statuses: value_container_statuses,
221 ephemeral_container_statuses: value_ephemeral_container_statuses,
222 host_ip: value_host_ip,
223 host_ips: value_host_ips,
224 init_container_statuses: value_init_container_statuses,
225 message: value_message,
226 nominated_node_name: value_nominated_node_name,
227 phase: value_phase,
228 pod_ip: value_pod_ip,
229 pod_ips: value_pod_ips,
230 qos_class: value_qos_class,
231 reason: value_reason,
232 resize: value_resize,
233 resource_claim_statuses: value_resource_claim_statuses,
234 start_time: value_start_time,
235 })
236 }
237 }
238
239 deserializer.deserialize_struct(
240 "PodStatus",
241 &[
242 "conditions",
243 "containerStatuses",
244 "ephemeralContainerStatuses",
245 "hostIP",
246 "hostIPs",
247 "initContainerStatuses",
248 "message",
249 "nominatedNodeName",
250 "phase",
251 "podIP",
252 "podIPs",
253 "qosClass",
254 "reason",
255 "resize",
256 "resourceClaimStatuses",
257 "startTime",
258 ],
259 Visitor,
260 )
261 }
262}
263
264impl crate::serde::Serialize for PodStatus {
265 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
266 let mut state = serializer.serialize_struct(
267 "PodStatus",
268 self.conditions.as_ref().map_or(0, |_| 1) +
269 self.container_statuses.as_ref().map_or(0, |_| 1) +
270 self.ephemeral_container_statuses.as_ref().map_or(0, |_| 1) +
271 self.host_ip.as_ref().map_or(0, |_| 1) +
272 self.host_ips.as_ref().map_or(0, |_| 1) +
273 self.init_container_statuses.as_ref().map_or(0, |_| 1) +
274 self.message.as_ref().map_or(0, |_| 1) +
275 self.nominated_node_name.as_ref().map_or(0, |_| 1) +
276 self.phase.as_ref().map_or(0, |_| 1) +
277 self.pod_ip.as_ref().map_or(0, |_| 1) +
278 self.pod_ips.as_ref().map_or(0, |_| 1) +
279 self.qos_class.as_ref().map_or(0, |_| 1) +
280 self.reason.as_ref().map_or(0, |_| 1) +
281 self.resize.as_ref().map_or(0, |_| 1) +
282 self.resource_claim_statuses.as_ref().map_or(0, |_| 1) +
283 self.start_time.as_ref().map_or(0, |_| 1),
284 )?;
285 if let Some(value) = &self.conditions {
286 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "conditions", value)?;
287 }
288 if let Some(value) = &self.container_statuses {
289 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "containerStatuses", value)?;
290 }
291 if let Some(value) = &self.ephemeral_container_statuses {
292 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "ephemeralContainerStatuses", value)?;
293 }
294 if let Some(value) = &self.host_ip {
295 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "hostIP", value)?;
296 }
297 if let Some(value) = &self.host_ips {
298 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "hostIPs", value)?;
299 }
300 if let Some(value) = &self.init_container_statuses {
301 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "initContainerStatuses", value)?;
302 }
303 if let Some(value) = &self.message {
304 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "message", value)?;
305 }
306 if let Some(value) = &self.nominated_node_name {
307 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "nominatedNodeName", value)?;
308 }
309 if let Some(value) = &self.phase {
310 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "phase", value)?;
311 }
312 if let Some(value) = &self.pod_ip {
313 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "podIP", value)?;
314 }
315 if let Some(value) = &self.pod_ips {
316 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "podIPs", value)?;
317 }
318 if let Some(value) = &self.qos_class {
319 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "qosClass", value)?;
320 }
321 if let Some(value) = &self.reason {
322 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "reason", value)?;
323 }
324 if let Some(value) = &self.resize {
325 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "resize", value)?;
326 }
327 if let Some(value) = &self.resource_claim_statuses {
328 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "resourceClaimStatuses", value)?;
329 }
330 if let Some(value) = &self.start_time {
331 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "startTime", value)?;
332 }
333 crate::serde::ser::SerializeStruct::end(state)
334 }
335}
336
337#[cfg(feature = "schemars")]
338impl crate::schemars::JsonSchema for PodStatus {
339 fn schema_name() -> std::borrow::Cow<'static, str> {
340 "io.k8s.api.core.v1.PodStatus".into()
341 }
342
343 fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
344 crate::schemars::json_schema!({
345 "description": "PodStatus represents information about the status of a pod. Status may trail the actual state of a system, especially if the node that hosts the pod cannot contact the control plane.",
346 "type": "object",
347 "properties": {
348 "conditions": {
349 "description": "Current service state of pod. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-conditions",
350 "type": "array",
351 "items": (__gen.subschema_for::<crate::api::core::v1::PodCondition>()),
352 },
353 "containerStatuses": {
354 "description": "The list has one entry per container in the manifest. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status",
355 "type": "array",
356 "items": (__gen.subschema_for::<crate::api::core::v1::ContainerStatus>()),
357 },
358 "ephemeralContainerStatuses": {
359 "description": "Status for any ephemeral containers that have run in this pod.",
360 "type": "array",
361 "items": (__gen.subschema_for::<crate::api::core::v1::ContainerStatus>()),
362 },
363 "hostIP": {
364 "description": "hostIP holds the IP address of the host to which the pod is assigned. Empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns mean that HostIP will not be updated even if there is a node is assigned to pod",
365 "type": "string",
366 },
367 "hostIPs": {
368 "description": "hostIPs holds the IP addresses allocated to the host. If this field is specified, the first entry must match the hostIP field. This list is empty if the pod has not started yet. A pod can be assigned to a node that has a problem in kubelet which in turns means that HostIPs will not be updated even if there is a node is assigned to this pod.",
369 "type": "array",
370 "items": (__gen.subschema_for::<crate::api::core::v1::HostIP>()),
371 },
372 "initContainerStatuses": {
373 "description": "The list has one entry per init container in the manifest. The most recent successful init container will have ready = true, the most recently started container will have startTime set. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-and-container-status",
374 "type": "array",
375 "items": (__gen.subschema_for::<crate::api::core::v1::ContainerStatus>()),
376 },
377 "message": {
378 "description": "A human readable message indicating details about why the pod is in this condition.",
379 "type": "string",
380 },
381 "nominatedNodeName": {
382 "description": "nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled.",
383 "type": "string",
384 },
385 "phase": {
386 "description": "The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values:\n\nPending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod.\n\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#pod-phase",
387 "type": "string",
388 },
389 "podIP": {
390 "description": "podIP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.",
391 "type": "string",
392 },
393 "podIPs": {
394 "description": "podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet.",
395 "type": "array",
396 "items": (__gen.subschema_for::<crate::api::core::v1::PodIP>()),
397 },
398 "qosClass": {
399 "description": "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-qos/#quality-of-service-classes",
400 "type": "string",
401 },
402 "reason": {
403 "description": "A brief CamelCase message indicating details about why the pod is in this state. e.g. 'Evicted'",
404 "type": "string",
405 },
406 "resize": {
407 "description": "Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to \"Proposed\"",
408 "type": "string",
409 },
410 "resourceClaimStatuses": {
411 "description": "Status of resource claims.",
412 "type": "array",
413 "items": (__gen.subschema_for::<crate::api::core::v1::PodResourceClaimStatus>()),
414 },
415 "startTime": ({
416 let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::Time>();
417 schema_obj.ensure_object().insert("description".into(), "RFC 3339 date and time at which the object was acknowledged by the Kubelet. This is before the Kubelet pulled the container image(s) for the pod.".into());
418 schema_obj
419 }),
420 },
421 })
422 }
423}