1#[derive(Clone, Debug, Default, PartialEq)]
5pub struct Event {
6 pub action: Option<std::string::String>,
8
9 pub count: Option<i32>,
11
12 pub event_time: Option<crate::apimachinery::pkg::apis::meta::v1::MicroTime>,
14
15 pub first_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time>,
17
18 pub involved_object: crate::api::core::v1::ObjectReference,
20
21 pub last_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time>,
23
24 pub message: Option<std::string::String>,
26
27 pub metadata: crate::apimachinery::pkg::apis::meta::v1::ObjectMeta,
29
30 pub reason: Option<std::string::String>,
32
33 pub related: Option<crate::api::core::v1::ObjectReference>,
35
36 pub reporting_component: Option<std::string::String>,
38
39 pub reporting_instance: Option<std::string::String>,
41
42 pub series: Option<crate::api::core::v1::EventSeries>,
44
45 pub source: Option<crate::api::core::v1::EventSource>,
47
48 pub type_: Option<std::string::String>,
50}
51
52impl crate::Resource for Event {
53 const API_VERSION: &'static str = "v1";
54 const GROUP: &'static str = "";
55 const KIND: &'static str = "Event";
56 const VERSION: &'static str = "v1";
57 const URL_PATH_SEGMENT: &'static str = "events";
58 type Scope = crate::NamespaceResourceScope;
59}
60
61impl crate::ListableResource for Event {
62 const LIST_KIND: &'static str = "EventList";
63}
64
65impl crate::Metadata for Event {
66 type Ty = crate::apimachinery::pkg::apis::meta::v1::ObjectMeta;
67
68 fn metadata(&self) -> &<Self as crate::Metadata>::Ty {
69 &self.metadata
70 }
71
72 fn metadata_mut(&mut self) -> &mut<Self as crate::Metadata>::Ty {
73 &mut self.metadata
74 }
75}
76
77impl crate::DeepMerge for Event {
78 fn merge_from(&mut self, other: Self) {
79 crate::DeepMerge::merge_from(&mut self.action, other.action);
80 crate::DeepMerge::merge_from(&mut self.count, other.count);
81 crate::DeepMerge::merge_from(&mut self.event_time, other.event_time);
82 crate::DeepMerge::merge_from(&mut self.first_timestamp, other.first_timestamp);
83 crate::DeepMerge::merge_from(&mut self.involved_object, other.involved_object);
84 crate::DeepMerge::merge_from(&mut self.last_timestamp, other.last_timestamp);
85 crate::DeepMerge::merge_from(&mut self.message, other.message);
86 crate::DeepMerge::merge_from(&mut self.metadata, other.metadata);
87 crate::DeepMerge::merge_from(&mut self.reason, other.reason);
88 crate::DeepMerge::merge_from(&mut self.related, other.related);
89 crate::DeepMerge::merge_from(&mut self.reporting_component, other.reporting_component);
90 crate::DeepMerge::merge_from(&mut self.reporting_instance, other.reporting_instance);
91 crate::DeepMerge::merge_from(&mut self.series, other.series);
92 crate::DeepMerge::merge_from(&mut self.source, other.source);
93 crate::DeepMerge::merge_from(&mut self.type_, other.type_);
94 }
95}
96
97impl<'de> crate::serde::Deserialize<'de> for Event {
98 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
99 #[allow(non_camel_case_types)]
100 enum Field {
101 Key_api_version,
102 Key_kind,
103 Key_action,
104 Key_count,
105 Key_event_time,
106 Key_first_timestamp,
107 Key_involved_object,
108 Key_last_timestamp,
109 Key_message,
110 Key_metadata,
111 Key_reason,
112 Key_related,
113 Key_reporting_component,
114 Key_reporting_instance,
115 Key_series,
116 Key_source,
117 Key_type_,
118 Other,
119 }
120
121 impl<'de> crate::serde::Deserialize<'de> for Field {
122 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: crate::serde::Deserializer<'de> {
123 struct Visitor;
124
125 impl crate::serde::de::Visitor<'_> for Visitor {
126 type Value = Field;
127
128 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
129 f.write_str("field identifier")
130 }
131
132 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: crate::serde::de::Error {
133 Ok(match v {
134 "apiVersion" => Field::Key_api_version,
135 "kind" => Field::Key_kind,
136 "action" => Field::Key_action,
137 "count" => Field::Key_count,
138 "eventTime" => Field::Key_event_time,
139 "firstTimestamp" => Field::Key_first_timestamp,
140 "involvedObject" => Field::Key_involved_object,
141 "lastTimestamp" => Field::Key_last_timestamp,
142 "message" => Field::Key_message,
143 "metadata" => Field::Key_metadata,
144 "reason" => Field::Key_reason,
145 "related" => Field::Key_related,
146 "reportingComponent" => Field::Key_reporting_component,
147 "reportingInstance" => Field::Key_reporting_instance,
148 "series" => Field::Key_series,
149 "source" => Field::Key_source,
150 "type" => Field::Key_type_,
151 _ => Field::Other,
152 })
153 }
154 }
155
156 deserializer.deserialize_identifier(Visitor)
157 }
158 }
159
160 struct Visitor;
161
162 impl<'de> crate::serde::de::Visitor<'de> for Visitor {
163 type Value = Event;
164
165 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
166 f.write_str(<Self::Value as crate::Resource>::KIND)
167 }
168
169 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: crate::serde::de::MapAccess<'de> {
170 let mut value_action: Option<std::string::String> = None;
171 let mut value_count: Option<i32> = None;
172 let mut value_event_time: Option<crate::apimachinery::pkg::apis::meta::v1::MicroTime> = None;
173 let mut value_first_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time> = None;
174 let mut value_involved_object: Option<crate::api::core::v1::ObjectReference> = None;
175 let mut value_last_timestamp: Option<crate::apimachinery::pkg::apis::meta::v1::Time> = None;
176 let mut value_message: Option<std::string::String> = None;
177 let mut value_metadata: Option<crate::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
178 let mut value_reason: Option<std::string::String> = None;
179 let mut value_related: Option<crate::api::core::v1::ObjectReference> = None;
180 let mut value_reporting_component: Option<std::string::String> = None;
181 let mut value_reporting_instance: Option<std::string::String> = None;
182 let mut value_series: Option<crate::api::core::v1::EventSeries> = None;
183 let mut value_source: Option<crate::api::core::v1::EventSource> = None;
184 let mut value_type_: Option<std::string::String> = None;
185
186 while let Some(key) = crate::serde::de::MapAccess::next_key::<Field>(&mut map)? {
187 match key {
188 Field::Key_api_version => {
189 let value_api_version: std::string::String = crate::serde::de::MapAccess::next_value(&mut map)?;
190 if value_api_version != <Self::Value as crate::Resource>::API_VERSION {
191 return Err(crate::serde::de::Error::invalid_value(crate::serde::de::Unexpected::Str(&value_api_version), &<Self::Value as crate::Resource>::API_VERSION));
192 }
193 },
194 Field::Key_kind => {
195 let value_kind: std::string::String = crate::serde::de::MapAccess::next_value(&mut map)?;
196 if value_kind != <Self::Value as crate::Resource>::KIND {
197 return Err(crate::serde::de::Error::invalid_value(crate::serde::de::Unexpected::Str(&value_kind), &<Self::Value as crate::Resource>::KIND));
198 }
199 },
200 Field::Key_action => value_action = crate::serde::de::MapAccess::next_value(&mut map)?,
201 Field::Key_count => value_count = crate::serde::de::MapAccess::next_value(&mut map)?,
202 Field::Key_event_time => value_event_time = crate::serde::de::MapAccess::next_value(&mut map)?,
203 Field::Key_first_timestamp => value_first_timestamp = crate::serde::de::MapAccess::next_value(&mut map)?,
204 Field::Key_involved_object => value_involved_object = crate::serde::de::MapAccess::next_value(&mut map)?,
205 Field::Key_last_timestamp => value_last_timestamp = crate::serde::de::MapAccess::next_value(&mut map)?,
206 Field::Key_message => value_message = crate::serde::de::MapAccess::next_value(&mut map)?,
207 Field::Key_metadata => value_metadata = crate::serde::de::MapAccess::next_value(&mut map)?,
208 Field::Key_reason => value_reason = crate::serde::de::MapAccess::next_value(&mut map)?,
209 Field::Key_related => value_related = crate::serde::de::MapAccess::next_value(&mut map)?,
210 Field::Key_reporting_component => value_reporting_component = crate::serde::de::MapAccess::next_value(&mut map)?,
211 Field::Key_reporting_instance => value_reporting_instance = crate::serde::de::MapAccess::next_value(&mut map)?,
212 Field::Key_series => value_series = crate::serde::de::MapAccess::next_value(&mut map)?,
213 Field::Key_source => value_source = crate::serde::de::MapAccess::next_value(&mut map)?,
214 Field::Key_type_ => value_type_ = crate::serde::de::MapAccess::next_value(&mut map)?,
215 Field::Other => { let _: crate::serde::de::IgnoredAny = crate::serde::de::MapAccess::next_value(&mut map)?; },
216 }
217 }
218
219 Ok(Event {
220 action: value_action,
221 count: value_count,
222 event_time: value_event_time,
223 first_timestamp: value_first_timestamp,
224 involved_object: value_involved_object.unwrap_or_default(),
225 last_timestamp: value_last_timestamp,
226 message: value_message,
227 metadata: value_metadata.unwrap_or_default(),
228 reason: value_reason,
229 related: value_related,
230 reporting_component: value_reporting_component,
231 reporting_instance: value_reporting_instance,
232 series: value_series,
233 source: value_source,
234 type_: value_type_,
235 })
236 }
237 }
238
239 deserializer.deserialize_struct(
240 <Self as crate::Resource>::KIND,
241 &[
242 "apiVersion",
243 "kind",
244 "action",
245 "count",
246 "eventTime",
247 "firstTimestamp",
248 "involvedObject",
249 "lastTimestamp",
250 "message",
251 "metadata",
252 "reason",
253 "related",
254 "reportingComponent",
255 "reportingInstance",
256 "series",
257 "source",
258 "type",
259 ],
260 Visitor,
261 )
262 }
263}
264
265impl crate::serde::Serialize for Event {
266 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: crate::serde::Serializer {
267 let mut state = serializer.serialize_struct(
268 <Self as crate::Resource>::KIND,
269 4 +
270 self.action.as_ref().map_or(0, |_| 1) +
271 self.count.as_ref().map_or(0, |_| 1) +
272 self.event_time.as_ref().map_or(0, |_| 1) +
273 self.first_timestamp.as_ref().map_or(0, |_| 1) +
274 self.last_timestamp.as_ref().map_or(0, |_| 1) +
275 self.message.as_ref().map_or(0, |_| 1) +
276 self.reason.as_ref().map_or(0, |_| 1) +
277 self.related.as_ref().map_or(0, |_| 1) +
278 self.reporting_component.as_ref().map_or(0, |_| 1) +
279 self.reporting_instance.as_ref().map_or(0, |_| 1) +
280 self.series.as_ref().map_or(0, |_| 1) +
281 self.source.as_ref().map_or(0, |_| 1) +
282 self.type_.as_ref().map_or(0, |_| 1),
283 )?;
284 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as crate::Resource>::API_VERSION)?;
285 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as crate::Resource>::KIND)?;
286 if let Some(value) = &self.action {
287 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "action", value)?;
288 }
289 if let Some(value) = &self.count {
290 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "count", value)?;
291 }
292 if let Some(value) = &self.event_time {
293 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "eventTime", value)?;
294 }
295 if let Some(value) = &self.first_timestamp {
296 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "firstTimestamp", value)?;
297 }
298 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "involvedObject", &self.involved_object)?;
299 if let Some(value) = &self.last_timestamp {
300 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "lastTimestamp", value)?;
301 }
302 if let Some(value) = &self.message {
303 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "message", value)?;
304 }
305 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
306 if let Some(value) = &self.reason {
307 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "reason", value)?;
308 }
309 if let Some(value) = &self.related {
310 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "related", value)?;
311 }
312 if let Some(value) = &self.reporting_component {
313 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "reportingComponent", value)?;
314 }
315 if let Some(value) = &self.reporting_instance {
316 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "reportingInstance", value)?;
317 }
318 if let Some(value) = &self.series {
319 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "series", value)?;
320 }
321 if let Some(value) = &self.source {
322 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "source", value)?;
323 }
324 if let Some(value) = &self.type_ {
325 crate::serde::ser::SerializeStruct::serialize_field(&mut state, "type", value)?;
326 }
327 crate::serde::ser::SerializeStruct::end(state)
328 }
329}
330
331#[cfg(feature = "schemars")]
332impl crate::schemars::JsonSchema for Event {
333 fn schema_name() -> std::borrow::Cow<'static, str> {
334 "io.k8s.api.core.v1.Event".into()
335 }
336
337 fn json_schema(__gen: &mut crate::schemars::SchemaGenerator) -> crate::schemars::Schema {
338 crate::schemars::json_schema!({
339 "description": "Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.",
340 "type": "object",
341 "properties": {
342 "action": {
343 "description": "What action was taken/failed regarding to the Regarding object.",
344 "type": "string",
345 },
346 "apiVersion": {
347 "description": "APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources",
348 "type": "string",
349 },
350 "count": {
351 "description": "The number of times this event has occurred.",
352 "type": "integer",
353 "format": "int32",
354 },
355 "eventTime": ({
356 let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::MicroTime>();
357 schema_obj.ensure_object().insert("description".into(), "Time when this Event was first observed.".into());
358 schema_obj
359 }),
360 "firstTimestamp": ({
361 let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::Time>();
362 schema_obj.ensure_object().insert("description".into(), "The time at which the event was first recorded. (Time of server receipt is in TypeMeta.)".into());
363 schema_obj
364 }),
365 "involvedObject": ({
366 let mut schema_obj = __gen.subschema_for::<crate::api::core::v1::ObjectReference>();
367 schema_obj.ensure_object().insert("description".into(), "The object that this event is about.".into());
368 schema_obj
369 }),
370 "kind": {
371 "description": "Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
372 "type": "string",
373 },
374 "lastTimestamp": ({
375 let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::Time>();
376 schema_obj.ensure_object().insert("description".into(), "The time at which the most recent occurrence of this event was recorded.".into());
377 schema_obj
378 }),
379 "message": {
380 "description": "A human-readable description of the status of this operation.",
381 "type": "string",
382 },
383 "metadata": ({
384 let mut schema_obj = __gen.subschema_for::<crate::apimachinery::pkg::apis::meta::v1::ObjectMeta>();
385 schema_obj.ensure_object().insert("description".into(), "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata".into());
386 schema_obj
387 }),
388 "reason": {
389 "description": "This should be a short, machine understandable string that gives the reason for the transition into the object's current status.",
390 "type": "string",
391 },
392 "related": ({
393 let mut schema_obj = __gen.subschema_for::<crate::api::core::v1::ObjectReference>();
394 schema_obj.ensure_object().insert("description".into(), "Optional secondary object for more complex actions.".into());
395 schema_obj
396 }),
397 "reportingComponent": {
398 "description": "Name of the controller that emitted this Event, e.g. `kubernetes.io/kubelet`.",
399 "type": "string",
400 },
401 "reportingInstance": {
402 "description": "ID of the controller instance, e.g. `kubelet-xyzf`.",
403 "type": "string",
404 },
405 "series": ({
406 let mut schema_obj = __gen.subschema_for::<crate::api::core::v1::EventSeries>();
407 schema_obj.ensure_object().insert("description".into(), "Data about the Event series this event represents or nil if it's a singleton Event.".into());
408 schema_obj
409 }),
410 "source": ({
411 let mut schema_obj = __gen.subschema_for::<crate::api::core::v1::EventSource>();
412 schema_obj.ensure_object().insert("description".into(), "The component reporting this event. Should be a short machine understandable string.".into());
413 schema_obj
414 }),
415 "type": {
416 "description": "Type of this event (Normal, Warning), new types could be added in the future",
417 "type": "string",
418 },
419 },
420 "required": [
421 "involvedObject",
422 "metadata",
423 ],
424 })
425 }
426}