1use crate::telemetry::*;
2impl serde::Serialize for BatchEventMessage {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if !self.events.is_empty() {
11 len += 1;
12 }
13 let mut struct_ser = serializer.serialize_struct("telemetry.BatchEventMessage", len)?;
14 if !self.events.is_empty() {
15 struct_ser.serialize_field("events", &self.events)?;
16 }
17 struct_ser.end()
18 }
19}
20impl<'de> serde::Deserialize<'de> for BatchEventMessage {
21 #[allow(deprecated)]
22 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
23 where
24 D: serde::Deserializer<'de>,
25 {
26 const FIELDS: &[&str] = &[
27 "events",
28 ];
29
30 #[allow(clippy::enum_variant_names)]
31 enum GeneratedField {
32 Events,
33 }
34 impl<'de> serde::Deserialize<'de> for GeneratedField {
35 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
36 where
37 D: serde::Deserializer<'de>,
38 {
39 struct GeneratedVisitor;
40
41 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
42 type Value = GeneratedField;
43
44 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
45 write!(formatter, "expected one of: {:?}", &FIELDS)
46 }
47
48 #[allow(unused_variables)]
49 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
50 where
51 E: serde::de::Error,
52 {
53 match value {
54 "events" => Ok(GeneratedField::Events),
55 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
56 }
57 }
58 }
59 deserializer.deserialize_identifier(GeneratedVisitor)
60 }
61 }
62 struct GeneratedVisitor;
63 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
64 type Value = BatchEventMessage;
65
66 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
67 formatter.write_str("struct telemetry.BatchEventMessage")
68 }
69
70 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchEventMessage, V::Error>
71 where
72 V: serde::de::MapAccess<'de>,
73 {
74 let mut events__ = None;
75 while let Some(k) = map_.next_key()? {
76 match k {
77 GeneratedField::Events => {
78 if events__.is_some() {
79 return Err(serde::de::Error::duplicate_field("events"));
80 }
81 events__ = Some(map_.next_value()?);
82 }
83 }
84 }
85 Ok(BatchEventMessage {
86 events: events__.unwrap_or_default(),
87 })
88 }
89 }
90 deserializer.deserialize_struct("telemetry.BatchEventMessage", FIELDS, GeneratedVisitor)
91 }
92}
93impl serde::Serialize for CompactorReport {
94 #[allow(deprecated)]
95 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
96 where
97 S: serde::Serializer,
98 {
99 use serde::ser::SerializeStruct;
100 let mut len = 0;
101 if self.base.is_some() {
102 len += 1;
103 }
104 let mut struct_ser = serializer.serialize_struct("telemetry.CompactorReport", len)?;
105 if let Some(v) = self.base.as_ref() {
106 struct_ser.serialize_field("base", v)?;
107 }
108 struct_ser.end()
109 }
110}
111impl<'de> serde::Deserialize<'de> for CompactorReport {
112 #[allow(deprecated)]
113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
114 where
115 D: serde::Deserializer<'de>,
116 {
117 const FIELDS: &[&str] = &[
118 "base",
119 ];
120
121 #[allow(clippy::enum_variant_names)]
122 enum GeneratedField {
123 Base,
124 }
125 impl<'de> serde::Deserialize<'de> for GeneratedField {
126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
127 where
128 D: serde::Deserializer<'de>,
129 {
130 struct GeneratedVisitor;
131
132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
133 type Value = GeneratedField;
134
135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
136 write!(formatter, "expected one of: {:?}", &FIELDS)
137 }
138
139 #[allow(unused_variables)]
140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
141 where
142 E: serde::de::Error,
143 {
144 match value {
145 "base" => Ok(GeneratedField::Base),
146 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
147 }
148 }
149 }
150 deserializer.deserialize_identifier(GeneratedVisitor)
151 }
152 }
153 struct GeneratedVisitor;
154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
155 type Value = CompactorReport;
156
157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158 formatter.write_str("struct telemetry.CompactorReport")
159 }
160
161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactorReport, V::Error>
162 where
163 V: serde::de::MapAccess<'de>,
164 {
165 let mut base__ = None;
166 while let Some(k) = map_.next_key()? {
167 match k {
168 GeneratedField::Base => {
169 if base__.is_some() {
170 return Err(serde::de::Error::duplicate_field("base"));
171 }
172 base__ = map_.next_value()?;
173 }
174 }
175 }
176 Ok(CompactorReport {
177 base: base__,
178 })
179 }
180 }
181 deserializer.deserialize_struct("telemetry.CompactorReport", FIELDS, GeneratedVisitor)
182 }
183}
184impl serde::Serialize for ComputeReport {
185 #[allow(deprecated)]
186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
187 where
188 S: serde::Serializer,
189 {
190 use serde::ser::SerializeStruct;
191 let mut len = 0;
192 if self.base.is_some() {
193 len += 1;
194 }
195 let mut struct_ser = serializer.serialize_struct("telemetry.ComputeReport", len)?;
196 if let Some(v) = self.base.as_ref() {
197 struct_ser.serialize_field("base", v)?;
198 }
199 struct_ser.end()
200 }
201}
202impl<'de> serde::Deserialize<'de> for ComputeReport {
203 #[allow(deprecated)]
204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
205 where
206 D: serde::Deserializer<'de>,
207 {
208 const FIELDS: &[&str] = &[
209 "base",
210 ];
211
212 #[allow(clippy::enum_variant_names)]
213 enum GeneratedField {
214 Base,
215 }
216 impl<'de> serde::Deserialize<'de> for GeneratedField {
217 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
218 where
219 D: serde::Deserializer<'de>,
220 {
221 struct GeneratedVisitor;
222
223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
224 type Value = GeneratedField;
225
226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
227 write!(formatter, "expected one of: {:?}", &FIELDS)
228 }
229
230 #[allow(unused_variables)]
231 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
232 where
233 E: serde::de::Error,
234 {
235 match value {
236 "base" => Ok(GeneratedField::Base),
237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
238 }
239 }
240 }
241 deserializer.deserialize_identifier(GeneratedVisitor)
242 }
243 }
244 struct GeneratedVisitor;
245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
246 type Value = ComputeReport;
247
248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
249 formatter.write_str("struct telemetry.ComputeReport")
250 }
251
252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ComputeReport, V::Error>
253 where
254 V: serde::de::MapAccess<'de>,
255 {
256 let mut base__ = None;
257 while let Some(k) = map_.next_key()? {
258 match k {
259 GeneratedField::Base => {
260 if base__.is_some() {
261 return Err(serde::de::Error::duplicate_field("base"));
262 }
263 base__ = map_.next_value()?;
264 }
265 }
266 }
267 Ok(ComputeReport {
268 base: base__,
269 })
270 }
271 }
272 deserializer.deserialize_struct("telemetry.ComputeReport", FIELDS, GeneratedVisitor)
273 }
274}
275impl serde::Serialize for EventMessage {
276 #[allow(deprecated)]
277 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
278 where
279 S: serde::Serializer,
280 {
281 use serde::ser::SerializeStruct;
282 let mut len = 0;
283 if !self.tracking_id.is_empty() {
284 len += 1;
285 }
286 if self.event_time_sec != 0 {
287 len += 1;
288 }
289 if self.event_stage != 0 {
290 len += 1;
291 }
292 if !self.event_name.is_empty() {
293 len += 1;
294 }
295 if self.connector_name.is_some() {
296 len += 1;
297 }
298 if self.object.is_some() {
299 len += 1;
300 }
301 if self.catalog_id != 0 {
302 len += 1;
303 }
304 if self.attributes.is_some() {
305 len += 1;
306 }
307 if !self.node.is_empty() {
308 len += 1;
309 }
310 if self.is_test {
311 len += 1;
312 }
313 let mut struct_ser = serializer.serialize_struct("telemetry.EventMessage", len)?;
314 if !self.tracking_id.is_empty() {
315 struct_ser.serialize_field("trackingId", &self.tracking_id)?;
316 }
317 if self.event_time_sec != 0 {
318 #[allow(clippy::needless_borrow)]
319 #[allow(clippy::needless_borrows_for_generic_args)]
320 struct_ser.serialize_field("eventTimeSec", ToString::to_string(&self.event_time_sec).as_str())?;
321 }
322 if self.event_stage != 0 {
323 let v = TelemetryEventStage::try_from(self.event_stage)
324 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.event_stage)))?;
325 struct_ser.serialize_field("eventStage", &v)?;
326 }
327 if !self.event_name.is_empty() {
328 struct_ser.serialize_field("eventName", &self.event_name)?;
329 }
330 if let Some(v) = self.connector_name.as_ref() {
331 struct_ser.serialize_field("connectorName", v)?;
332 }
333 if let Some(v) = self.object.as_ref() {
334 let v = TelemetryDatabaseObject::try_from(*v)
335 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
336 struct_ser.serialize_field("object", &v)?;
337 }
338 if self.catalog_id != 0 {
339 #[allow(clippy::needless_borrow)]
340 #[allow(clippy::needless_borrows_for_generic_args)]
341 struct_ser.serialize_field("catalogId", ToString::to_string(&self.catalog_id).as_str())?;
342 }
343 if let Some(v) = self.attributes.as_ref() {
344 struct_ser.serialize_field("attributes", v)?;
345 }
346 if !self.node.is_empty() {
347 struct_ser.serialize_field("node", &self.node)?;
348 }
349 if self.is_test {
350 struct_ser.serialize_field("isTest", &self.is_test)?;
351 }
352 struct_ser.end()
353 }
354}
355impl<'de> serde::Deserialize<'de> for EventMessage {
356 #[allow(deprecated)]
357 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
358 where
359 D: serde::Deserializer<'de>,
360 {
361 const FIELDS: &[&str] = &[
362 "tracking_id",
363 "trackingId",
364 "event_time_sec",
365 "eventTimeSec",
366 "event_stage",
367 "eventStage",
368 "event_name",
369 "eventName",
370 "connector_name",
371 "connectorName",
372 "object",
373 "catalog_id",
374 "catalogId",
375 "attributes",
376 "node",
377 "is_test",
378 "isTest",
379 ];
380
381 #[allow(clippy::enum_variant_names)]
382 enum GeneratedField {
383 TrackingId,
384 EventTimeSec,
385 EventStage,
386 EventName,
387 ConnectorName,
388 Object,
389 CatalogId,
390 Attributes,
391 Node,
392 IsTest,
393 }
394 impl<'de> serde::Deserialize<'de> for GeneratedField {
395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
396 where
397 D: serde::Deserializer<'de>,
398 {
399 struct GeneratedVisitor;
400
401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
402 type Value = GeneratedField;
403
404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
405 write!(formatter, "expected one of: {:?}", &FIELDS)
406 }
407
408 #[allow(unused_variables)]
409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
410 where
411 E: serde::de::Error,
412 {
413 match value {
414 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
415 "eventTimeSec" | "event_time_sec" => Ok(GeneratedField::EventTimeSec),
416 "eventStage" | "event_stage" => Ok(GeneratedField::EventStage),
417 "eventName" | "event_name" => Ok(GeneratedField::EventName),
418 "connectorName" | "connector_name" => Ok(GeneratedField::ConnectorName),
419 "object" => Ok(GeneratedField::Object),
420 "catalogId" | "catalog_id" => Ok(GeneratedField::CatalogId),
421 "attributes" => Ok(GeneratedField::Attributes),
422 "node" => Ok(GeneratedField::Node),
423 "isTest" | "is_test" => Ok(GeneratedField::IsTest),
424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
425 }
426 }
427 }
428 deserializer.deserialize_identifier(GeneratedVisitor)
429 }
430 }
431 struct GeneratedVisitor;
432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
433 type Value = EventMessage;
434
435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
436 formatter.write_str("struct telemetry.EventMessage")
437 }
438
439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventMessage, V::Error>
440 where
441 V: serde::de::MapAccess<'de>,
442 {
443 let mut tracking_id__ = None;
444 let mut event_time_sec__ = None;
445 let mut event_stage__ = None;
446 let mut event_name__ = None;
447 let mut connector_name__ = None;
448 let mut object__ = None;
449 let mut catalog_id__ = None;
450 let mut attributes__ = None;
451 let mut node__ = None;
452 let mut is_test__ = None;
453 while let Some(k) = map_.next_key()? {
454 match k {
455 GeneratedField::TrackingId => {
456 if tracking_id__.is_some() {
457 return Err(serde::de::Error::duplicate_field("trackingId"));
458 }
459 tracking_id__ = Some(map_.next_value()?);
460 }
461 GeneratedField::EventTimeSec => {
462 if event_time_sec__.is_some() {
463 return Err(serde::de::Error::duplicate_field("eventTimeSec"));
464 }
465 event_time_sec__ =
466 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
467 ;
468 }
469 GeneratedField::EventStage => {
470 if event_stage__.is_some() {
471 return Err(serde::de::Error::duplicate_field("eventStage"));
472 }
473 event_stage__ = Some(map_.next_value::<TelemetryEventStage>()? as i32);
474 }
475 GeneratedField::EventName => {
476 if event_name__.is_some() {
477 return Err(serde::de::Error::duplicate_field("eventName"));
478 }
479 event_name__ = Some(map_.next_value()?);
480 }
481 GeneratedField::ConnectorName => {
482 if connector_name__.is_some() {
483 return Err(serde::de::Error::duplicate_field("connectorName"));
484 }
485 connector_name__ = map_.next_value()?;
486 }
487 GeneratedField::Object => {
488 if object__.is_some() {
489 return Err(serde::de::Error::duplicate_field("object"));
490 }
491 object__ = map_.next_value::<::std::option::Option<TelemetryDatabaseObject>>()?.map(|x| x as i32);
492 }
493 GeneratedField::CatalogId => {
494 if catalog_id__.is_some() {
495 return Err(serde::de::Error::duplicate_field("catalogId"));
496 }
497 catalog_id__ =
498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
499 ;
500 }
501 GeneratedField::Attributes => {
502 if attributes__.is_some() {
503 return Err(serde::de::Error::duplicate_field("attributes"));
504 }
505 attributes__ = map_.next_value()?;
506 }
507 GeneratedField::Node => {
508 if node__.is_some() {
509 return Err(serde::de::Error::duplicate_field("node"));
510 }
511 node__ = Some(map_.next_value()?);
512 }
513 GeneratedField::IsTest => {
514 if is_test__.is_some() {
515 return Err(serde::de::Error::duplicate_field("isTest"));
516 }
517 is_test__ = Some(map_.next_value()?);
518 }
519 }
520 }
521 Ok(EventMessage {
522 tracking_id: tracking_id__.unwrap_or_default(),
523 event_time_sec: event_time_sec__.unwrap_or_default(),
524 event_stage: event_stage__.unwrap_or_default(),
525 event_name: event_name__.unwrap_or_default(),
526 connector_name: connector_name__,
527 object: object__,
528 catalog_id: catalog_id__.unwrap_or_default(),
529 attributes: attributes__,
530 node: node__.unwrap_or_default(),
531 is_test: is_test__.unwrap_or_default(),
532 })
533 }
534 }
535 deserializer.deserialize_struct("telemetry.EventMessage", FIELDS, GeneratedVisitor)
536 }
537}
538impl serde::Serialize for FrontendReport {
539 #[allow(deprecated)]
540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
541 where
542 S: serde::Serializer,
543 {
544 use serde::ser::SerializeStruct;
545 let mut len = 0;
546 if self.base.is_some() {
547 len += 1;
548 }
549 let mut struct_ser = serializer.serialize_struct("telemetry.FrontendReport", len)?;
550 if let Some(v) = self.base.as_ref() {
551 struct_ser.serialize_field("base", v)?;
552 }
553 struct_ser.end()
554 }
555}
556impl<'de> serde::Deserialize<'de> for FrontendReport {
557 #[allow(deprecated)]
558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
559 where
560 D: serde::Deserializer<'de>,
561 {
562 const FIELDS: &[&str] = &[
563 "base",
564 ];
565
566 #[allow(clippy::enum_variant_names)]
567 enum GeneratedField {
568 Base,
569 }
570 impl<'de> serde::Deserialize<'de> for GeneratedField {
571 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
572 where
573 D: serde::Deserializer<'de>,
574 {
575 struct GeneratedVisitor;
576
577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
578 type Value = GeneratedField;
579
580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
581 write!(formatter, "expected one of: {:?}", &FIELDS)
582 }
583
584 #[allow(unused_variables)]
585 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
586 where
587 E: serde::de::Error,
588 {
589 match value {
590 "base" => Ok(GeneratedField::Base),
591 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
592 }
593 }
594 }
595 deserializer.deserialize_identifier(GeneratedVisitor)
596 }
597 }
598 struct GeneratedVisitor;
599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
600 type Value = FrontendReport;
601
602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
603 formatter.write_str("struct telemetry.FrontendReport")
604 }
605
606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FrontendReport, V::Error>
607 where
608 V: serde::de::MapAccess<'de>,
609 {
610 let mut base__ = None;
611 while let Some(k) = map_.next_key()? {
612 match k {
613 GeneratedField::Base => {
614 if base__.is_some() {
615 return Err(serde::de::Error::duplicate_field("base"));
616 }
617 base__ = map_.next_value()?;
618 }
619 }
620 }
621 Ok(FrontendReport {
622 base: base__,
623 })
624 }
625 }
626 deserializer.deserialize_struct("telemetry.FrontendReport", FIELDS, GeneratedVisitor)
627 }
628}
629impl serde::Serialize for MetaBackend {
630 #[allow(deprecated)]
631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
632 where
633 S: serde::Serializer,
634 {
635 let variant = match self {
636 Self::Unspecified => "META_BACKEND_UNSPECIFIED",
637 Self::Memory => "META_BACKEND_MEMORY",
638 Self::Etcd => "META_BACKEND_ETCD",
639 Self::Rdb => "META_BACKEND_RDB",
640 };
641 serializer.serialize_str(variant)
642 }
643}
644impl<'de> serde::Deserialize<'de> for MetaBackend {
645 #[allow(deprecated)]
646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
647 where
648 D: serde::Deserializer<'de>,
649 {
650 const FIELDS: &[&str] = &[
651 "META_BACKEND_UNSPECIFIED",
652 "META_BACKEND_MEMORY",
653 "META_BACKEND_ETCD",
654 "META_BACKEND_RDB",
655 ];
656
657 struct GeneratedVisitor;
658
659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
660 type Value = MetaBackend;
661
662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
663 write!(formatter, "expected one of: {:?}", &FIELDS)
664 }
665
666 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
667 where
668 E: serde::de::Error,
669 {
670 i32::try_from(v)
671 .ok()
672 .and_then(|x| x.try_into().ok())
673 .ok_or_else(|| {
674 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
675 })
676 }
677
678 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
679 where
680 E: serde::de::Error,
681 {
682 i32::try_from(v)
683 .ok()
684 .and_then(|x| x.try_into().ok())
685 .ok_or_else(|| {
686 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
687 })
688 }
689
690 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
691 where
692 E: serde::de::Error,
693 {
694 match value {
695 "META_BACKEND_UNSPECIFIED" => Ok(MetaBackend::Unspecified),
696 "META_BACKEND_MEMORY" => Ok(MetaBackend::Memory),
697 "META_BACKEND_ETCD" => Ok(MetaBackend::Etcd),
698 "META_BACKEND_RDB" => Ok(MetaBackend::Rdb),
699 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
700 }
701 }
702 }
703 deserializer.deserialize_any(GeneratedVisitor)
704 }
705}
706impl serde::Serialize for MetaReport {
707 #[allow(deprecated)]
708 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
709 where
710 S: serde::Serializer,
711 {
712 use serde::ser::SerializeStruct;
713 let mut len = 0;
714 if self.base.is_some() {
715 len += 1;
716 }
717 if self.meta_backend != 0 {
718 len += 1;
719 }
720 if self.node_count.is_some() {
721 len += 1;
722 }
723 if self.rw_version.is_some() {
724 len += 1;
725 }
726 if self.stream_job_count != 0 {
727 len += 1;
728 }
729 if !self.stream_jobs.is_empty() {
730 len += 1;
731 }
732 if self.cluster_type != 0 {
733 len += 1;
734 }
735 if !self.object_store_media_type.is_empty() {
736 len += 1;
737 }
738 if !self.connector_usage_json_str.is_empty() {
739 len += 1;
740 }
741 if !self.license_info_json_str.is_empty() {
742 len += 1;
743 }
744 let mut struct_ser = serializer.serialize_struct("telemetry.MetaReport", len)?;
745 if let Some(v) = self.base.as_ref() {
746 struct_ser.serialize_field("base", v)?;
747 }
748 if self.meta_backend != 0 {
749 let v = MetaBackend::try_from(self.meta_backend)
750 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.meta_backend)))?;
751 struct_ser.serialize_field("metaBackend", &v)?;
752 }
753 if let Some(v) = self.node_count.as_ref() {
754 struct_ser.serialize_field("nodeCount", v)?;
755 }
756 if let Some(v) = self.rw_version.as_ref() {
757 struct_ser.serialize_field("rwVersion", v)?;
758 }
759 if self.stream_job_count != 0 {
760 struct_ser.serialize_field("streamJobCount", &self.stream_job_count)?;
761 }
762 if !self.stream_jobs.is_empty() {
763 struct_ser.serialize_field("streamJobs", &self.stream_jobs)?;
764 }
765 if self.cluster_type != 0 {
766 let v = TelemetryClusterType::try_from(self.cluster_type)
767 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cluster_type)))?;
768 struct_ser.serialize_field("clusterType", &v)?;
769 }
770 if !self.object_store_media_type.is_empty() {
771 struct_ser.serialize_field("objectStoreMediaType", &self.object_store_media_type)?;
772 }
773 if !self.connector_usage_json_str.is_empty() {
774 struct_ser.serialize_field("connectorUsageJsonStr", &self.connector_usage_json_str)?;
775 }
776 if !self.license_info_json_str.is_empty() {
777 struct_ser.serialize_field("licenseInfoJsonStr", &self.license_info_json_str)?;
778 }
779 struct_ser.end()
780 }
781}
782impl<'de> serde::Deserialize<'de> for MetaReport {
783 #[allow(deprecated)]
784 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
785 where
786 D: serde::Deserializer<'de>,
787 {
788 const FIELDS: &[&str] = &[
789 "base",
790 "meta_backend",
791 "metaBackend",
792 "node_count",
793 "nodeCount",
794 "rw_version",
795 "rwVersion",
796 "stream_job_count",
797 "streamJobCount",
798 "stream_jobs",
799 "streamJobs",
800 "cluster_type",
801 "clusterType",
802 "object_store_media_type",
803 "objectStoreMediaType",
804 "connector_usage_json_str",
805 "connectorUsageJsonStr",
806 "license_info_json_str",
807 "licenseInfoJsonStr",
808 ];
809
810 #[allow(clippy::enum_variant_names)]
811 enum GeneratedField {
812 Base,
813 MetaBackend,
814 NodeCount,
815 RwVersion,
816 StreamJobCount,
817 StreamJobs,
818 ClusterType,
819 ObjectStoreMediaType,
820 ConnectorUsageJsonStr,
821 LicenseInfoJsonStr,
822 }
823 impl<'de> serde::Deserialize<'de> for GeneratedField {
824 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
825 where
826 D: serde::Deserializer<'de>,
827 {
828 struct GeneratedVisitor;
829
830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
831 type Value = GeneratedField;
832
833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
834 write!(formatter, "expected one of: {:?}", &FIELDS)
835 }
836
837 #[allow(unused_variables)]
838 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
839 where
840 E: serde::de::Error,
841 {
842 match value {
843 "base" => Ok(GeneratedField::Base),
844 "metaBackend" | "meta_backend" => Ok(GeneratedField::MetaBackend),
845 "nodeCount" | "node_count" => Ok(GeneratedField::NodeCount),
846 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
847 "streamJobCount" | "stream_job_count" => Ok(GeneratedField::StreamJobCount),
848 "streamJobs" | "stream_jobs" => Ok(GeneratedField::StreamJobs),
849 "clusterType" | "cluster_type" => Ok(GeneratedField::ClusterType),
850 "objectStoreMediaType" | "object_store_media_type" => Ok(GeneratedField::ObjectStoreMediaType),
851 "connectorUsageJsonStr" | "connector_usage_json_str" => Ok(GeneratedField::ConnectorUsageJsonStr),
852 "licenseInfoJsonStr" | "license_info_json_str" => Ok(GeneratedField::LicenseInfoJsonStr),
853 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
854 }
855 }
856 }
857 deserializer.deserialize_identifier(GeneratedVisitor)
858 }
859 }
860 struct GeneratedVisitor;
861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
862 type Value = MetaReport;
863
864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
865 formatter.write_str("struct telemetry.MetaReport")
866 }
867
868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaReport, V::Error>
869 where
870 V: serde::de::MapAccess<'de>,
871 {
872 let mut base__ = None;
873 let mut meta_backend__ = None;
874 let mut node_count__ = None;
875 let mut rw_version__ = None;
876 let mut stream_job_count__ = None;
877 let mut stream_jobs__ = None;
878 let mut cluster_type__ = None;
879 let mut object_store_media_type__ = None;
880 let mut connector_usage_json_str__ = None;
881 let mut license_info_json_str__ = None;
882 while let Some(k) = map_.next_key()? {
883 match k {
884 GeneratedField::Base => {
885 if base__.is_some() {
886 return Err(serde::de::Error::duplicate_field("base"));
887 }
888 base__ = map_.next_value()?;
889 }
890 GeneratedField::MetaBackend => {
891 if meta_backend__.is_some() {
892 return Err(serde::de::Error::duplicate_field("metaBackend"));
893 }
894 meta_backend__ = Some(map_.next_value::<MetaBackend>()? as i32);
895 }
896 GeneratedField::NodeCount => {
897 if node_count__.is_some() {
898 return Err(serde::de::Error::duplicate_field("nodeCount"));
899 }
900 node_count__ = map_.next_value()?;
901 }
902 GeneratedField::RwVersion => {
903 if rw_version__.is_some() {
904 return Err(serde::de::Error::duplicate_field("rwVersion"));
905 }
906 rw_version__ = map_.next_value()?;
907 }
908 GeneratedField::StreamJobCount => {
909 if stream_job_count__.is_some() {
910 return Err(serde::de::Error::duplicate_field("streamJobCount"));
911 }
912 stream_job_count__ =
913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
914 ;
915 }
916 GeneratedField::StreamJobs => {
917 if stream_jobs__.is_some() {
918 return Err(serde::de::Error::duplicate_field("streamJobs"));
919 }
920 stream_jobs__ = Some(map_.next_value()?);
921 }
922 GeneratedField::ClusterType => {
923 if cluster_type__.is_some() {
924 return Err(serde::de::Error::duplicate_field("clusterType"));
925 }
926 cluster_type__ = Some(map_.next_value::<TelemetryClusterType>()? as i32);
927 }
928 GeneratedField::ObjectStoreMediaType => {
929 if object_store_media_type__.is_some() {
930 return Err(serde::de::Error::duplicate_field("objectStoreMediaType"));
931 }
932 object_store_media_type__ = Some(map_.next_value()?);
933 }
934 GeneratedField::ConnectorUsageJsonStr => {
935 if connector_usage_json_str__.is_some() {
936 return Err(serde::de::Error::duplicate_field("connectorUsageJsonStr"));
937 }
938 connector_usage_json_str__ = Some(map_.next_value()?);
939 }
940 GeneratedField::LicenseInfoJsonStr => {
941 if license_info_json_str__.is_some() {
942 return Err(serde::de::Error::duplicate_field("licenseInfoJsonStr"));
943 }
944 license_info_json_str__ = Some(map_.next_value()?);
945 }
946 }
947 }
948 Ok(MetaReport {
949 base: base__,
950 meta_backend: meta_backend__.unwrap_or_default(),
951 node_count: node_count__,
952 rw_version: rw_version__,
953 stream_job_count: stream_job_count__.unwrap_or_default(),
954 stream_jobs: stream_jobs__.unwrap_or_default(),
955 cluster_type: cluster_type__.unwrap_or_default(),
956 object_store_media_type: object_store_media_type__.unwrap_or_default(),
957 connector_usage_json_str: connector_usage_json_str__.unwrap_or_default(),
958 license_info_json_str: license_info_json_str__.unwrap_or_default(),
959 })
960 }
961 }
962 deserializer.deserialize_struct("telemetry.MetaReport", FIELDS, GeneratedVisitor)
963 }
964}
965impl serde::Serialize for NodeCount {
966 #[allow(deprecated)]
967 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
968 where
969 S: serde::Serializer,
970 {
971 use serde::ser::SerializeStruct;
972 let mut len = 0;
973 if self.meta != 0 {
974 len += 1;
975 }
976 if self.compute != 0 {
977 len += 1;
978 }
979 if self.frontend != 0 {
980 len += 1;
981 }
982 if self.compactor != 0 {
983 len += 1;
984 }
985 let mut struct_ser = serializer.serialize_struct("telemetry.NodeCount", len)?;
986 if self.meta != 0 {
987 struct_ser.serialize_field("meta", &self.meta)?;
988 }
989 if self.compute != 0 {
990 struct_ser.serialize_field("compute", &self.compute)?;
991 }
992 if self.frontend != 0 {
993 struct_ser.serialize_field("frontend", &self.frontend)?;
994 }
995 if self.compactor != 0 {
996 struct_ser.serialize_field("compactor", &self.compactor)?;
997 }
998 struct_ser.end()
999 }
1000}
1001impl<'de> serde::Deserialize<'de> for NodeCount {
1002 #[allow(deprecated)]
1003 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1004 where
1005 D: serde::Deserializer<'de>,
1006 {
1007 const FIELDS: &[&str] = &[
1008 "meta",
1009 "compute",
1010 "frontend",
1011 "compactor",
1012 ];
1013
1014 #[allow(clippy::enum_variant_names)]
1015 enum GeneratedField {
1016 Meta,
1017 Compute,
1018 Frontend,
1019 Compactor,
1020 }
1021 impl<'de> serde::Deserialize<'de> for GeneratedField {
1022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1023 where
1024 D: serde::Deserializer<'de>,
1025 {
1026 struct GeneratedVisitor;
1027
1028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1029 type Value = GeneratedField;
1030
1031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1032 write!(formatter, "expected one of: {:?}", &FIELDS)
1033 }
1034
1035 #[allow(unused_variables)]
1036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1037 where
1038 E: serde::de::Error,
1039 {
1040 match value {
1041 "meta" => Ok(GeneratedField::Meta),
1042 "compute" => Ok(GeneratedField::Compute),
1043 "frontend" => Ok(GeneratedField::Frontend),
1044 "compactor" => Ok(GeneratedField::Compactor),
1045 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1046 }
1047 }
1048 }
1049 deserializer.deserialize_identifier(GeneratedVisitor)
1050 }
1051 }
1052 struct GeneratedVisitor;
1053 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1054 type Value = NodeCount;
1055
1056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1057 formatter.write_str("struct telemetry.NodeCount")
1058 }
1059
1060 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NodeCount, V::Error>
1061 where
1062 V: serde::de::MapAccess<'de>,
1063 {
1064 let mut meta__ = None;
1065 let mut compute__ = None;
1066 let mut frontend__ = None;
1067 let mut compactor__ = None;
1068 while let Some(k) = map_.next_key()? {
1069 match k {
1070 GeneratedField::Meta => {
1071 if meta__.is_some() {
1072 return Err(serde::de::Error::duplicate_field("meta"));
1073 }
1074 meta__ =
1075 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1076 ;
1077 }
1078 GeneratedField::Compute => {
1079 if compute__.is_some() {
1080 return Err(serde::de::Error::duplicate_field("compute"));
1081 }
1082 compute__ =
1083 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1084 ;
1085 }
1086 GeneratedField::Frontend => {
1087 if frontend__.is_some() {
1088 return Err(serde::de::Error::duplicate_field("frontend"));
1089 }
1090 frontend__ =
1091 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1092 ;
1093 }
1094 GeneratedField::Compactor => {
1095 if compactor__.is_some() {
1096 return Err(serde::de::Error::duplicate_field("compactor"));
1097 }
1098 compactor__ =
1099 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1100 ;
1101 }
1102 }
1103 }
1104 Ok(NodeCount {
1105 meta: meta__.unwrap_or_default(),
1106 compute: compute__.unwrap_or_default(),
1107 frontend: frontend__.unwrap_or_default(),
1108 compactor: compactor__.unwrap_or_default(),
1109 })
1110 }
1111 }
1112 deserializer.deserialize_struct("telemetry.NodeCount", FIELDS, GeneratedVisitor)
1113 }
1114}
1115impl serde::Serialize for PlanOptimization {
1116 #[allow(deprecated)]
1117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1118 where
1119 S: serde::Serializer,
1120 {
1121 let variant = match self {
1122 Self::TableOptimizationUnspecified => "TABLE_OPTIMIZATION_UNSPECIFIED",
1123 };
1124 serializer.serialize_str(variant)
1125 }
1126}
1127impl<'de> serde::Deserialize<'de> for PlanOptimization {
1128 #[allow(deprecated)]
1129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1130 where
1131 D: serde::Deserializer<'de>,
1132 {
1133 const FIELDS: &[&str] = &[
1134 "TABLE_OPTIMIZATION_UNSPECIFIED",
1135 ];
1136
1137 struct GeneratedVisitor;
1138
1139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1140 type Value = PlanOptimization;
1141
1142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1143 write!(formatter, "expected one of: {:?}", &FIELDS)
1144 }
1145
1146 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1147 where
1148 E: serde::de::Error,
1149 {
1150 i32::try_from(v)
1151 .ok()
1152 .and_then(|x| x.try_into().ok())
1153 .ok_or_else(|| {
1154 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1155 })
1156 }
1157
1158 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1159 where
1160 E: serde::de::Error,
1161 {
1162 i32::try_from(v)
1163 .ok()
1164 .and_then(|x| x.try_into().ok())
1165 .ok_or_else(|| {
1166 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1167 })
1168 }
1169
1170 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1171 where
1172 E: serde::de::Error,
1173 {
1174 match value {
1175 "TABLE_OPTIMIZATION_UNSPECIFIED" => Ok(PlanOptimization::TableOptimizationUnspecified),
1176 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1177 }
1178 }
1179 }
1180 deserializer.deserialize_any(GeneratedVisitor)
1181 }
1182}
1183impl serde::Serialize for ReportBase {
1184 #[allow(deprecated)]
1185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1186 where
1187 S: serde::Serializer,
1188 {
1189 use serde::ser::SerializeStruct;
1190 let mut len = 0;
1191 if !self.tracking_id.is_empty() {
1192 len += 1;
1193 }
1194 if !self.session_id.is_empty() {
1195 len += 1;
1196 }
1197 if self.system_data.is_some() {
1198 len += 1;
1199 }
1200 if self.up_time != 0 {
1201 len += 1;
1202 }
1203 if self.report_time != 0 {
1204 len += 1;
1205 }
1206 if self.node_type != 0 {
1207 len += 1;
1208 }
1209 if self.is_test {
1210 len += 1;
1211 }
1212 let mut struct_ser = serializer.serialize_struct("telemetry.ReportBase", len)?;
1213 if !self.tracking_id.is_empty() {
1214 struct_ser.serialize_field("trackingId", &self.tracking_id)?;
1215 }
1216 if !self.session_id.is_empty() {
1217 struct_ser.serialize_field("sessionId", &self.session_id)?;
1218 }
1219 if let Some(v) = self.system_data.as_ref() {
1220 struct_ser.serialize_field("systemData", v)?;
1221 }
1222 if self.up_time != 0 {
1223 #[allow(clippy::needless_borrow)]
1224 #[allow(clippy::needless_borrows_for_generic_args)]
1225 struct_ser.serialize_field("upTime", ToString::to_string(&self.up_time).as_str())?;
1226 }
1227 if self.report_time != 0 {
1228 #[allow(clippy::needless_borrow)]
1229 #[allow(clippy::needless_borrows_for_generic_args)]
1230 struct_ser.serialize_field("reportTime", ToString::to_string(&self.report_time).as_str())?;
1231 }
1232 if self.node_type != 0 {
1233 let v = TelemetryNodeType::try_from(self.node_type)
1234 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.node_type)))?;
1235 struct_ser.serialize_field("nodeType", &v)?;
1236 }
1237 if self.is_test {
1238 struct_ser.serialize_field("isTest", &self.is_test)?;
1239 }
1240 struct_ser.end()
1241 }
1242}
1243impl<'de> serde::Deserialize<'de> for ReportBase {
1244 #[allow(deprecated)]
1245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1246 where
1247 D: serde::Deserializer<'de>,
1248 {
1249 const FIELDS: &[&str] = &[
1250 "tracking_id",
1251 "trackingId",
1252 "session_id",
1253 "sessionId",
1254 "system_data",
1255 "systemData",
1256 "up_time",
1257 "upTime",
1258 "report_time",
1259 "reportTime",
1260 "node_type",
1261 "nodeType",
1262 "is_test",
1263 "isTest",
1264 ];
1265
1266 #[allow(clippy::enum_variant_names)]
1267 enum GeneratedField {
1268 TrackingId,
1269 SessionId,
1270 SystemData,
1271 UpTime,
1272 ReportTime,
1273 NodeType,
1274 IsTest,
1275 }
1276 impl<'de> serde::Deserialize<'de> for GeneratedField {
1277 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1278 where
1279 D: serde::Deserializer<'de>,
1280 {
1281 struct GeneratedVisitor;
1282
1283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1284 type Value = GeneratedField;
1285
1286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1287 write!(formatter, "expected one of: {:?}", &FIELDS)
1288 }
1289
1290 #[allow(unused_variables)]
1291 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1292 where
1293 E: serde::de::Error,
1294 {
1295 match value {
1296 "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
1297 "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
1298 "systemData" | "system_data" => Ok(GeneratedField::SystemData),
1299 "upTime" | "up_time" => Ok(GeneratedField::UpTime),
1300 "reportTime" | "report_time" => Ok(GeneratedField::ReportTime),
1301 "nodeType" | "node_type" => Ok(GeneratedField::NodeType),
1302 "isTest" | "is_test" => Ok(GeneratedField::IsTest),
1303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1304 }
1305 }
1306 }
1307 deserializer.deserialize_identifier(GeneratedVisitor)
1308 }
1309 }
1310 struct GeneratedVisitor;
1311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1312 type Value = ReportBase;
1313
1314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1315 formatter.write_str("struct telemetry.ReportBase")
1316 }
1317
1318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportBase, V::Error>
1319 where
1320 V: serde::de::MapAccess<'de>,
1321 {
1322 let mut tracking_id__ = None;
1323 let mut session_id__ = None;
1324 let mut system_data__ = None;
1325 let mut up_time__ = None;
1326 let mut report_time__ = None;
1327 let mut node_type__ = None;
1328 let mut is_test__ = None;
1329 while let Some(k) = map_.next_key()? {
1330 match k {
1331 GeneratedField::TrackingId => {
1332 if tracking_id__.is_some() {
1333 return Err(serde::de::Error::duplicate_field("trackingId"));
1334 }
1335 tracking_id__ = Some(map_.next_value()?);
1336 }
1337 GeneratedField::SessionId => {
1338 if session_id__.is_some() {
1339 return Err(serde::de::Error::duplicate_field("sessionId"));
1340 }
1341 session_id__ = Some(map_.next_value()?);
1342 }
1343 GeneratedField::SystemData => {
1344 if system_data__.is_some() {
1345 return Err(serde::de::Error::duplicate_field("systemData"));
1346 }
1347 system_data__ = map_.next_value()?;
1348 }
1349 GeneratedField::UpTime => {
1350 if up_time__.is_some() {
1351 return Err(serde::de::Error::duplicate_field("upTime"));
1352 }
1353 up_time__ =
1354 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1355 ;
1356 }
1357 GeneratedField::ReportTime => {
1358 if report_time__.is_some() {
1359 return Err(serde::de::Error::duplicate_field("reportTime"));
1360 }
1361 report_time__ =
1362 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1363 ;
1364 }
1365 GeneratedField::NodeType => {
1366 if node_type__.is_some() {
1367 return Err(serde::de::Error::duplicate_field("nodeType"));
1368 }
1369 node_type__ = Some(map_.next_value::<TelemetryNodeType>()? as i32);
1370 }
1371 GeneratedField::IsTest => {
1372 if is_test__.is_some() {
1373 return Err(serde::de::Error::duplicate_field("isTest"));
1374 }
1375 is_test__ = Some(map_.next_value()?);
1376 }
1377 }
1378 }
1379 Ok(ReportBase {
1380 tracking_id: tracking_id__.unwrap_or_default(),
1381 session_id: session_id__.unwrap_or_default(),
1382 system_data: system_data__,
1383 up_time: up_time__.unwrap_or_default(),
1384 report_time: report_time__.unwrap_or_default(),
1385 node_type: node_type__.unwrap_or_default(),
1386 is_test: is_test__.unwrap_or_default(),
1387 })
1388 }
1389 }
1390 deserializer.deserialize_struct("telemetry.ReportBase", FIELDS, GeneratedVisitor)
1391 }
1392}
1393impl serde::Serialize for RwVersion {
1394 #[allow(deprecated)]
1395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1396 where
1397 S: serde::Serializer,
1398 {
1399 use serde::ser::SerializeStruct;
1400 let mut len = 0;
1401 if !self.rw_version.is_empty() {
1402 len += 1;
1403 }
1404 if !self.git_sha.is_empty() {
1405 len += 1;
1406 }
1407 let mut struct_ser = serializer.serialize_struct("telemetry.RwVersion", len)?;
1408 if !self.rw_version.is_empty() {
1409 struct_ser.serialize_field("rwVersion", &self.rw_version)?;
1410 }
1411 if !self.git_sha.is_empty() {
1412 struct_ser.serialize_field("gitSha", &self.git_sha)?;
1413 }
1414 struct_ser.end()
1415 }
1416}
1417impl<'de> serde::Deserialize<'de> for RwVersion {
1418 #[allow(deprecated)]
1419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1420 where
1421 D: serde::Deserializer<'de>,
1422 {
1423 const FIELDS: &[&str] = &[
1424 "rw_version",
1425 "rwVersion",
1426 "git_sha",
1427 "gitSha",
1428 ];
1429
1430 #[allow(clippy::enum_variant_names)]
1431 enum GeneratedField {
1432 RwVersion,
1433 GitSha,
1434 }
1435 impl<'de> serde::Deserialize<'de> for GeneratedField {
1436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1437 where
1438 D: serde::Deserializer<'de>,
1439 {
1440 struct GeneratedVisitor;
1441
1442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1443 type Value = GeneratedField;
1444
1445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1446 write!(formatter, "expected one of: {:?}", &FIELDS)
1447 }
1448
1449 #[allow(unused_variables)]
1450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1451 where
1452 E: serde::de::Error,
1453 {
1454 match value {
1455 "rwVersion" | "rw_version" => Ok(GeneratedField::RwVersion),
1456 "gitSha" | "git_sha" => Ok(GeneratedField::GitSha),
1457 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1458 }
1459 }
1460 }
1461 deserializer.deserialize_identifier(GeneratedVisitor)
1462 }
1463 }
1464 struct GeneratedVisitor;
1465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1466 type Value = RwVersion;
1467
1468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1469 formatter.write_str("struct telemetry.RwVersion")
1470 }
1471
1472 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RwVersion, V::Error>
1473 where
1474 V: serde::de::MapAccess<'de>,
1475 {
1476 let mut rw_version__ = None;
1477 let mut git_sha__ = None;
1478 while let Some(k) = map_.next_key()? {
1479 match k {
1480 GeneratedField::RwVersion => {
1481 if rw_version__.is_some() {
1482 return Err(serde::de::Error::duplicate_field("rwVersion"));
1483 }
1484 rw_version__ = Some(map_.next_value()?);
1485 }
1486 GeneratedField::GitSha => {
1487 if git_sha__.is_some() {
1488 return Err(serde::de::Error::duplicate_field("gitSha"));
1489 }
1490 git_sha__ = Some(map_.next_value()?);
1491 }
1492 }
1493 }
1494 Ok(RwVersion {
1495 rw_version: rw_version__.unwrap_or_default(),
1496 git_sha: git_sha__.unwrap_or_default(),
1497 })
1498 }
1499 }
1500 deserializer.deserialize_struct("telemetry.RwVersion", FIELDS, GeneratedVisitor)
1501 }
1502}
1503impl serde::Serialize for StreamJobDesc {
1504 #[allow(deprecated)]
1505 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1506 where
1507 S: serde::Serializer,
1508 {
1509 use serde::ser::SerializeStruct;
1510 let mut len = 0;
1511 if self.table_id != 0 {
1512 len += 1;
1513 }
1514 if self.connector_name.is_some() {
1515 len += 1;
1516 }
1517 if !self.plan_optimizations.is_empty() {
1518 len += 1;
1519 }
1520 let mut struct_ser = serializer.serialize_struct("telemetry.StreamJobDesc", len)?;
1521 if self.table_id != 0 {
1522 struct_ser.serialize_field("tableId", &self.table_id)?;
1523 }
1524 if let Some(v) = self.connector_name.as_ref() {
1525 struct_ser.serialize_field("connectorName", v)?;
1526 }
1527 if !self.plan_optimizations.is_empty() {
1528 let v = self.plan_optimizations.iter().cloned().map(|v| {
1529 PlanOptimization::try_from(v)
1530 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", v)))
1531 }).collect::<std::result::Result<Vec<_>, _>>()?;
1532 struct_ser.serialize_field("planOptimizations", &v)?;
1533 }
1534 struct_ser.end()
1535 }
1536}
1537impl<'de> serde::Deserialize<'de> for StreamJobDesc {
1538 #[allow(deprecated)]
1539 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1540 where
1541 D: serde::Deserializer<'de>,
1542 {
1543 const FIELDS: &[&str] = &[
1544 "table_id",
1545 "tableId",
1546 "connector_name",
1547 "connectorName",
1548 "plan_optimizations",
1549 "planOptimizations",
1550 ];
1551
1552 #[allow(clippy::enum_variant_names)]
1553 enum GeneratedField {
1554 TableId,
1555 ConnectorName,
1556 PlanOptimizations,
1557 }
1558 impl<'de> serde::Deserialize<'de> for GeneratedField {
1559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1560 where
1561 D: serde::Deserializer<'de>,
1562 {
1563 struct GeneratedVisitor;
1564
1565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1566 type Value = GeneratedField;
1567
1568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1569 write!(formatter, "expected one of: {:?}", &FIELDS)
1570 }
1571
1572 #[allow(unused_variables)]
1573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1574 where
1575 E: serde::de::Error,
1576 {
1577 match value {
1578 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1579 "connectorName" | "connector_name" => Ok(GeneratedField::ConnectorName),
1580 "planOptimizations" | "plan_optimizations" => Ok(GeneratedField::PlanOptimizations),
1581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1582 }
1583 }
1584 }
1585 deserializer.deserialize_identifier(GeneratedVisitor)
1586 }
1587 }
1588 struct GeneratedVisitor;
1589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1590 type Value = StreamJobDesc;
1591
1592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1593 formatter.write_str("struct telemetry.StreamJobDesc")
1594 }
1595
1596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamJobDesc, V::Error>
1597 where
1598 V: serde::de::MapAccess<'de>,
1599 {
1600 let mut table_id__ = None;
1601 let mut connector_name__ = None;
1602 let mut plan_optimizations__ = None;
1603 while let Some(k) = map_.next_key()? {
1604 match k {
1605 GeneratedField::TableId => {
1606 if table_id__.is_some() {
1607 return Err(serde::de::Error::duplicate_field("tableId"));
1608 }
1609 table_id__ =
1610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1611 ;
1612 }
1613 GeneratedField::ConnectorName => {
1614 if connector_name__.is_some() {
1615 return Err(serde::de::Error::duplicate_field("connectorName"));
1616 }
1617 connector_name__ = map_.next_value()?;
1618 }
1619 GeneratedField::PlanOptimizations => {
1620 if plan_optimizations__.is_some() {
1621 return Err(serde::de::Error::duplicate_field("planOptimizations"));
1622 }
1623 plan_optimizations__ = Some(map_.next_value::<Vec<PlanOptimization>>()?.into_iter().map(|x| x as i32).collect());
1624 }
1625 }
1626 }
1627 Ok(StreamJobDesc {
1628 table_id: table_id__.unwrap_or_default(),
1629 connector_name: connector_name__,
1630 plan_optimizations: plan_optimizations__.unwrap_or_default(),
1631 })
1632 }
1633 }
1634 deserializer.deserialize_struct("telemetry.StreamJobDesc", FIELDS, GeneratedVisitor)
1635 }
1636}
1637impl serde::Serialize for SystemCpu {
1638 #[allow(deprecated)]
1639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1640 where
1641 S: serde::Serializer,
1642 {
1643 use serde::ser::SerializeStruct;
1644 let mut len = 0;
1645 if self.available != 0. {
1646 len += 1;
1647 }
1648 let mut struct_ser = serializer.serialize_struct("telemetry.SystemCpu", len)?;
1649 if self.available != 0. {
1650 struct_ser.serialize_field("available", &self.available)?;
1651 }
1652 struct_ser.end()
1653 }
1654}
1655impl<'de> serde::Deserialize<'de> for SystemCpu {
1656 #[allow(deprecated)]
1657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1658 where
1659 D: serde::Deserializer<'de>,
1660 {
1661 const FIELDS: &[&str] = &[
1662 "available",
1663 ];
1664
1665 #[allow(clippy::enum_variant_names)]
1666 enum GeneratedField {
1667 Available,
1668 }
1669 impl<'de> serde::Deserialize<'de> for GeneratedField {
1670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1671 where
1672 D: serde::Deserializer<'de>,
1673 {
1674 struct GeneratedVisitor;
1675
1676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1677 type Value = GeneratedField;
1678
1679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1680 write!(formatter, "expected one of: {:?}", &FIELDS)
1681 }
1682
1683 #[allow(unused_variables)]
1684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1685 where
1686 E: serde::de::Error,
1687 {
1688 match value {
1689 "available" => Ok(GeneratedField::Available),
1690 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1691 }
1692 }
1693 }
1694 deserializer.deserialize_identifier(GeneratedVisitor)
1695 }
1696 }
1697 struct GeneratedVisitor;
1698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1699 type Value = SystemCpu;
1700
1701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1702 formatter.write_str("struct telemetry.SystemCpu")
1703 }
1704
1705 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemCpu, V::Error>
1706 where
1707 V: serde::de::MapAccess<'de>,
1708 {
1709 let mut available__ = None;
1710 while let Some(k) = map_.next_key()? {
1711 match k {
1712 GeneratedField::Available => {
1713 if available__.is_some() {
1714 return Err(serde::de::Error::duplicate_field("available"));
1715 }
1716 available__ =
1717 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1718 ;
1719 }
1720 }
1721 }
1722 Ok(SystemCpu {
1723 available: available__.unwrap_or_default(),
1724 })
1725 }
1726 }
1727 deserializer.deserialize_struct("telemetry.SystemCpu", FIELDS, GeneratedVisitor)
1728 }
1729}
1730impl serde::Serialize for SystemData {
1731 #[allow(deprecated)]
1732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1733 where
1734 S: serde::Serializer,
1735 {
1736 use serde::ser::SerializeStruct;
1737 let mut len = 0;
1738 if self.memory.is_some() {
1739 len += 1;
1740 }
1741 if self.os.is_some() {
1742 len += 1;
1743 }
1744 if self.cpu.is_some() {
1745 len += 1;
1746 }
1747 let mut struct_ser = serializer.serialize_struct("telemetry.SystemData", len)?;
1748 if let Some(v) = self.memory.as_ref() {
1749 struct_ser.serialize_field("memory", v)?;
1750 }
1751 if let Some(v) = self.os.as_ref() {
1752 struct_ser.serialize_field("os", v)?;
1753 }
1754 if let Some(v) = self.cpu.as_ref() {
1755 struct_ser.serialize_field("cpu", v)?;
1756 }
1757 struct_ser.end()
1758 }
1759}
1760impl<'de> serde::Deserialize<'de> for SystemData {
1761 #[allow(deprecated)]
1762 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1763 where
1764 D: serde::Deserializer<'de>,
1765 {
1766 const FIELDS: &[&str] = &[
1767 "memory",
1768 "os",
1769 "cpu",
1770 ];
1771
1772 #[allow(clippy::enum_variant_names)]
1773 enum GeneratedField {
1774 Memory,
1775 Os,
1776 Cpu,
1777 }
1778 impl<'de> serde::Deserialize<'de> for GeneratedField {
1779 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1780 where
1781 D: serde::Deserializer<'de>,
1782 {
1783 struct GeneratedVisitor;
1784
1785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1786 type Value = GeneratedField;
1787
1788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1789 write!(formatter, "expected one of: {:?}", &FIELDS)
1790 }
1791
1792 #[allow(unused_variables)]
1793 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1794 where
1795 E: serde::de::Error,
1796 {
1797 match value {
1798 "memory" => Ok(GeneratedField::Memory),
1799 "os" => Ok(GeneratedField::Os),
1800 "cpu" => Ok(GeneratedField::Cpu),
1801 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1802 }
1803 }
1804 }
1805 deserializer.deserialize_identifier(GeneratedVisitor)
1806 }
1807 }
1808 struct GeneratedVisitor;
1809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1810 type Value = SystemData;
1811
1812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1813 formatter.write_str("struct telemetry.SystemData")
1814 }
1815
1816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemData, V::Error>
1817 where
1818 V: serde::de::MapAccess<'de>,
1819 {
1820 let mut memory__ = None;
1821 let mut os__ = None;
1822 let mut cpu__ = None;
1823 while let Some(k) = map_.next_key()? {
1824 match k {
1825 GeneratedField::Memory => {
1826 if memory__.is_some() {
1827 return Err(serde::de::Error::duplicate_field("memory"));
1828 }
1829 memory__ = map_.next_value()?;
1830 }
1831 GeneratedField::Os => {
1832 if os__.is_some() {
1833 return Err(serde::de::Error::duplicate_field("os"));
1834 }
1835 os__ = map_.next_value()?;
1836 }
1837 GeneratedField::Cpu => {
1838 if cpu__.is_some() {
1839 return Err(serde::de::Error::duplicate_field("cpu"));
1840 }
1841 cpu__ = map_.next_value()?;
1842 }
1843 }
1844 }
1845 Ok(SystemData {
1846 memory: memory__,
1847 os: os__,
1848 cpu: cpu__,
1849 })
1850 }
1851 }
1852 deserializer.deserialize_struct("telemetry.SystemData", FIELDS, GeneratedVisitor)
1853 }
1854}
1855impl serde::Serialize for SystemMemory {
1856 #[allow(deprecated)]
1857 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1858 where
1859 S: serde::Serializer,
1860 {
1861 use serde::ser::SerializeStruct;
1862 let mut len = 0;
1863 if self.used != 0 {
1864 len += 1;
1865 }
1866 if self.total != 0 {
1867 len += 1;
1868 }
1869 let mut struct_ser = serializer.serialize_struct("telemetry.SystemMemory", len)?;
1870 if self.used != 0 {
1871 #[allow(clippy::needless_borrow)]
1872 #[allow(clippy::needless_borrows_for_generic_args)]
1873 struct_ser.serialize_field("used", ToString::to_string(&self.used).as_str())?;
1874 }
1875 if self.total != 0 {
1876 #[allow(clippy::needless_borrow)]
1877 #[allow(clippy::needless_borrows_for_generic_args)]
1878 struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?;
1879 }
1880 struct_ser.end()
1881 }
1882}
1883impl<'de> serde::Deserialize<'de> for SystemMemory {
1884 #[allow(deprecated)]
1885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1886 where
1887 D: serde::Deserializer<'de>,
1888 {
1889 const FIELDS: &[&str] = &[
1890 "used",
1891 "total",
1892 ];
1893
1894 #[allow(clippy::enum_variant_names)]
1895 enum GeneratedField {
1896 Used,
1897 Total,
1898 }
1899 impl<'de> serde::Deserialize<'de> for GeneratedField {
1900 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1901 where
1902 D: serde::Deserializer<'de>,
1903 {
1904 struct GeneratedVisitor;
1905
1906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1907 type Value = GeneratedField;
1908
1909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1910 write!(formatter, "expected one of: {:?}", &FIELDS)
1911 }
1912
1913 #[allow(unused_variables)]
1914 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1915 where
1916 E: serde::de::Error,
1917 {
1918 match value {
1919 "used" => Ok(GeneratedField::Used),
1920 "total" => Ok(GeneratedField::Total),
1921 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1922 }
1923 }
1924 }
1925 deserializer.deserialize_identifier(GeneratedVisitor)
1926 }
1927 }
1928 struct GeneratedVisitor;
1929 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1930 type Value = SystemMemory;
1931
1932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1933 formatter.write_str("struct telemetry.SystemMemory")
1934 }
1935
1936 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemMemory, V::Error>
1937 where
1938 V: serde::de::MapAccess<'de>,
1939 {
1940 let mut used__ = None;
1941 let mut total__ = None;
1942 while let Some(k) = map_.next_key()? {
1943 match k {
1944 GeneratedField::Used => {
1945 if used__.is_some() {
1946 return Err(serde::de::Error::duplicate_field("used"));
1947 }
1948 used__ =
1949 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1950 ;
1951 }
1952 GeneratedField::Total => {
1953 if total__.is_some() {
1954 return Err(serde::de::Error::duplicate_field("total"));
1955 }
1956 total__ =
1957 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1958 ;
1959 }
1960 }
1961 }
1962 Ok(SystemMemory {
1963 used: used__.unwrap_or_default(),
1964 total: total__.unwrap_or_default(),
1965 })
1966 }
1967 }
1968 deserializer.deserialize_struct("telemetry.SystemMemory", FIELDS, GeneratedVisitor)
1969 }
1970}
1971impl serde::Serialize for SystemOs {
1972 #[allow(deprecated)]
1973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1974 where
1975 S: serde::Serializer,
1976 {
1977 use serde::ser::SerializeStruct;
1978 let mut len = 0;
1979 if !self.name.is_empty() {
1980 len += 1;
1981 }
1982 if !self.version.is_empty() {
1983 len += 1;
1984 }
1985 if !self.kernel_version.is_empty() {
1986 len += 1;
1987 }
1988 let mut struct_ser = serializer.serialize_struct("telemetry.SystemOs", len)?;
1989 if !self.name.is_empty() {
1990 struct_ser.serialize_field("name", &self.name)?;
1991 }
1992 if !self.version.is_empty() {
1993 struct_ser.serialize_field("version", &self.version)?;
1994 }
1995 if !self.kernel_version.is_empty() {
1996 struct_ser.serialize_field("kernelVersion", &self.kernel_version)?;
1997 }
1998 struct_ser.end()
1999 }
2000}
2001impl<'de> serde::Deserialize<'de> for SystemOs {
2002 #[allow(deprecated)]
2003 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2004 where
2005 D: serde::Deserializer<'de>,
2006 {
2007 const FIELDS: &[&str] = &[
2008 "name",
2009 "version",
2010 "kernel_version",
2011 "kernelVersion",
2012 ];
2013
2014 #[allow(clippy::enum_variant_names)]
2015 enum GeneratedField {
2016 Name,
2017 Version,
2018 KernelVersion,
2019 }
2020 impl<'de> serde::Deserialize<'de> for GeneratedField {
2021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2022 where
2023 D: serde::Deserializer<'de>,
2024 {
2025 struct GeneratedVisitor;
2026
2027 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2028 type Value = GeneratedField;
2029
2030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2031 write!(formatter, "expected one of: {:?}", &FIELDS)
2032 }
2033
2034 #[allow(unused_variables)]
2035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2036 where
2037 E: serde::de::Error,
2038 {
2039 match value {
2040 "name" => Ok(GeneratedField::Name),
2041 "version" => Ok(GeneratedField::Version),
2042 "kernelVersion" | "kernel_version" => Ok(GeneratedField::KernelVersion),
2043 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2044 }
2045 }
2046 }
2047 deserializer.deserialize_identifier(GeneratedVisitor)
2048 }
2049 }
2050 struct GeneratedVisitor;
2051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2052 type Value = SystemOs;
2053
2054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2055 formatter.write_str("struct telemetry.SystemOs")
2056 }
2057
2058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemOs, V::Error>
2059 where
2060 V: serde::de::MapAccess<'de>,
2061 {
2062 let mut name__ = None;
2063 let mut version__ = None;
2064 let mut kernel_version__ = None;
2065 while let Some(k) = map_.next_key()? {
2066 match k {
2067 GeneratedField::Name => {
2068 if name__.is_some() {
2069 return Err(serde::de::Error::duplicate_field("name"));
2070 }
2071 name__ = Some(map_.next_value()?);
2072 }
2073 GeneratedField::Version => {
2074 if version__.is_some() {
2075 return Err(serde::de::Error::duplicate_field("version"));
2076 }
2077 version__ = Some(map_.next_value()?);
2078 }
2079 GeneratedField::KernelVersion => {
2080 if kernel_version__.is_some() {
2081 return Err(serde::de::Error::duplicate_field("kernelVersion"));
2082 }
2083 kernel_version__ = Some(map_.next_value()?);
2084 }
2085 }
2086 }
2087 Ok(SystemOs {
2088 name: name__.unwrap_or_default(),
2089 version: version__.unwrap_or_default(),
2090 kernel_version: kernel_version__.unwrap_or_default(),
2091 })
2092 }
2093 }
2094 deserializer.deserialize_struct("telemetry.SystemOs", FIELDS, GeneratedVisitor)
2095 }
2096}
2097impl serde::Serialize for TelemetryClusterType {
2098 #[allow(deprecated)]
2099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2100 where
2101 S: serde::Serializer,
2102 {
2103 let variant = match self {
2104 Self::Unspecified => "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED",
2105 Self::SingleNode => "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE",
2106 Self::DockerCompose => "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE",
2107 Self::Kubernetes => "TELEMETRY_CLUSTER_TYPE_KUBERNETES",
2108 Self::CloudHosted => "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED",
2109 };
2110 serializer.serialize_str(variant)
2111 }
2112}
2113impl<'de> serde::Deserialize<'de> for TelemetryClusterType {
2114 #[allow(deprecated)]
2115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2116 where
2117 D: serde::Deserializer<'de>,
2118 {
2119 const FIELDS: &[&str] = &[
2120 "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED",
2121 "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE",
2122 "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE",
2123 "TELEMETRY_CLUSTER_TYPE_KUBERNETES",
2124 "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED",
2125 ];
2126
2127 struct GeneratedVisitor;
2128
2129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2130 type Value = TelemetryClusterType;
2131
2132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2133 write!(formatter, "expected one of: {:?}", &FIELDS)
2134 }
2135
2136 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2137 where
2138 E: serde::de::Error,
2139 {
2140 i32::try_from(v)
2141 .ok()
2142 .and_then(|x| x.try_into().ok())
2143 .ok_or_else(|| {
2144 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2145 })
2146 }
2147
2148 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2149 where
2150 E: serde::de::Error,
2151 {
2152 i32::try_from(v)
2153 .ok()
2154 .and_then(|x| x.try_into().ok())
2155 .ok_or_else(|| {
2156 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2157 })
2158 }
2159
2160 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2161 where
2162 E: serde::de::Error,
2163 {
2164 match value {
2165 "TELEMETRY_CLUSTER_TYPE_UNSPECIFIED" => Ok(TelemetryClusterType::Unspecified),
2166 "TELEMETRY_CLUSTER_TYPE_SINGLE_NODE" => Ok(TelemetryClusterType::SingleNode),
2167 "TELEMETRY_CLUSTER_TYPE_DOCKER_COMPOSE" => Ok(TelemetryClusterType::DockerCompose),
2168 "TELEMETRY_CLUSTER_TYPE_KUBERNETES" => Ok(TelemetryClusterType::Kubernetes),
2169 "TELEMETRY_CLUSTER_TYPE_CLOUD_HOSTED" => Ok(TelemetryClusterType::CloudHosted),
2170 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2171 }
2172 }
2173 }
2174 deserializer.deserialize_any(GeneratedVisitor)
2175 }
2176}
2177impl serde::Serialize for TelemetryDatabaseObject {
2178 #[allow(deprecated)]
2179 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2180 where
2181 S: serde::Serializer,
2182 {
2183 let variant = match self {
2184 Self::Unspecified => "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED",
2185 Self::Source => "TELEMETRY_DATABASE_OBJECT_SOURCE",
2186 Self::Mv => "TELEMETRY_DATABASE_OBJECT_MV",
2187 Self::Table => "TELEMETRY_DATABASE_OBJECT_TABLE",
2188 Self::Sink => "TELEMETRY_DATABASE_OBJECT_SINK",
2189 Self::Index => "TELEMETRY_DATABASE_OBJECT_INDEX",
2190 };
2191 serializer.serialize_str(variant)
2192 }
2193}
2194impl<'de> serde::Deserialize<'de> for TelemetryDatabaseObject {
2195 #[allow(deprecated)]
2196 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2197 where
2198 D: serde::Deserializer<'de>,
2199 {
2200 const FIELDS: &[&str] = &[
2201 "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED",
2202 "TELEMETRY_DATABASE_OBJECT_SOURCE",
2203 "TELEMETRY_DATABASE_OBJECT_MV",
2204 "TELEMETRY_DATABASE_OBJECT_TABLE",
2205 "TELEMETRY_DATABASE_OBJECT_SINK",
2206 "TELEMETRY_DATABASE_OBJECT_INDEX",
2207 ];
2208
2209 struct GeneratedVisitor;
2210
2211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2212 type Value = TelemetryDatabaseObject;
2213
2214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2215 write!(formatter, "expected one of: {:?}", &FIELDS)
2216 }
2217
2218 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2219 where
2220 E: serde::de::Error,
2221 {
2222 i32::try_from(v)
2223 .ok()
2224 .and_then(|x| x.try_into().ok())
2225 .ok_or_else(|| {
2226 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2227 })
2228 }
2229
2230 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2231 where
2232 E: serde::de::Error,
2233 {
2234 i32::try_from(v)
2235 .ok()
2236 .and_then(|x| x.try_into().ok())
2237 .ok_or_else(|| {
2238 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2239 })
2240 }
2241
2242 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2243 where
2244 E: serde::de::Error,
2245 {
2246 match value {
2247 "TELEMETRY_DATABASE_OBJECT_UNSPECIFIED" => Ok(TelemetryDatabaseObject::Unspecified),
2248 "TELEMETRY_DATABASE_OBJECT_SOURCE" => Ok(TelemetryDatabaseObject::Source),
2249 "TELEMETRY_DATABASE_OBJECT_MV" => Ok(TelemetryDatabaseObject::Mv),
2250 "TELEMETRY_DATABASE_OBJECT_TABLE" => Ok(TelemetryDatabaseObject::Table),
2251 "TELEMETRY_DATABASE_OBJECT_SINK" => Ok(TelemetryDatabaseObject::Sink),
2252 "TELEMETRY_DATABASE_OBJECT_INDEX" => Ok(TelemetryDatabaseObject::Index),
2253 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2254 }
2255 }
2256 }
2257 deserializer.deserialize_any(GeneratedVisitor)
2258 }
2259}
2260impl serde::Serialize for TelemetryEventStage {
2261 #[allow(deprecated)]
2262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2263 where
2264 S: serde::Serializer,
2265 {
2266 let variant = match self {
2267 Self::Unspecified => "TELEMETRY_EVENT_STAGE_UNSPECIFIED",
2268 Self::CreateStreamJob => "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB",
2269 Self::UpdateStreamJob => "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB",
2270 Self::DropStreamJob => "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB",
2271 Self::Query => "TELEMETRY_EVENT_STAGE_QUERY",
2272 Self::Recovery => "TELEMETRY_EVENT_STAGE_RECOVERY",
2273 };
2274 serializer.serialize_str(variant)
2275 }
2276}
2277impl<'de> serde::Deserialize<'de> for TelemetryEventStage {
2278 #[allow(deprecated)]
2279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2280 where
2281 D: serde::Deserializer<'de>,
2282 {
2283 const FIELDS: &[&str] = &[
2284 "TELEMETRY_EVENT_STAGE_UNSPECIFIED",
2285 "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB",
2286 "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB",
2287 "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB",
2288 "TELEMETRY_EVENT_STAGE_QUERY",
2289 "TELEMETRY_EVENT_STAGE_RECOVERY",
2290 ];
2291
2292 struct GeneratedVisitor;
2293
2294 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2295 type Value = TelemetryEventStage;
2296
2297 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2298 write!(formatter, "expected one of: {:?}", &FIELDS)
2299 }
2300
2301 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2302 where
2303 E: serde::de::Error,
2304 {
2305 i32::try_from(v)
2306 .ok()
2307 .and_then(|x| x.try_into().ok())
2308 .ok_or_else(|| {
2309 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2310 })
2311 }
2312
2313 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2314 where
2315 E: serde::de::Error,
2316 {
2317 i32::try_from(v)
2318 .ok()
2319 .and_then(|x| x.try_into().ok())
2320 .ok_or_else(|| {
2321 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2322 })
2323 }
2324
2325 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2326 where
2327 E: serde::de::Error,
2328 {
2329 match value {
2330 "TELEMETRY_EVENT_STAGE_UNSPECIFIED" => Ok(TelemetryEventStage::Unspecified),
2331 "TELEMETRY_EVENT_STAGE_CREATE_STREAM_JOB" => Ok(TelemetryEventStage::CreateStreamJob),
2332 "TELEMETRY_EVENT_STAGE_UPDATE_STREAM_JOB" => Ok(TelemetryEventStage::UpdateStreamJob),
2333 "TELEMETRY_EVENT_STAGE_DROP_STREAM_JOB" => Ok(TelemetryEventStage::DropStreamJob),
2334 "TELEMETRY_EVENT_STAGE_QUERY" => Ok(TelemetryEventStage::Query),
2335 "TELEMETRY_EVENT_STAGE_RECOVERY" => Ok(TelemetryEventStage::Recovery),
2336 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2337 }
2338 }
2339 }
2340 deserializer.deserialize_any(GeneratedVisitor)
2341 }
2342}
2343impl serde::Serialize for TelemetryNodeType {
2344 #[allow(deprecated)]
2345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2346 where
2347 S: serde::Serializer,
2348 {
2349 let variant = match self {
2350 Self::Unspecified => "TELEMETRY_NODE_TYPE_UNSPECIFIED",
2351 Self::Meta => "TELEMETRY_NODE_TYPE_META",
2352 Self::Compute => "TELEMETRY_NODE_TYPE_COMPUTE",
2353 Self::Frontend => "TELEMETRY_NODE_TYPE_FRONTEND",
2354 Self::Compactor => "TELEMETRY_NODE_TYPE_COMPACTOR",
2355 };
2356 serializer.serialize_str(variant)
2357 }
2358}
2359impl<'de> serde::Deserialize<'de> for TelemetryNodeType {
2360 #[allow(deprecated)]
2361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2362 where
2363 D: serde::Deserializer<'de>,
2364 {
2365 const FIELDS: &[&str] = &[
2366 "TELEMETRY_NODE_TYPE_UNSPECIFIED",
2367 "TELEMETRY_NODE_TYPE_META",
2368 "TELEMETRY_NODE_TYPE_COMPUTE",
2369 "TELEMETRY_NODE_TYPE_FRONTEND",
2370 "TELEMETRY_NODE_TYPE_COMPACTOR",
2371 ];
2372
2373 struct GeneratedVisitor;
2374
2375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2376 type Value = TelemetryNodeType;
2377
2378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2379 write!(formatter, "expected one of: {:?}", &FIELDS)
2380 }
2381
2382 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2383 where
2384 E: serde::de::Error,
2385 {
2386 i32::try_from(v)
2387 .ok()
2388 .and_then(|x| x.try_into().ok())
2389 .ok_or_else(|| {
2390 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2391 })
2392 }
2393
2394 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2395 where
2396 E: serde::de::Error,
2397 {
2398 i32::try_from(v)
2399 .ok()
2400 .and_then(|x| x.try_into().ok())
2401 .ok_or_else(|| {
2402 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2403 })
2404 }
2405
2406 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2407 where
2408 E: serde::de::Error,
2409 {
2410 match value {
2411 "TELEMETRY_NODE_TYPE_UNSPECIFIED" => Ok(TelemetryNodeType::Unspecified),
2412 "TELEMETRY_NODE_TYPE_META" => Ok(TelemetryNodeType::Meta),
2413 "TELEMETRY_NODE_TYPE_COMPUTE" => Ok(TelemetryNodeType::Compute),
2414 "TELEMETRY_NODE_TYPE_FRONTEND" => Ok(TelemetryNodeType::Frontend),
2415 "TELEMETRY_NODE_TYPE_COMPACTOR" => Ok(TelemetryNodeType::Compactor),
2416 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2417 }
2418 }
2419 }
2420 deserializer.deserialize_any(GeneratedVisitor)
2421 }
2422}