1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::monitor_service::*;
4impl serde::Serialize for AnalyzeHeapRequest {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if !self.path.is_empty() {
13 len += 1;
14 }
15 let mut struct_ser = serializer.serialize_struct("monitor_service.AnalyzeHeapRequest", len)?;
16 if !self.path.is_empty() {
17 struct_ser.serialize_field("path", &self.path)?;
18 }
19 struct_ser.end()
20 }
21}
22impl<'de> serde::Deserialize<'de> for AnalyzeHeapRequest {
23 #[allow(deprecated)]
24 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
25 where
26 D: serde::Deserializer<'de>,
27 {
28 const FIELDS: &[&str] = &[
29 "path",
30 ];
31
32 #[allow(clippy::enum_variant_names)]
33 enum GeneratedField {
34 Path,
35 }
36 impl<'de> serde::Deserialize<'de> for GeneratedField {
37 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
38 where
39 D: serde::Deserializer<'de>,
40 {
41 struct GeneratedVisitor;
42
43 impl serde::de::Visitor<'_> for GeneratedVisitor {
44 type Value = GeneratedField;
45
46 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47 write!(formatter, "expected one of: {:?}", &FIELDS)
48 }
49
50 #[allow(unused_variables)]
51 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
52 where
53 E: serde::de::Error,
54 {
55 match value {
56 "path" => Ok(GeneratedField::Path),
57 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
58 }
59 }
60 }
61 deserializer.deserialize_identifier(GeneratedVisitor)
62 }
63 }
64 struct GeneratedVisitor;
65 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
66 type Value = AnalyzeHeapRequest;
67
68 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
69 formatter.write_str("struct monitor_service.AnalyzeHeapRequest")
70 }
71
72 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AnalyzeHeapRequest, V::Error>
73 where
74 V: serde::de::MapAccess<'de>,
75 {
76 let mut path__ = None;
77 while let Some(k) = map_.next_key()? {
78 match k {
79 GeneratedField::Path => {
80 if path__.is_some() {
81 return Err(serde::de::Error::duplicate_field("path"));
82 }
83 path__ = Some(map_.next_value()?);
84 }
85 }
86 }
87 Ok(AnalyzeHeapRequest {
88 path: path__.unwrap_or_default(),
89 })
90 }
91 }
92 deserializer.deserialize_struct("monitor_service.AnalyzeHeapRequest", FIELDS, GeneratedVisitor)
93 }
94}
95impl serde::Serialize for AnalyzeHeapResponse {
96 #[allow(deprecated)]
97 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
98 where
99 S: serde::Serializer,
100 {
101 use serde::ser::SerializeStruct;
102 let mut len = 0;
103 if !self.result.is_empty() {
104 len += 1;
105 }
106 let mut struct_ser = serializer.serialize_struct("monitor_service.AnalyzeHeapResponse", len)?;
107 if !self.result.is_empty() {
108 #[allow(clippy::needless_borrow)]
109 #[allow(clippy::needless_borrows_for_generic_args)]
110 struct_ser.serialize_field("result", pbjson::private::base64::encode(&self.result).as_str())?;
111 }
112 struct_ser.end()
113 }
114}
115impl<'de> serde::Deserialize<'de> for AnalyzeHeapResponse {
116 #[allow(deprecated)]
117 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
118 where
119 D: serde::Deserializer<'de>,
120 {
121 const FIELDS: &[&str] = &[
122 "result",
123 ];
124
125 #[allow(clippy::enum_variant_names)]
126 enum GeneratedField {
127 Result,
128 }
129 impl<'de> serde::Deserialize<'de> for GeneratedField {
130 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
131 where
132 D: serde::Deserializer<'de>,
133 {
134 struct GeneratedVisitor;
135
136 impl serde::de::Visitor<'_> for GeneratedVisitor {
137 type Value = GeneratedField;
138
139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
140 write!(formatter, "expected one of: {:?}", &FIELDS)
141 }
142
143 #[allow(unused_variables)]
144 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
145 where
146 E: serde::de::Error,
147 {
148 match value {
149 "result" => Ok(GeneratedField::Result),
150 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
151 }
152 }
153 }
154 deserializer.deserialize_identifier(GeneratedVisitor)
155 }
156 }
157 struct GeneratedVisitor;
158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
159 type Value = AnalyzeHeapResponse;
160
161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
162 formatter.write_str("struct monitor_service.AnalyzeHeapResponse")
163 }
164
165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AnalyzeHeapResponse, V::Error>
166 where
167 V: serde::de::MapAccess<'de>,
168 {
169 let mut result__ = None;
170 while let Some(k) = map_.next_key()? {
171 match k {
172 GeneratedField::Result => {
173 if result__.is_some() {
174 return Err(serde::de::Error::duplicate_field("result"));
175 }
176 result__ =
177 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
178 ;
179 }
180 }
181 }
182 Ok(AnalyzeHeapResponse {
183 result: result__.unwrap_or_default(),
184 })
185 }
186 }
187 deserializer.deserialize_struct("monitor_service.AnalyzeHeapResponse", FIELDS, GeneratedVisitor)
188 }
189}
190impl serde::Serialize for ChannelDeltaStats {
191 #[allow(deprecated)]
192 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
193 where
194 S: serde::Serializer,
195 {
196 use serde::ser::SerializeStruct;
197 let mut len = 0;
198 if self.actor_count != 0 {
199 len += 1;
200 }
201 if self.backpressure_rate != 0. {
202 len += 1;
203 }
204 if self.recv_throughput != 0. {
205 len += 1;
206 }
207 if self.send_throughput != 0. {
208 len += 1;
209 }
210 let mut struct_ser = serializer.serialize_struct("monitor_service.ChannelDeltaStats", len)?;
211 if self.actor_count != 0 {
212 struct_ser.serialize_field("n", &self.actor_count)?;
213 }
214 if self.backpressure_rate != 0. {
215 struct_ser.serialize_field("b", &self.backpressure_rate)?;
216 }
217 if self.recv_throughput != 0. {
218 struct_ser.serialize_field("i", &self.recv_throughput)?;
219 }
220 if self.send_throughput != 0. {
221 struct_ser.serialize_field("o", &self.send_throughput)?;
222 }
223 struct_ser.end()
224 }
225}
226impl<'de> serde::Deserialize<'de> for ChannelDeltaStats {
227 #[allow(deprecated)]
228 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
229 where
230 D: serde::Deserializer<'de>,
231 {
232 const FIELDS: &[&str] = &[
233 "actor_count",
234 "n",
235 "backpressure_rate",
236 "b",
237 "recv_throughput",
238 "i",
239 "send_throughput",
240 "o",
241 ];
242
243 #[allow(clippy::enum_variant_names)]
244 enum GeneratedField {
245 ActorCount,
246 BackpressureRate,
247 RecvThroughput,
248 SendThroughput,
249 }
250 impl<'de> serde::Deserialize<'de> for GeneratedField {
251 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
252 where
253 D: serde::Deserializer<'de>,
254 {
255 struct GeneratedVisitor;
256
257 impl serde::de::Visitor<'_> for GeneratedVisitor {
258 type Value = GeneratedField;
259
260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
261 write!(formatter, "expected one of: {:?}", &FIELDS)
262 }
263
264 #[allow(unused_variables)]
265 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
266 where
267 E: serde::de::Error,
268 {
269 match value {
270 "n" | "actor_count" => Ok(GeneratedField::ActorCount),
271 "b" | "backpressure_rate" => Ok(GeneratedField::BackpressureRate),
272 "i" | "recv_throughput" => Ok(GeneratedField::RecvThroughput),
273 "o" | "send_throughput" => Ok(GeneratedField::SendThroughput),
274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
275 }
276 }
277 }
278 deserializer.deserialize_identifier(GeneratedVisitor)
279 }
280 }
281 struct GeneratedVisitor;
282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
283 type Value = ChannelDeltaStats;
284
285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
286 formatter.write_str("struct monitor_service.ChannelDeltaStats")
287 }
288
289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChannelDeltaStats, V::Error>
290 where
291 V: serde::de::MapAccess<'de>,
292 {
293 let mut actor_count__ = None;
294 let mut backpressure_rate__ = None;
295 let mut recv_throughput__ = None;
296 let mut send_throughput__ = None;
297 while let Some(k) = map_.next_key()? {
298 match k {
299 GeneratedField::ActorCount => {
300 if actor_count__.is_some() {
301 return Err(serde::de::Error::duplicate_field("n"));
302 }
303 actor_count__ =
304 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
305 ;
306 }
307 GeneratedField::BackpressureRate => {
308 if backpressure_rate__.is_some() {
309 return Err(serde::de::Error::duplicate_field("b"));
310 }
311 backpressure_rate__ =
312 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
313 ;
314 }
315 GeneratedField::RecvThroughput => {
316 if recv_throughput__.is_some() {
317 return Err(serde::de::Error::duplicate_field("i"));
318 }
319 recv_throughput__ =
320 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
321 ;
322 }
323 GeneratedField::SendThroughput => {
324 if send_throughput__.is_some() {
325 return Err(serde::de::Error::duplicate_field("o"));
326 }
327 send_throughput__ =
328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
329 ;
330 }
331 }
332 }
333 Ok(ChannelDeltaStats {
334 actor_count: actor_count__.unwrap_or_default(),
335 backpressure_rate: backpressure_rate__.unwrap_or_default(),
336 recv_throughput: recv_throughput__.unwrap_or_default(),
337 send_throughput: send_throughput__.unwrap_or_default(),
338 })
339 }
340 }
341 deserializer.deserialize_struct("monitor_service.ChannelDeltaStats", FIELDS, GeneratedVisitor)
342 }
343}
344impl serde::Serialize for ChannelStats {
345 #[allow(deprecated)]
346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
347 where
348 S: serde::Serializer,
349 {
350 use serde::ser::SerializeStruct;
351 let mut len = 0;
352 if self.actor_count != 0 {
353 len += 1;
354 }
355 if self.output_blocking_duration != 0. {
356 len += 1;
357 }
358 if self.recv_row_count != 0 {
359 len += 1;
360 }
361 if self.send_row_count != 0 {
362 len += 1;
363 }
364 let mut struct_ser = serializer.serialize_struct("monitor_service.ChannelStats", len)?;
365 if self.actor_count != 0 {
366 struct_ser.serialize_field("n", &self.actor_count)?;
367 }
368 if self.output_blocking_duration != 0. {
369 struct_ser.serialize_field("b", &self.output_blocking_duration)?;
370 }
371 if self.recv_row_count != 0 {
372 #[allow(clippy::needless_borrow)]
373 #[allow(clippy::needless_borrows_for_generic_args)]
374 struct_ser.serialize_field("i", ToString::to_string(&self.recv_row_count).as_str())?;
375 }
376 if self.send_row_count != 0 {
377 #[allow(clippy::needless_borrow)]
378 #[allow(clippy::needless_borrows_for_generic_args)]
379 struct_ser.serialize_field("o", ToString::to_string(&self.send_row_count).as_str())?;
380 }
381 struct_ser.end()
382 }
383}
384impl<'de> serde::Deserialize<'de> for ChannelStats {
385 #[allow(deprecated)]
386 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
387 where
388 D: serde::Deserializer<'de>,
389 {
390 const FIELDS: &[&str] = &[
391 "actor_count",
392 "n",
393 "output_blocking_duration",
394 "b",
395 "recv_row_count",
396 "i",
397 "send_row_count",
398 "o",
399 ];
400
401 #[allow(clippy::enum_variant_names)]
402 enum GeneratedField {
403 ActorCount,
404 OutputBlockingDuration,
405 RecvRowCount,
406 SendRowCount,
407 }
408 impl<'de> serde::Deserialize<'de> for GeneratedField {
409 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
410 where
411 D: serde::Deserializer<'de>,
412 {
413 struct GeneratedVisitor;
414
415 impl serde::de::Visitor<'_> for GeneratedVisitor {
416 type Value = GeneratedField;
417
418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
419 write!(formatter, "expected one of: {:?}", &FIELDS)
420 }
421
422 #[allow(unused_variables)]
423 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
424 where
425 E: serde::de::Error,
426 {
427 match value {
428 "n" | "actor_count" => Ok(GeneratedField::ActorCount),
429 "b" | "output_blocking_duration" => Ok(GeneratedField::OutputBlockingDuration),
430 "i" | "recv_row_count" => Ok(GeneratedField::RecvRowCount),
431 "o" | "send_row_count" => Ok(GeneratedField::SendRowCount),
432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
433 }
434 }
435 }
436 deserializer.deserialize_identifier(GeneratedVisitor)
437 }
438 }
439 struct GeneratedVisitor;
440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
441 type Value = ChannelStats;
442
443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
444 formatter.write_str("struct monitor_service.ChannelStats")
445 }
446
447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChannelStats, V::Error>
448 where
449 V: serde::de::MapAccess<'de>,
450 {
451 let mut actor_count__ = None;
452 let mut output_blocking_duration__ = None;
453 let mut recv_row_count__ = None;
454 let mut send_row_count__ = None;
455 while let Some(k) = map_.next_key()? {
456 match k {
457 GeneratedField::ActorCount => {
458 if actor_count__.is_some() {
459 return Err(serde::de::Error::duplicate_field("n"));
460 }
461 actor_count__ =
462 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
463 ;
464 }
465 GeneratedField::OutputBlockingDuration => {
466 if output_blocking_duration__.is_some() {
467 return Err(serde::de::Error::duplicate_field("b"));
468 }
469 output_blocking_duration__ =
470 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
471 ;
472 }
473 GeneratedField::RecvRowCount => {
474 if recv_row_count__.is_some() {
475 return Err(serde::de::Error::duplicate_field("i"));
476 }
477 recv_row_count__ =
478 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
479 ;
480 }
481 GeneratedField::SendRowCount => {
482 if send_row_count__.is_some() {
483 return Err(serde::de::Error::duplicate_field("o"));
484 }
485 send_row_count__ =
486 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
487 ;
488 }
489 }
490 }
491 Ok(ChannelStats {
492 actor_count: actor_count__.unwrap_or_default(),
493 output_blocking_duration: output_blocking_duration__.unwrap_or_default(),
494 recv_row_count: recv_row_count__.unwrap_or_default(),
495 send_row_count: send_row_count__.unwrap_or_default(),
496 })
497 }
498 }
499 deserializer.deserialize_struct("monitor_service.ChannelStats", FIELDS, GeneratedVisitor)
500 }
501}
502impl serde::Serialize for FragmentStats {
503 #[allow(deprecated)]
504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
505 where
506 S: serde::Serializer,
507 {
508 use serde::ser::SerializeStruct;
509 let mut len = 0;
510 if self.actor_count != 0 {
511 len += 1;
512 }
513 if self.current_epoch != 0 {
514 len += 1;
515 }
516 let mut struct_ser = serializer.serialize_struct("monitor_service.FragmentStats", len)?;
517 if self.actor_count != 0 {
518 struct_ser.serialize_field("n", &self.actor_count)?;
519 }
520 if self.current_epoch != 0 {
521 #[allow(clippy::needless_borrow)]
522 #[allow(clippy::needless_borrows_for_generic_args)]
523 struct_ser.serialize_field("e", ToString::to_string(&self.current_epoch).as_str())?;
524 }
525 struct_ser.end()
526 }
527}
528impl<'de> serde::Deserialize<'de> for FragmentStats {
529 #[allow(deprecated)]
530 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
531 where
532 D: serde::Deserializer<'de>,
533 {
534 const FIELDS: &[&str] = &[
535 "actor_count",
536 "n",
537 "current_epoch",
538 "e",
539 ];
540
541 #[allow(clippy::enum_variant_names)]
542 enum GeneratedField {
543 ActorCount,
544 CurrentEpoch,
545 }
546 impl<'de> serde::Deserialize<'de> for GeneratedField {
547 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
548 where
549 D: serde::Deserializer<'de>,
550 {
551 struct GeneratedVisitor;
552
553 impl serde::de::Visitor<'_> for GeneratedVisitor {
554 type Value = GeneratedField;
555
556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
557 write!(formatter, "expected one of: {:?}", &FIELDS)
558 }
559
560 #[allow(unused_variables)]
561 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
562 where
563 E: serde::de::Error,
564 {
565 match value {
566 "n" | "actor_count" => Ok(GeneratedField::ActorCount),
567 "e" | "current_epoch" => Ok(GeneratedField::CurrentEpoch),
568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
569 }
570 }
571 }
572 deserializer.deserialize_identifier(GeneratedVisitor)
573 }
574 }
575 struct GeneratedVisitor;
576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
577 type Value = FragmentStats;
578
579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
580 formatter.write_str("struct monitor_service.FragmentStats")
581 }
582
583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentStats, V::Error>
584 where
585 V: serde::de::MapAccess<'de>,
586 {
587 let mut actor_count__ = None;
588 let mut current_epoch__ = None;
589 while let Some(k) = map_.next_key()? {
590 match k {
591 GeneratedField::ActorCount => {
592 if actor_count__.is_some() {
593 return Err(serde::de::Error::duplicate_field("n"));
594 }
595 actor_count__ =
596 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
597 ;
598 }
599 GeneratedField::CurrentEpoch => {
600 if current_epoch__.is_some() {
601 return Err(serde::de::Error::duplicate_field("e"));
602 }
603 current_epoch__ =
604 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
605 ;
606 }
607 }
608 }
609 Ok(FragmentStats {
610 actor_count: actor_count__.unwrap_or_default(),
611 current_epoch: current_epoch__.unwrap_or_default(),
612 })
613 }
614 }
615 deserializer.deserialize_struct("monitor_service.FragmentStats", FIELDS, GeneratedVisitor)
616 }
617}
618impl serde::Serialize for GetProfileStatsRequest {
619 #[allow(deprecated)]
620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
621 where
622 S: serde::Serializer,
623 {
624 use serde::ser::SerializeStruct;
625 let mut len = 0;
626 if !self.executor_ids.is_empty() {
627 len += 1;
628 }
629 if !self.dispatcher_fragment_ids.is_empty() {
630 len += 1;
631 }
632 let mut struct_ser = serializer.serialize_struct("monitor_service.GetProfileStatsRequest", len)?;
633 if !self.executor_ids.is_empty() {
634 struct_ser.serialize_field("executorIds", &self.executor_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
635 }
636 if !self.dispatcher_fragment_ids.is_empty() {
637 struct_ser.serialize_field("dispatcherFragmentIds", &self.dispatcher_fragment_ids)?;
638 }
639 struct_ser.end()
640 }
641}
642impl<'de> serde::Deserialize<'de> for GetProfileStatsRequest {
643 #[allow(deprecated)]
644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
645 where
646 D: serde::Deserializer<'de>,
647 {
648 const FIELDS: &[&str] = &[
649 "executor_ids",
650 "executorIds",
651 "dispatcher_fragment_ids",
652 "dispatcherFragmentIds",
653 ];
654
655 #[allow(clippy::enum_variant_names)]
656 enum GeneratedField {
657 ExecutorIds,
658 DispatcherFragmentIds,
659 }
660 impl<'de> serde::Deserialize<'de> for GeneratedField {
661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
662 where
663 D: serde::Deserializer<'de>,
664 {
665 struct GeneratedVisitor;
666
667 impl serde::de::Visitor<'_> for GeneratedVisitor {
668 type Value = GeneratedField;
669
670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
671 write!(formatter, "expected one of: {:?}", &FIELDS)
672 }
673
674 #[allow(unused_variables)]
675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
676 where
677 E: serde::de::Error,
678 {
679 match value {
680 "executorIds" | "executor_ids" => Ok(GeneratedField::ExecutorIds),
681 "dispatcherFragmentIds" | "dispatcher_fragment_ids" => Ok(GeneratedField::DispatcherFragmentIds),
682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
683 }
684 }
685 }
686 deserializer.deserialize_identifier(GeneratedVisitor)
687 }
688 }
689 struct GeneratedVisitor;
690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
691 type Value = GetProfileStatsRequest;
692
693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
694 formatter.write_str("struct monitor_service.GetProfileStatsRequest")
695 }
696
697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetProfileStatsRequest, V::Error>
698 where
699 V: serde::de::MapAccess<'de>,
700 {
701 let mut executor_ids__ = None;
702 let mut dispatcher_fragment_ids__ = None;
703 while let Some(k) = map_.next_key()? {
704 match k {
705 GeneratedField::ExecutorIds => {
706 if executor_ids__.is_some() {
707 return Err(serde::de::Error::duplicate_field("executorIds"));
708 }
709 executor_ids__ =
710 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
711 .into_iter().map(|x| x.0).collect())
712 ;
713 }
714 GeneratedField::DispatcherFragmentIds => {
715 if dispatcher_fragment_ids__.is_some() {
716 return Err(serde::de::Error::duplicate_field("dispatcherFragmentIds"));
717 }
718 dispatcher_fragment_ids__ =
719 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
720 .into_iter().map(|x| x.0).collect())
721 ;
722 }
723 }
724 }
725 Ok(GetProfileStatsRequest {
726 executor_ids: executor_ids__.unwrap_or_default(),
727 dispatcher_fragment_ids: dispatcher_fragment_ids__.unwrap_or_default(),
728 })
729 }
730 }
731 deserializer.deserialize_struct("monitor_service.GetProfileStatsRequest", FIELDS, GeneratedVisitor)
732 }
733}
734impl serde::Serialize for GetProfileStatsResponse {
735 #[allow(deprecated)]
736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
737 where
738 S: serde::Serializer,
739 {
740 use serde::ser::SerializeStruct;
741 let mut len = 0;
742 if !self.stream_node_output_row_count.is_empty() {
743 len += 1;
744 }
745 if !self.stream_node_output_blocking_duration_ns.is_empty() {
746 len += 1;
747 }
748 if !self.dispatch_fragment_output_row_count.is_empty() {
749 len += 1;
750 }
751 if !self.dispatch_fragment_output_blocking_duration_ns.is_empty() {
752 len += 1;
753 }
754 let mut struct_ser = serializer.serialize_struct("monitor_service.GetProfileStatsResponse", len)?;
755 if !self.stream_node_output_row_count.is_empty() {
756 let v: std::collections::HashMap<_, _> = self.stream_node_output_row_count.iter()
757 .map(|(k, v)| (k, v.to_string())).collect();
758 struct_ser.serialize_field("streamNodeOutputRowCount", &v)?;
759 }
760 if !self.stream_node_output_blocking_duration_ns.is_empty() {
761 let v: std::collections::HashMap<_, _> = self.stream_node_output_blocking_duration_ns.iter()
762 .map(|(k, v)| (k, v.to_string())).collect();
763 struct_ser.serialize_field("streamNodeOutputBlockingDurationNs", &v)?;
764 }
765 if !self.dispatch_fragment_output_row_count.is_empty() {
766 let v: std::collections::HashMap<_, _> = self.dispatch_fragment_output_row_count.iter()
767 .map(|(k, v)| (k, v.to_string())).collect();
768 struct_ser.serialize_field("dispatchFragmentOutputRowCount", &v)?;
769 }
770 if !self.dispatch_fragment_output_blocking_duration_ns.is_empty() {
771 let v: std::collections::HashMap<_, _> = self.dispatch_fragment_output_blocking_duration_ns.iter()
772 .map(|(k, v)| (k, v.to_string())).collect();
773 struct_ser.serialize_field("dispatchFragmentOutputBlockingDurationNs", &v)?;
774 }
775 struct_ser.end()
776 }
777}
778impl<'de> serde::Deserialize<'de> for GetProfileStatsResponse {
779 #[allow(deprecated)]
780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
781 where
782 D: serde::Deserializer<'de>,
783 {
784 const FIELDS: &[&str] = &[
785 "stream_node_output_row_count",
786 "streamNodeOutputRowCount",
787 "stream_node_output_blocking_duration_ns",
788 "streamNodeOutputBlockingDurationNs",
789 "dispatch_fragment_output_row_count",
790 "dispatchFragmentOutputRowCount",
791 "dispatch_fragment_output_blocking_duration_ns",
792 "dispatchFragmentOutputBlockingDurationNs",
793 ];
794
795 #[allow(clippy::enum_variant_names)]
796 enum GeneratedField {
797 StreamNodeOutputRowCount,
798 StreamNodeOutputBlockingDurationNs,
799 DispatchFragmentOutputRowCount,
800 DispatchFragmentOutputBlockingDurationNs,
801 }
802 impl<'de> serde::Deserialize<'de> for GeneratedField {
803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
804 where
805 D: serde::Deserializer<'de>,
806 {
807 struct GeneratedVisitor;
808
809 impl serde::de::Visitor<'_> for GeneratedVisitor {
810 type Value = GeneratedField;
811
812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
813 write!(formatter, "expected one of: {:?}", &FIELDS)
814 }
815
816 #[allow(unused_variables)]
817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
818 where
819 E: serde::de::Error,
820 {
821 match value {
822 "streamNodeOutputRowCount" | "stream_node_output_row_count" => Ok(GeneratedField::StreamNodeOutputRowCount),
823 "streamNodeOutputBlockingDurationNs" | "stream_node_output_blocking_duration_ns" => Ok(GeneratedField::StreamNodeOutputBlockingDurationNs),
824 "dispatchFragmentOutputRowCount" | "dispatch_fragment_output_row_count" => Ok(GeneratedField::DispatchFragmentOutputRowCount),
825 "dispatchFragmentOutputBlockingDurationNs" | "dispatch_fragment_output_blocking_duration_ns" => Ok(GeneratedField::DispatchFragmentOutputBlockingDurationNs),
826 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
827 }
828 }
829 }
830 deserializer.deserialize_identifier(GeneratedVisitor)
831 }
832 }
833 struct GeneratedVisitor;
834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
835 type Value = GetProfileStatsResponse;
836
837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
838 formatter.write_str("struct monitor_service.GetProfileStatsResponse")
839 }
840
841 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetProfileStatsResponse, V::Error>
842 where
843 V: serde::de::MapAccess<'de>,
844 {
845 let mut stream_node_output_row_count__ = None;
846 let mut stream_node_output_blocking_duration_ns__ = None;
847 let mut dispatch_fragment_output_row_count__ = None;
848 let mut dispatch_fragment_output_blocking_duration_ns__ = None;
849 while let Some(k) = map_.next_key()? {
850 match k {
851 GeneratedField::StreamNodeOutputRowCount => {
852 if stream_node_output_row_count__.is_some() {
853 return Err(serde::de::Error::duplicate_field("streamNodeOutputRowCount"));
854 }
855 stream_node_output_row_count__ = Some(
856 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
857 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
858 );
859 }
860 GeneratedField::StreamNodeOutputBlockingDurationNs => {
861 if stream_node_output_blocking_duration_ns__.is_some() {
862 return Err(serde::de::Error::duplicate_field("streamNodeOutputBlockingDurationNs"));
863 }
864 stream_node_output_blocking_duration_ns__ = Some(
865 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
866 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
867 );
868 }
869 GeneratedField::DispatchFragmentOutputRowCount => {
870 if dispatch_fragment_output_row_count__.is_some() {
871 return Err(serde::de::Error::duplicate_field("dispatchFragmentOutputRowCount"));
872 }
873 dispatch_fragment_output_row_count__ = Some(
874 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u64>>>()?
875 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
876 );
877 }
878 GeneratedField::DispatchFragmentOutputBlockingDurationNs => {
879 if dispatch_fragment_output_blocking_duration_ns__.is_some() {
880 return Err(serde::de::Error::duplicate_field("dispatchFragmentOutputBlockingDurationNs"));
881 }
882 dispatch_fragment_output_blocking_duration_ns__ = Some(
883 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u64>>>()?
884 .into_iter().map(|(k,v)| (k.0.into(), v.0.into())).collect()
885 );
886 }
887 }
888 }
889 Ok(GetProfileStatsResponse {
890 stream_node_output_row_count: stream_node_output_row_count__.unwrap_or_default(),
891 stream_node_output_blocking_duration_ns: stream_node_output_blocking_duration_ns__.unwrap_or_default(),
892 dispatch_fragment_output_row_count: dispatch_fragment_output_row_count__.unwrap_or_default(),
893 dispatch_fragment_output_blocking_duration_ns: dispatch_fragment_output_blocking_duration_ns__.unwrap_or_default(),
894 })
895 }
896 }
897 deserializer.deserialize_struct("monitor_service.GetProfileStatsResponse", FIELDS, GeneratedVisitor)
898 }
899}
900impl serde::Serialize for GetStreamingPrometheusStatsResponse {
901 #[allow(deprecated)]
902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
903 where
904 S: serde::Serializer,
905 {
906 use serde::ser::SerializeStruct;
907 let mut len = 0;
908 if !self.channel_stats.is_empty() {
909 len += 1;
910 }
911 if !self.fragment_stats.is_empty() {
912 len += 1;
913 }
914 if !self.relation_stats.is_empty() {
915 len += 1;
916 }
917 let mut struct_ser = serializer.serialize_struct("monitor_service.GetStreamingPrometheusStatsResponse", len)?;
918 if !self.channel_stats.is_empty() {
919 struct_ser.serialize_field("channelStats", &self.channel_stats)?;
920 }
921 if !self.fragment_stats.is_empty() {
922 struct_ser.serialize_field("fragmentStats", &self.fragment_stats)?;
923 }
924 if !self.relation_stats.is_empty() {
925 struct_ser.serialize_field("relationStats", &self.relation_stats)?;
926 }
927 struct_ser.end()
928 }
929}
930impl<'de> serde::Deserialize<'de> for GetStreamingPrometheusStatsResponse {
931 #[allow(deprecated)]
932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
933 where
934 D: serde::Deserializer<'de>,
935 {
936 const FIELDS: &[&str] = &[
937 "channel_stats",
938 "channelStats",
939 "fragment_stats",
940 "fragmentStats",
941 "relation_stats",
942 "relationStats",
943 ];
944
945 #[allow(clippy::enum_variant_names)]
946 enum GeneratedField {
947 ChannelStats,
948 FragmentStats,
949 RelationStats,
950 }
951 impl<'de> serde::Deserialize<'de> for GeneratedField {
952 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
953 where
954 D: serde::Deserializer<'de>,
955 {
956 struct GeneratedVisitor;
957
958 impl serde::de::Visitor<'_> for GeneratedVisitor {
959 type Value = GeneratedField;
960
961 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
962 write!(formatter, "expected one of: {:?}", &FIELDS)
963 }
964
965 #[allow(unused_variables)]
966 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
967 where
968 E: serde::de::Error,
969 {
970 match value {
971 "channelStats" | "channel_stats" => Ok(GeneratedField::ChannelStats),
972 "fragmentStats" | "fragment_stats" => Ok(GeneratedField::FragmentStats),
973 "relationStats" | "relation_stats" => Ok(GeneratedField::RelationStats),
974 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
975 }
976 }
977 }
978 deserializer.deserialize_identifier(GeneratedVisitor)
979 }
980 }
981 struct GeneratedVisitor;
982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
983 type Value = GetStreamingPrometheusStatsResponse;
984
985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
986 formatter.write_str("struct monitor_service.GetStreamingPrometheusStatsResponse")
987 }
988
989 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamingPrometheusStatsResponse, V::Error>
990 where
991 V: serde::de::MapAccess<'de>,
992 {
993 let mut channel_stats__ = None;
994 let mut fragment_stats__ = None;
995 let mut relation_stats__ = None;
996 while let Some(k) = map_.next_key()? {
997 match k {
998 GeneratedField::ChannelStats => {
999 if channel_stats__.is_some() {
1000 return Err(serde::de::Error::duplicate_field("channelStats"));
1001 }
1002 channel_stats__ = Some(
1003 map_.next_value::<std::collections::HashMap<_, _>>()?
1004 );
1005 }
1006 GeneratedField::FragmentStats => {
1007 if fragment_stats__.is_some() {
1008 return Err(serde::de::Error::duplicate_field("fragmentStats"));
1009 }
1010 fragment_stats__ = Some(
1011 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1012 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1013 );
1014 }
1015 GeneratedField::RelationStats => {
1016 if relation_stats__.is_some() {
1017 return Err(serde::de::Error::duplicate_field("relationStats"));
1018 }
1019 relation_stats__ = Some(
1020 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1021 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1022 );
1023 }
1024 }
1025 }
1026 Ok(GetStreamingPrometheusStatsResponse {
1027 channel_stats: channel_stats__.unwrap_or_default(),
1028 fragment_stats: fragment_stats__.unwrap_or_default(),
1029 relation_stats: relation_stats__.unwrap_or_default(),
1030 })
1031 }
1032 }
1033 deserializer.deserialize_struct("monitor_service.GetStreamingPrometheusStatsResponse", FIELDS, GeneratedVisitor)
1034 }
1035}
1036impl serde::Serialize for GetStreamingStatsRequest {
1037 #[allow(deprecated)]
1038 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1039 where
1040 S: serde::Serializer,
1041 {
1042 use serde::ser::SerializeStruct;
1043 let len = 0;
1044 let struct_ser = serializer.serialize_struct("monitor_service.GetStreamingStatsRequest", len)?;
1045 struct_ser.end()
1046 }
1047}
1048impl<'de> serde::Deserialize<'de> for GetStreamingStatsRequest {
1049 #[allow(deprecated)]
1050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1051 where
1052 D: serde::Deserializer<'de>,
1053 {
1054 const FIELDS: &[&str] = &[
1055 ];
1056
1057 #[allow(clippy::enum_variant_names)]
1058 enum GeneratedField {
1059 }
1060 impl<'de> serde::Deserialize<'de> for GeneratedField {
1061 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1062 where
1063 D: serde::Deserializer<'de>,
1064 {
1065 struct GeneratedVisitor;
1066
1067 impl serde::de::Visitor<'_> for GeneratedVisitor {
1068 type Value = GeneratedField;
1069
1070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1071 write!(formatter, "expected one of: {:?}", &FIELDS)
1072 }
1073
1074 #[allow(unused_variables)]
1075 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1076 where
1077 E: serde::de::Error,
1078 {
1079 Err(serde::de::Error::unknown_field(value, FIELDS))
1080 }
1081 }
1082 deserializer.deserialize_identifier(GeneratedVisitor)
1083 }
1084 }
1085 struct GeneratedVisitor;
1086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1087 type Value = GetStreamingStatsRequest;
1088
1089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1090 formatter.write_str("struct monitor_service.GetStreamingStatsRequest")
1091 }
1092
1093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamingStatsRequest, V::Error>
1094 where
1095 V: serde::de::MapAccess<'de>,
1096 {
1097 while map_.next_key::<GeneratedField>()?.is_some() {
1098 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1099 }
1100 Ok(GetStreamingStatsRequest {
1101 })
1102 }
1103 }
1104 deserializer.deserialize_struct("monitor_service.GetStreamingStatsRequest", FIELDS, GeneratedVisitor)
1105 }
1106}
1107impl serde::Serialize for GetStreamingStatsResponse {
1108 #[allow(deprecated)]
1109 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1110 where
1111 S: serde::Serializer,
1112 {
1113 use serde::ser::SerializeStruct;
1114 let mut len = 0;
1115 if !self.channel_stats.is_empty() {
1116 len += 1;
1117 }
1118 if !self.fragment_stats.is_empty() {
1119 len += 1;
1120 }
1121 if !self.relation_stats.is_empty() {
1122 len += 1;
1123 }
1124 let mut struct_ser = serializer.serialize_struct("monitor_service.GetStreamingStatsResponse", len)?;
1125 if !self.channel_stats.is_empty() {
1126 struct_ser.serialize_field("channelStats", &self.channel_stats)?;
1127 }
1128 if !self.fragment_stats.is_empty() {
1129 struct_ser.serialize_field("fragmentStats", &self.fragment_stats)?;
1130 }
1131 if !self.relation_stats.is_empty() {
1132 struct_ser.serialize_field("relationStats", &self.relation_stats)?;
1133 }
1134 struct_ser.end()
1135 }
1136}
1137impl<'de> serde::Deserialize<'de> for GetStreamingStatsResponse {
1138 #[allow(deprecated)]
1139 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1140 where
1141 D: serde::Deserializer<'de>,
1142 {
1143 const FIELDS: &[&str] = &[
1144 "channel_stats",
1145 "channelStats",
1146 "fragment_stats",
1147 "fragmentStats",
1148 "relation_stats",
1149 "relationStats",
1150 ];
1151
1152 #[allow(clippy::enum_variant_names)]
1153 enum GeneratedField {
1154 ChannelStats,
1155 FragmentStats,
1156 RelationStats,
1157 }
1158 impl<'de> serde::Deserialize<'de> for GeneratedField {
1159 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1160 where
1161 D: serde::Deserializer<'de>,
1162 {
1163 struct GeneratedVisitor;
1164
1165 impl serde::de::Visitor<'_> for GeneratedVisitor {
1166 type Value = GeneratedField;
1167
1168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1169 write!(formatter, "expected one of: {:?}", &FIELDS)
1170 }
1171
1172 #[allow(unused_variables)]
1173 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1174 where
1175 E: serde::de::Error,
1176 {
1177 match value {
1178 "channelStats" | "channel_stats" => Ok(GeneratedField::ChannelStats),
1179 "fragmentStats" | "fragment_stats" => Ok(GeneratedField::FragmentStats),
1180 "relationStats" | "relation_stats" => Ok(GeneratedField::RelationStats),
1181 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1182 }
1183 }
1184 }
1185 deserializer.deserialize_identifier(GeneratedVisitor)
1186 }
1187 }
1188 struct GeneratedVisitor;
1189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1190 type Value = GetStreamingStatsResponse;
1191
1192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1193 formatter.write_str("struct monitor_service.GetStreamingStatsResponse")
1194 }
1195
1196 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamingStatsResponse, V::Error>
1197 where
1198 V: serde::de::MapAccess<'de>,
1199 {
1200 let mut channel_stats__ = None;
1201 let mut fragment_stats__ = None;
1202 let mut relation_stats__ = None;
1203 while let Some(k) = map_.next_key()? {
1204 match k {
1205 GeneratedField::ChannelStats => {
1206 if channel_stats__.is_some() {
1207 return Err(serde::de::Error::duplicate_field("channelStats"));
1208 }
1209 channel_stats__ = Some(
1210 map_.next_value::<std::collections::HashMap<_, _>>()?
1211 );
1212 }
1213 GeneratedField::FragmentStats => {
1214 if fragment_stats__.is_some() {
1215 return Err(serde::de::Error::duplicate_field("fragmentStats"));
1216 }
1217 fragment_stats__ = Some(
1218 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1219 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1220 );
1221 }
1222 GeneratedField::RelationStats => {
1223 if relation_stats__.is_some() {
1224 return Err(serde::de::Error::duplicate_field("relationStats"));
1225 }
1226 relation_stats__ = Some(
1227 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1228 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1229 );
1230 }
1231 }
1232 }
1233 Ok(GetStreamingStatsResponse {
1234 channel_stats: channel_stats__.unwrap_or_default(),
1235 fragment_stats: fragment_stats__.unwrap_or_default(),
1236 relation_stats: relation_stats__.unwrap_or_default(),
1237 })
1238 }
1239 }
1240 deserializer.deserialize_struct("monitor_service.GetStreamingStatsResponse", FIELDS, GeneratedVisitor)
1241 }
1242}
1243impl serde::Serialize for GetTableCacheRefillStatsRequest {
1244 #[allow(deprecated)]
1245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1246 where
1247 S: serde::Serializer,
1248 {
1249 use serde::ser::SerializeStruct;
1250 let len = 0;
1251 let struct_ser = serializer.serialize_struct("monitor_service.GetTableCacheRefillStatsRequest", len)?;
1252 struct_ser.end()
1253 }
1254}
1255impl<'de> serde::Deserialize<'de> for GetTableCacheRefillStatsRequest {
1256 #[allow(deprecated)]
1257 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1258 where
1259 D: serde::Deserializer<'de>,
1260 {
1261 const FIELDS: &[&str] = &[
1262 ];
1263
1264 #[allow(clippy::enum_variant_names)]
1265 enum GeneratedField {
1266 }
1267 impl<'de> serde::Deserialize<'de> for GeneratedField {
1268 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1269 where
1270 D: serde::Deserializer<'de>,
1271 {
1272 struct GeneratedVisitor;
1273
1274 impl serde::de::Visitor<'_> for GeneratedVisitor {
1275 type Value = GeneratedField;
1276
1277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1278 write!(formatter, "expected one of: {:?}", &FIELDS)
1279 }
1280
1281 #[allow(unused_variables)]
1282 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1283 where
1284 E: serde::de::Error,
1285 {
1286 Err(serde::de::Error::unknown_field(value, FIELDS))
1287 }
1288 }
1289 deserializer.deserialize_identifier(GeneratedVisitor)
1290 }
1291 }
1292 struct GeneratedVisitor;
1293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1294 type Value = GetTableCacheRefillStatsRequest;
1295
1296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1297 formatter.write_str("struct monitor_service.GetTableCacheRefillStatsRequest")
1298 }
1299
1300 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableCacheRefillStatsRequest, V::Error>
1301 where
1302 V: serde::de::MapAccess<'de>,
1303 {
1304 while map_.next_key::<GeneratedField>()?.is_some() {
1305 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1306 }
1307 Ok(GetTableCacheRefillStatsRequest {
1308 })
1309 }
1310 }
1311 deserializer.deserialize_struct("monitor_service.GetTableCacheRefillStatsRequest", FIELDS, GeneratedVisitor)
1312 }
1313}
1314impl serde::Serialize for GetTableCacheRefillStatsResponse {
1315 #[allow(deprecated)]
1316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1317 where
1318 S: serde::Serializer,
1319 {
1320 use serde::ser::SerializeStruct;
1321 let mut len = 0;
1322 if !self.stats.is_empty() {
1323 len += 1;
1324 }
1325 let mut struct_ser = serializer.serialize_struct("monitor_service.GetTableCacheRefillStatsResponse", len)?;
1326 if !self.stats.is_empty() {
1327 struct_ser.serialize_field("stats", &self.stats)?;
1328 }
1329 struct_ser.end()
1330 }
1331}
1332impl<'de> serde::Deserialize<'de> for GetTableCacheRefillStatsResponse {
1333 #[allow(deprecated)]
1334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1335 where
1336 D: serde::Deserializer<'de>,
1337 {
1338 const FIELDS: &[&str] = &[
1339 "stats",
1340 ];
1341
1342 #[allow(clippy::enum_variant_names)]
1343 enum GeneratedField {
1344 Stats,
1345 }
1346 impl<'de> serde::Deserialize<'de> for GeneratedField {
1347 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1348 where
1349 D: serde::Deserializer<'de>,
1350 {
1351 struct GeneratedVisitor;
1352
1353 impl serde::de::Visitor<'_> for GeneratedVisitor {
1354 type Value = GeneratedField;
1355
1356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1357 write!(formatter, "expected one of: {:?}", &FIELDS)
1358 }
1359
1360 #[allow(unused_variables)]
1361 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1362 where
1363 E: serde::de::Error,
1364 {
1365 match value {
1366 "stats" => Ok(GeneratedField::Stats),
1367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1368 }
1369 }
1370 }
1371 deserializer.deserialize_identifier(GeneratedVisitor)
1372 }
1373 }
1374 struct GeneratedVisitor;
1375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1376 type Value = GetTableCacheRefillStatsResponse;
1377
1378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1379 formatter.write_str("struct monitor_service.GetTableCacheRefillStatsResponse")
1380 }
1381
1382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTableCacheRefillStatsResponse, V::Error>
1383 where
1384 V: serde::de::MapAccess<'de>,
1385 {
1386 let mut stats__ = None;
1387 while let Some(k) = map_.next_key()? {
1388 match k {
1389 GeneratedField::Stats => {
1390 if stats__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("stats"));
1392 }
1393 stats__ = Some(map_.next_value()?);
1394 }
1395 }
1396 }
1397 Ok(GetTableCacheRefillStatsResponse {
1398 stats: stats__.unwrap_or_default(),
1399 })
1400 }
1401 }
1402 deserializer.deserialize_struct("monitor_service.GetTableCacheRefillStatsResponse", FIELDS, GeneratedVisitor)
1403 }
1404}
1405impl serde::Serialize for HeapProfilingRequest {
1406 #[allow(deprecated)]
1407 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1408 where
1409 S: serde::Serializer,
1410 {
1411 use serde::ser::SerializeStruct;
1412 let mut len = 0;
1413 if !self.dir.is_empty() {
1414 len += 1;
1415 }
1416 let mut struct_ser = serializer.serialize_struct("monitor_service.HeapProfilingRequest", len)?;
1417 if !self.dir.is_empty() {
1418 struct_ser.serialize_field("dir", &self.dir)?;
1419 }
1420 struct_ser.end()
1421 }
1422}
1423impl<'de> serde::Deserialize<'de> for HeapProfilingRequest {
1424 #[allow(deprecated)]
1425 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1426 where
1427 D: serde::Deserializer<'de>,
1428 {
1429 const FIELDS: &[&str] = &[
1430 "dir",
1431 ];
1432
1433 #[allow(clippy::enum_variant_names)]
1434 enum GeneratedField {
1435 Dir,
1436 }
1437 impl<'de> serde::Deserialize<'de> for GeneratedField {
1438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1439 where
1440 D: serde::Deserializer<'de>,
1441 {
1442 struct GeneratedVisitor;
1443
1444 impl serde::de::Visitor<'_> for GeneratedVisitor {
1445 type Value = GeneratedField;
1446
1447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1448 write!(formatter, "expected one of: {:?}", &FIELDS)
1449 }
1450
1451 #[allow(unused_variables)]
1452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1453 where
1454 E: serde::de::Error,
1455 {
1456 match value {
1457 "dir" => Ok(GeneratedField::Dir),
1458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1459 }
1460 }
1461 }
1462 deserializer.deserialize_identifier(GeneratedVisitor)
1463 }
1464 }
1465 struct GeneratedVisitor;
1466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1467 type Value = HeapProfilingRequest;
1468
1469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1470 formatter.write_str("struct monitor_service.HeapProfilingRequest")
1471 }
1472
1473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeapProfilingRequest, V::Error>
1474 where
1475 V: serde::de::MapAccess<'de>,
1476 {
1477 let mut dir__ = None;
1478 while let Some(k) = map_.next_key()? {
1479 match k {
1480 GeneratedField::Dir => {
1481 if dir__.is_some() {
1482 return Err(serde::de::Error::duplicate_field("dir"));
1483 }
1484 dir__ = Some(map_.next_value()?);
1485 }
1486 }
1487 }
1488 Ok(HeapProfilingRequest {
1489 dir: dir__.unwrap_or_default(),
1490 })
1491 }
1492 }
1493 deserializer.deserialize_struct("monitor_service.HeapProfilingRequest", FIELDS, GeneratedVisitor)
1494 }
1495}
1496impl serde::Serialize for HeapProfilingResponse {
1497 #[allow(deprecated)]
1498 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1499 where
1500 S: serde::Serializer,
1501 {
1502 use serde::ser::SerializeStruct;
1503 let len = 0;
1504 let struct_ser = serializer.serialize_struct("monitor_service.HeapProfilingResponse", len)?;
1505 struct_ser.end()
1506 }
1507}
1508impl<'de> serde::Deserialize<'de> for HeapProfilingResponse {
1509 #[allow(deprecated)]
1510 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1511 where
1512 D: serde::Deserializer<'de>,
1513 {
1514 const FIELDS: &[&str] = &[
1515 ];
1516
1517 #[allow(clippy::enum_variant_names)]
1518 enum GeneratedField {
1519 }
1520 impl<'de> serde::Deserialize<'de> for GeneratedField {
1521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1522 where
1523 D: serde::Deserializer<'de>,
1524 {
1525 struct GeneratedVisitor;
1526
1527 impl serde::de::Visitor<'_> for GeneratedVisitor {
1528 type Value = GeneratedField;
1529
1530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1531 write!(formatter, "expected one of: {:?}", &FIELDS)
1532 }
1533
1534 #[allow(unused_variables)]
1535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1536 where
1537 E: serde::de::Error,
1538 {
1539 Err(serde::de::Error::unknown_field(value, FIELDS))
1540 }
1541 }
1542 deserializer.deserialize_identifier(GeneratedVisitor)
1543 }
1544 }
1545 struct GeneratedVisitor;
1546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1547 type Value = HeapProfilingResponse;
1548
1549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1550 formatter.write_str("struct monitor_service.HeapProfilingResponse")
1551 }
1552
1553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeapProfilingResponse, V::Error>
1554 where
1555 V: serde::de::MapAccess<'de>,
1556 {
1557 while map_.next_key::<GeneratedField>()?.is_some() {
1558 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1559 }
1560 Ok(HeapProfilingResponse {
1561 })
1562 }
1563 }
1564 deserializer.deserialize_struct("monitor_service.HeapProfilingResponse", FIELDS, GeneratedVisitor)
1565 }
1566}
1567impl serde::Serialize for ListHeapProfilingRequest {
1568 #[allow(deprecated)]
1569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1570 where
1571 S: serde::Serializer,
1572 {
1573 use serde::ser::SerializeStruct;
1574 let len = 0;
1575 let struct_ser = serializer.serialize_struct("monitor_service.ListHeapProfilingRequest", len)?;
1576 struct_ser.end()
1577 }
1578}
1579impl<'de> serde::Deserialize<'de> for ListHeapProfilingRequest {
1580 #[allow(deprecated)]
1581 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1582 where
1583 D: serde::Deserializer<'de>,
1584 {
1585 const FIELDS: &[&str] = &[
1586 ];
1587
1588 #[allow(clippy::enum_variant_names)]
1589 enum GeneratedField {
1590 }
1591 impl<'de> serde::Deserialize<'de> for GeneratedField {
1592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1593 where
1594 D: serde::Deserializer<'de>,
1595 {
1596 struct GeneratedVisitor;
1597
1598 impl serde::de::Visitor<'_> for GeneratedVisitor {
1599 type Value = GeneratedField;
1600
1601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1602 write!(formatter, "expected one of: {:?}", &FIELDS)
1603 }
1604
1605 #[allow(unused_variables)]
1606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1607 where
1608 E: serde::de::Error,
1609 {
1610 Err(serde::de::Error::unknown_field(value, FIELDS))
1611 }
1612 }
1613 deserializer.deserialize_identifier(GeneratedVisitor)
1614 }
1615 }
1616 struct GeneratedVisitor;
1617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1618 type Value = ListHeapProfilingRequest;
1619
1620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1621 formatter.write_str("struct monitor_service.ListHeapProfilingRequest")
1622 }
1623
1624 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHeapProfilingRequest, V::Error>
1625 where
1626 V: serde::de::MapAccess<'de>,
1627 {
1628 while map_.next_key::<GeneratedField>()?.is_some() {
1629 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1630 }
1631 Ok(ListHeapProfilingRequest {
1632 })
1633 }
1634 }
1635 deserializer.deserialize_struct("monitor_service.ListHeapProfilingRequest", FIELDS, GeneratedVisitor)
1636 }
1637}
1638impl serde::Serialize for ListHeapProfilingResponse {
1639 #[allow(deprecated)]
1640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1641 where
1642 S: serde::Serializer,
1643 {
1644 use serde::ser::SerializeStruct;
1645 let mut len = 0;
1646 if !self.dir.is_empty() {
1647 len += 1;
1648 }
1649 if !self.name_manually.is_empty() {
1650 len += 1;
1651 }
1652 if !self.name_auto.is_empty() {
1653 len += 1;
1654 }
1655 let mut struct_ser = serializer.serialize_struct("monitor_service.ListHeapProfilingResponse", len)?;
1656 if !self.dir.is_empty() {
1657 struct_ser.serialize_field("dir", &self.dir)?;
1658 }
1659 if !self.name_manually.is_empty() {
1660 struct_ser.serialize_field("nameManually", &self.name_manually)?;
1661 }
1662 if !self.name_auto.is_empty() {
1663 struct_ser.serialize_field("nameAuto", &self.name_auto)?;
1664 }
1665 struct_ser.end()
1666 }
1667}
1668impl<'de> serde::Deserialize<'de> for ListHeapProfilingResponse {
1669 #[allow(deprecated)]
1670 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1671 where
1672 D: serde::Deserializer<'de>,
1673 {
1674 const FIELDS: &[&str] = &[
1675 "dir",
1676 "name_manually",
1677 "nameManually",
1678 "name_auto",
1679 "nameAuto",
1680 ];
1681
1682 #[allow(clippy::enum_variant_names)]
1683 enum GeneratedField {
1684 Dir,
1685 NameManually,
1686 NameAuto,
1687 }
1688 impl<'de> serde::Deserialize<'de> for GeneratedField {
1689 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1690 where
1691 D: serde::Deserializer<'de>,
1692 {
1693 struct GeneratedVisitor;
1694
1695 impl serde::de::Visitor<'_> for GeneratedVisitor {
1696 type Value = GeneratedField;
1697
1698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1699 write!(formatter, "expected one of: {:?}", &FIELDS)
1700 }
1701
1702 #[allow(unused_variables)]
1703 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1704 where
1705 E: serde::de::Error,
1706 {
1707 match value {
1708 "dir" => Ok(GeneratedField::Dir),
1709 "nameManually" | "name_manually" => Ok(GeneratedField::NameManually),
1710 "nameAuto" | "name_auto" => Ok(GeneratedField::NameAuto),
1711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1712 }
1713 }
1714 }
1715 deserializer.deserialize_identifier(GeneratedVisitor)
1716 }
1717 }
1718 struct GeneratedVisitor;
1719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1720 type Value = ListHeapProfilingResponse;
1721
1722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1723 formatter.write_str("struct monitor_service.ListHeapProfilingResponse")
1724 }
1725
1726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHeapProfilingResponse, V::Error>
1727 where
1728 V: serde::de::MapAccess<'de>,
1729 {
1730 let mut dir__ = None;
1731 let mut name_manually__ = None;
1732 let mut name_auto__ = None;
1733 while let Some(k) = map_.next_key()? {
1734 match k {
1735 GeneratedField::Dir => {
1736 if dir__.is_some() {
1737 return Err(serde::de::Error::duplicate_field("dir"));
1738 }
1739 dir__ = Some(map_.next_value()?);
1740 }
1741 GeneratedField::NameManually => {
1742 if name_manually__.is_some() {
1743 return Err(serde::de::Error::duplicate_field("nameManually"));
1744 }
1745 name_manually__ = Some(map_.next_value()?);
1746 }
1747 GeneratedField::NameAuto => {
1748 if name_auto__.is_some() {
1749 return Err(serde::de::Error::duplicate_field("nameAuto"));
1750 }
1751 name_auto__ = Some(map_.next_value()?);
1752 }
1753 }
1754 }
1755 Ok(ListHeapProfilingResponse {
1756 dir: dir__.unwrap_or_default(),
1757 name_manually: name_manually__.unwrap_or_default(),
1758 name_auto: name_auto__.unwrap_or_default(),
1759 })
1760 }
1761 }
1762 deserializer.deserialize_struct("monitor_service.ListHeapProfilingResponse", FIELDS, GeneratedVisitor)
1763 }
1764}
1765impl serde::Serialize for ProfilingRequest {
1766 #[allow(deprecated)]
1767 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1768 where
1769 S: serde::Serializer,
1770 {
1771 use serde::ser::SerializeStruct;
1772 let mut len = 0;
1773 if self.sleep_s != 0 {
1774 len += 1;
1775 }
1776 let mut struct_ser = serializer.serialize_struct("monitor_service.ProfilingRequest", len)?;
1777 if self.sleep_s != 0 {
1778 #[allow(clippy::needless_borrow)]
1779 #[allow(clippy::needless_borrows_for_generic_args)]
1780 struct_ser.serialize_field("sleepS", ToString::to_string(&self.sleep_s).as_str())?;
1781 }
1782 struct_ser.end()
1783 }
1784}
1785impl<'de> serde::Deserialize<'de> for ProfilingRequest {
1786 #[allow(deprecated)]
1787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1788 where
1789 D: serde::Deserializer<'de>,
1790 {
1791 const FIELDS: &[&str] = &[
1792 "sleep_s",
1793 "sleepS",
1794 ];
1795
1796 #[allow(clippy::enum_variant_names)]
1797 enum GeneratedField {
1798 SleepS,
1799 }
1800 impl<'de> serde::Deserialize<'de> for GeneratedField {
1801 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1802 where
1803 D: serde::Deserializer<'de>,
1804 {
1805 struct GeneratedVisitor;
1806
1807 impl serde::de::Visitor<'_> for GeneratedVisitor {
1808 type Value = GeneratedField;
1809
1810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1811 write!(formatter, "expected one of: {:?}", &FIELDS)
1812 }
1813
1814 #[allow(unused_variables)]
1815 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1816 where
1817 E: serde::de::Error,
1818 {
1819 match value {
1820 "sleepS" | "sleep_s" => Ok(GeneratedField::SleepS),
1821 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1822 }
1823 }
1824 }
1825 deserializer.deserialize_identifier(GeneratedVisitor)
1826 }
1827 }
1828 struct GeneratedVisitor;
1829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1830 type Value = ProfilingRequest;
1831
1832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1833 formatter.write_str("struct monitor_service.ProfilingRequest")
1834 }
1835
1836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProfilingRequest, V::Error>
1837 where
1838 V: serde::de::MapAccess<'de>,
1839 {
1840 let mut sleep_s__ = None;
1841 while let Some(k) = map_.next_key()? {
1842 match k {
1843 GeneratedField::SleepS => {
1844 if sleep_s__.is_some() {
1845 return Err(serde::de::Error::duplicate_field("sleepS"));
1846 }
1847 sleep_s__ =
1848 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1849 ;
1850 }
1851 }
1852 }
1853 Ok(ProfilingRequest {
1854 sleep_s: sleep_s__.unwrap_or_default(),
1855 })
1856 }
1857 }
1858 deserializer.deserialize_struct("monitor_service.ProfilingRequest", FIELDS, GeneratedVisitor)
1859 }
1860}
1861impl serde::Serialize for ProfilingResponse {
1862 #[allow(deprecated)]
1863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1864 where
1865 S: serde::Serializer,
1866 {
1867 use serde::ser::SerializeStruct;
1868 let mut len = 0;
1869 if !self.result.is_empty() {
1870 len += 1;
1871 }
1872 let mut struct_ser = serializer.serialize_struct("monitor_service.ProfilingResponse", len)?;
1873 if !self.result.is_empty() {
1874 #[allow(clippy::needless_borrow)]
1875 #[allow(clippy::needless_borrows_for_generic_args)]
1876 struct_ser.serialize_field("result", pbjson::private::base64::encode(&self.result).as_str())?;
1877 }
1878 struct_ser.end()
1879 }
1880}
1881impl<'de> serde::Deserialize<'de> for ProfilingResponse {
1882 #[allow(deprecated)]
1883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1884 where
1885 D: serde::Deserializer<'de>,
1886 {
1887 const FIELDS: &[&str] = &[
1888 "result",
1889 ];
1890
1891 #[allow(clippy::enum_variant_names)]
1892 enum GeneratedField {
1893 Result,
1894 }
1895 impl<'de> serde::Deserialize<'de> for GeneratedField {
1896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1897 where
1898 D: serde::Deserializer<'de>,
1899 {
1900 struct GeneratedVisitor;
1901
1902 impl serde::de::Visitor<'_> for GeneratedVisitor {
1903 type Value = GeneratedField;
1904
1905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1906 write!(formatter, "expected one of: {:?}", &FIELDS)
1907 }
1908
1909 #[allow(unused_variables)]
1910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1911 where
1912 E: serde::de::Error,
1913 {
1914 match value {
1915 "result" => Ok(GeneratedField::Result),
1916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1917 }
1918 }
1919 }
1920 deserializer.deserialize_identifier(GeneratedVisitor)
1921 }
1922 }
1923 struct GeneratedVisitor;
1924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1925 type Value = ProfilingResponse;
1926
1927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1928 formatter.write_str("struct monitor_service.ProfilingResponse")
1929 }
1930
1931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProfilingResponse, V::Error>
1932 where
1933 V: serde::de::MapAccess<'de>,
1934 {
1935 let mut result__ = None;
1936 while let Some(k) = map_.next_key()? {
1937 match k {
1938 GeneratedField::Result => {
1939 if result__.is_some() {
1940 return Err(serde::de::Error::duplicate_field("result"));
1941 }
1942 result__ =
1943 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
1944 ;
1945 }
1946 }
1947 }
1948 Ok(ProfilingResponse {
1949 result: result__.unwrap_or_default(),
1950 })
1951 }
1952 }
1953 deserializer.deserialize_struct("monitor_service.ProfilingResponse", FIELDS, GeneratedVisitor)
1954 }
1955}
1956impl serde::Serialize for RelationStats {
1957 #[allow(deprecated)]
1958 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1959 where
1960 S: serde::Serializer,
1961 {
1962 use serde::ser::SerializeStruct;
1963 let mut len = 0;
1964 if self.actor_count != 0 {
1965 len += 1;
1966 }
1967 if self.current_epoch != 0 {
1968 len += 1;
1969 }
1970 let mut struct_ser = serializer.serialize_struct("monitor_service.RelationStats", len)?;
1971 if self.actor_count != 0 {
1972 struct_ser.serialize_field("n", &self.actor_count)?;
1973 }
1974 if self.current_epoch != 0 {
1975 #[allow(clippy::needless_borrow)]
1976 #[allow(clippy::needless_borrows_for_generic_args)]
1977 struct_ser.serialize_field("e", ToString::to_string(&self.current_epoch).as_str())?;
1978 }
1979 struct_ser.end()
1980 }
1981}
1982impl<'de> serde::Deserialize<'de> for RelationStats {
1983 #[allow(deprecated)]
1984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1985 where
1986 D: serde::Deserializer<'de>,
1987 {
1988 const FIELDS: &[&str] = &[
1989 "actor_count",
1990 "n",
1991 "current_epoch",
1992 "e",
1993 ];
1994
1995 #[allow(clippy::enum_variant_names)]
1996 enum GeneratedField {
1997 ActorCount,
1998 CurrentEpoch,
1999 }
2000 impl<'de> serde::Deserialize<'de> for GeneratedField {
2001 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2002 where
2003 D: serde::Deserializer<'de>,
2004 {
2005 struct GeneratedVisitor;
2006
2007 impl serde::de::Visitor<'_> for GeneratedVisitor {
2008 type Value = GeneratedField;
2009
2010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2011 write!(formatter, "expected one of: {:?}", &FIELDS)
2012 }
2013
2014 #[allow(unused_variables)]
2015 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2016 where
2017 E: serde::de::Error,
2018 {
2019 match value {
2020 "n" | "actor_count" => Ok(GeneratedField::ActorCount),
2021 "e" | "current_epoch" => Ok(GeneratedField::CurrentEpoch),
2022 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2023 }
2024 }
2025 }
2026 deserializer.deserialize_identifier(GeneratedVisitor)
2027 }
2028 }
2029 struct GeneratedVisitor;
2030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2031 type Value = RelationStats;
2032
2033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2034 formatter.write_str("struct monitor_service.RelationStats")
2035 }
2036
2037 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationStats, V::Error>
2038 where
2039 V: serde::de::MapAccess<'de>,
2040 {
2041 let mut actor_count__ = None;
2042 let mut current_epoch__ = None;
2043 while let Some(k) = map_.next_key()? {
2044 match k {
2045 GeneratedField::ActorCount => {
2046 if actor_count__.is_some() {
2047 return Err(serde::de::Error::duplicate_field("n"));
2048 }
2049 actor_count__ =
2050 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2051 ;
2052 }
2053 GeneratedField::CurrentEpoch => {
2054 if current_epoch__.is_some() {
2055 return Err(serde::de::Error::duplicate_field("e"));
2056 }
2057 current_epoch__ =
2058 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2059 ;
2060 }
2061 }
2062 }
2063 Ok(RelationStats {
2064 actor_count: actor_count__.unwrap_or_default(),
2065 current_epoch: current_epoch__.unwrap_or_default(),
2066 })
2067 }
2068 }
2069 deserializer.deserialize_struct("monitor_service.RelationStats", FIELDS, GeneratedVisitor)
2070 }
2071}
2072impl serde::Serialize for StackTraceRequest {
2073 #[allow(deprecated)]
2074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2075 where
2076 S: serde::Serializer,
2077 {
2078 use serde::ser::SerializeStruct;
2079 let mut len = 0;
2080 if self.actor_traces_format != 0 {
2081 len += 1;
2082 }
2083 let mut struct_ser = serializer.serialize_struct("monitor_service.StackTraceRequest", len)?;
2084 if self.actor_traces_format != 0 {
2085 let v = stack_trace_request::ActorTracesFormat::try_from(self.actor_traces_format)
2086 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.actor_traces_format)))?;
2087 struct_ser.serialize_field("actorTracesFormat", &v)?;
2088 }
2089 struct_ser.end()
2090 }
2091}
2092impl<'de> serde::Deserialize<'de> for StackTraceRequest {
2093 #[allow(deprecated)]
2094 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2095 where
2096 D: serde::Deserializer<'de>,
2097 {
2098 const FIELDS: &[&str] = &[
2099 "actor_traces_format",
2100 "actorTracesFormat",
2101 ];
2102
2103 #[allow(clippy::enum_variant_names)]
2104 enum GeneratedField {
2105 ActorTracesFormat,
2106 }
2107 impl<'de> serde::Deserialize<'de> for GeneratedField {
2108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2109 where
2110 D: serde::Deserializer<'de>,
2111 {
2112 struct GeneratedVisitor;
2113
2114 impl serde::de::Visitor<'_> for GeneratedVisitor {
2115 type Value = GeneratedField;
2116
2117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2118 write!(formatter, "expected one of: {:?}", &FIELDS)
2119 }
2120
2121 #[allow(unused_variables)]
2122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2123 where
2124 E: serde::de::Error,
2125 {
2126 match value {
2127 "actorTracesFormat" | "actor_traces_format" => Ok(GeneratedField::ActorTracesFormat),
2128 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2129 }
2130 }
2131 }
2132 deserializer.deserialize_identifier(GeneratedVisitor)
2133 }
2134 }
2135 struct GeneratedVisitor;
2136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2137 type Value = StackTraceRequest;
2138
2139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2140 formatter.write_str("struct monitor_service.StackTraceRequest")
2141 }
2142
2143 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StackTraceRequest, V::Error>
2144 where
2145 V: serde::de::MapAccess<'de>,
2146 {
2147 let mut actor_traces_format__ = None;
2148 while let Some(k) = map_.next_key()? {
2149 match k {
2150 GeneratedField::ActorTracesFormat => {
2151 if actor_traces_format__.is_some() {
2152 return Err(serde::de::Error::duplicate_field("actorTracesFormat"));
2153 }
2154 actor_traces_format__ = Some(map_.next_value::<stack_trace_request::ActorTracesFormat>()? as i32);
2155 }
2156 }
2157 }
2158 Ok(StackTraceRequest {
2159 actor_traces_format: actor_traces_format__.unwrap_or_default(),
2160 })
2161 }
2162 }
2163 deserializer.deserialize_struct("monitor_service.StackTraceRequest", FIELDS, GeneratedVisitor)
2164 }
2165}
2166impl serde::Serialize for stack_trace_request::ActorTracesFormat {
2167 #[allow(deprecated)]
2168 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2169 where
2170 S: serde::Serializer,
2171 {
2172 let variant = match self {
2173 Self::Unspecified => "UNSPECIFIED",
2174 Self::Json => "JSON",
2175 Self::Text => "TEXT",
2176 };
2177 serializer.serialize_str(variant)
2178 }
2179}
2180impl<'de> serde::Deserialize<'de> for stack_trace_request::ActorTracesFormat {
2181 #[allow(deprecated)]
2182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2183 where
2184 D: serde::Deserializer<'de>,
2185 {
2186 const FIELDS: &[&str] = &[
2187 "UNSPECIFIED",
2188 "JSON",
2189 "TEXT",
2190 ];
2191
2192 struct GeneratedVisitor;
2193
2194 impl serde::de::Visitor<'_> for GeneratedVisitor {
2195 type Value = stack_trace_request::ActorTracesFormat;
2196
2197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2198 write!(formatter, "expected one of: {:?}", &FIELDS)
2199 }
2200
2201 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2202 where
2203 E: serde::de::Error,
2204 {
2205 i32::try_from(v)
2206 .ok()
2207 .and_then(|x| x.try_into().ok())
2208 .ok_or_else(|| {
2209 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2210 })
2211 }
2212
2213 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2214 where
2215 E: serde::de::Error,
2216 {
2217 i32::try_from(v)
2218 .ok()
2219 .and_then(|x| x.try_into().ok())
2220 .ok_or_else(|| {
2221 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2222 })
2223 }
2224
2225 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2226 where
2227 E: serde::de::Error,
2228 {
2229 match value {
2230 "UNSPECIFIED" => Ok(stack_trace_request::ActorTracesFormat::Unspecified),
2231 "JSON" => Ok(stack_trace_request::ActorTracesFormat::Json),
2232 "TEXT" => Ok(stack_trace_request::ActorTracesFormat::Text),
2233 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2234 }
2235 }
2236 }
2237 deserializer.deserialize_any(GeneratedVisitor)
2238 }
2239}
2240impl serde::Serialize for StackTraceResponse {
2241 #[allow(deprecated)]
2242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2243 where
2244 S: serde::Serializer,
2245 {
2246 use serde::ser::SerializeStruct;
2247 let mut len = 0;
2248 if !self.actor_traces.is_empty() {
2249 len += 1;
2250 }
2251 if !self.rpc_traces.is_empty() {
2252 len += 1;
2253 }
2254 if !self.compaction_task_traces.is_empty() {
2255 len += 1;
2256 }
2257 if !self.inflight_barrier_traces.is_empty() {
2258 len += 1;
2259 }
2260 if !self.barrier_worker_state.is_empty() {
2261 len += 1;
2262 }
2263 if !self.jvm_stack_traces.is_empty() {
2264 len += 1;
2265 }
2266 if !self.meta_traces.is_empty() {
2267 len += 1;
2268 }
2269 if !self.node_errors.is_empty() {
2270 len += 1;
2271 }
2272 if !self.batch_traces.is_empty() {
2273 len += 1;
2274 }
2275 let mut struct_ser = serializer.serialize_struct("monitor_service.StackTraceResponse", len)?;
2276 if !self.actor_traces.is_empty() {
2277 struct_ser.serialize_field("actorTraces", &self.actor_traces)?;
2278 }
2279 if !self.rpc_traces.is_empty() {
2280 struct_ser.serialize_field("rpcTraces", &self.rpc_traces)?;
2281 }
2282 if !self.compaction_task_traces.is_empty() {
2283 struct_ser.serialize_field("compactionTaskTraces", &self.compaction_task_traces)?;
2284 }
2285 if !self.inflight_barrier_traces.is_empty() {
2286 struct_ser.serialize_field("inflightBarrierTraces", &self.inflight_barrier_traces)?;
2287 }
2288 if !self.barrier_worker_state.is_empty() {
2289 struct_ser.serialize_field("barrierWorkerState", &self.barrier_worker_state)?;
2290 }
2291 if !self.jvm_stack_traces.is_empty() {
2292 struct_ser.serialize_field("jvmStackTraces", &self.jvm_stack_traces)?;
2293 }
2294 if !self.meta_traces.is_empty() {
2295 struct_ser.serialize_field("metaTraces", &self.meta_traces)?;
2296 }
2297 if !self.node_errors.is_empty() {
2298 struct_ser.serialize_field("nodeErrors", &self.node_errors)?;
2299 }
2300 if !self.batch_traces.is_empty() {
2301 struct_ser.serialize_field("batchTraces", &self.batch_traces)?;
2302 }
2303 struct_ser.end()
2304 }
2305}
2306impl<'de> serde::Deserialize<'de> for StackTraceResponse {
2307 #[allow(deprecated)]
2308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2309 where
2310 D: serde::Deserializer<'de>,
2311 {
2312 const FIELDS: &[&str] = &[
2313 "actor_traces",
2314 "actorTraces",
2315 "rpc_traces",
2316 "rpcTraces",
2317 "compaction_task_traces",
2318 "compactionTaskTraces",
2319 "inflight_barrier_traces",
2320 "inflightBarrierTraces",
2321 "barrier_worker_state",
2322 "barrierWorkerState",
2323 "jvm_stack_traces",
2324 "jvmStackTraces",
2325 "meta_traces",
2326 "metaTraces",
2327 "node_errors",
2328 "nodeErrors",
2329 "batch_traces",
2330 "batchTraces",
2331 ];
2332
2333 #[allow(clippy::enum_variant_names)]
2334 enum GeneratedField {
2335 ActorTraces,
2336 RpcTraces,
2337 CompactionTaskTraces,
2338 InflightBarrierTraces,
2339 BarrierWorkerState,
2340 JvmStackTraces,
2341 MetaTraces,
2342 NodeErrors,
2343 BatchTraces,
2344 }
2345 impl<'de> serde::Deserialize<'de> for GeneratedField {
2346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2347 where
2348 D: serde::Deserializer<'de>,
2349 {
2350 struct GeneratedVisitor;
2351
2352 impl serde::de::Visitor<'_> for GeneratedVisitor {
2353 type Value = GeneratedField;
2354
2355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2356 write!(formatter, "expected one of: {:?}", &FIELDS)
2357 }
2358
2359 #[allow(unused_variables)]
2360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2361 where
2362 E: serde::de::Error,
2363 {
2364 match value {
2365 "actorTraces" | "actor_traces" => Ok(GeneratedField::ActorTraces),
2366 "rpcTraces" | "rpc_traces" => Ok(GeneratedField::RpcTraces),
2367 "compactionTaskTraces" | "compaction_task_traces" => Ok(GeneratedField::CompactionTaskTraces),
2368 "inflightBarrierTraces" | "inflight_barrier_traces" => Ok(GeneratedField::InflightBarrierTraces),
2369 "barrierWorkerState" | "barrier_worker_state" => Ok(GeneratedField::BarrierWorkerState),
2370 "jvmStackTraces" | "jvm_stack_traces" => Ok(GeneratedField::JvmStackTraces),
2371 "metaTraces" | "meta_traces" => Ok(GeneratedField::MetaTraces),
2372 "nodeErrors" | "node_errors" => Ok(GeneratedField::NodeErrors),
2373 "batchTraces" | "batch_traces" => Ok(GeneratedField::BatchTraces),
2374 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2375 }
2376 }
2377 }
2378 deserializer.deserialize_identifier(GeneratedVisitor)
2379 }
2380 }
2381 struct GeneratedVisitor;
2382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2383 type Value = StackTraceResponse;
2384
2385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2386 formatter.write_str("struct monitor_service.StackTraceResponse")
2387 }
2388
2389 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StackTraceResponse, V::Error>
2390 where
2391 V: serde::de::MapAccess<'de>,
2392 {
2393 let mut actor_traces__ = None;
2394 let mut rpc_traces__ = None;
2395 let mut compaction_task_traces__ = None;
2396 let mut inflight_barrier_traces__ = None;
2397 let mut barrier_worker_state__ = None;
2398 let mut jvm_stack_traces__ = None;
2399 let mut meta_traces__ = None;
2400 let mut node_errors__ = None;
2401 let mut batch_traces__ = None;
2402 while let Some(k) = map_.next_key()? {
2403 match k {
2404 GeneratedField::ActorTraces => {
2405 if actor_traces__.is_some() {
2406 return Err(serde::de::Error::duplicate_field("actorTraces"));
2407 }
2408 actor_traces__ = Some(
2409 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2410 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2411 );
2412 }
2413 GeneratedField::RpcTraces => {
2414 if rpc_traces__.is_some() {
2415 return Err(serde::de::Error::duplicate_field("rpcTraces"));
2416 }
2417 rpc_traces__ = Some(
2418 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2419 );
2420 }
2421 GeneratedField::CompactionTaskTraces => {
2422 if compaction_task_traces__.is_some() {
2423 return Err(serde::de::Error::duplicate_field("compactionTaskTraces"));
2424 }
2425 compaction_task_traces__ = Some(
2426 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2427 );
2428 }
2429 GeneratedField::InflightBarrierTraces => {
2430 if inflight_barrier_traces__.is_some() {
2431 return Err(serde::de::Error::duplicate_field("inflightBarrierTraces"));
2432 }
2433 inflight_barrier_traces__ = Some(
2434 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
2435 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2436 );
2437 }
2438 GeneratedField::BarrierWorkerState => {
2439 if barrier_worker_state__.is_some() {
2440 return Err(serde::de::Error::duplicate_field("barrierWorkerState"));
2441 }
2442 barrier_worker_state__ = Some(
2443 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2444 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2445 );
2446 }
2447 GeneratedField::JvmStackTraces => {
2448 if jvm_stack_traces__.is_some() {
2449 return Err(serde::de::Error::duplicate_field("jvmStackTraces"));
2450 }
2451 jvm_stack_traces__ = Some(
2452 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2453 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2454 );
2455 }
2456 GeneratedField::MetaTraces => {
2457 if meta_traces__.is_some() {
2458 return Err(serde::de::Error::duplicate_field("metaTraces"));
2459 }
2460 meta_traces__ = Some(
2461 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2462 );
2463 }
2464 GeneratedField::NodeErrors => {
2465 if node_errors__.is_some() {
2466 return Err(serde::de::Error::duplicate_field("nodeErrors"));
2467 }
2468 node_errors__ = Some(
2469 map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2470 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2471 );
2472 }
2473 GeneratedField::BatchTraces => {
2474 if batch_traces__.is_some() {
2475 return Err(serde::de::Error::duplicate_field("batchTraces"));
2476 }
2477 batch_traces__ = Some(
2478 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2479 );
2480 }
2481 }
2482 }
2483 Ok(StackTraceResponse {
2484 actor_traces: actor_traces__.unwrap_or_default(),
2485 rpc_traces: rpc_traces__.unwrap_or_default(),
2486 compaction_task_traces: compaction_task_traces__.unwrap_or_default(),
2487 inflight_barrier_traces: inflight_barrier_traces__.unwrap_or_default(),
2488 barrier_worker_state: barrier_worker_state__.unwrap_or_default(),
2489 jvm_stack_traces: jvm_stack_traces__.unwrap_or_default(),
2490 meta_traces: meta_traces__.unwrap_or_default(),
2491 node_errors: node_errors__.unwrap_or_default(),
2492 batch_traces: batch_traces__.unwrap_or_default(),
2493 })
2494 }
2495 }
2496 deserializer.deserialize_struct("monitor_service.StackTraceResponse", FIELDS, GeneratedVisitor)
2497 }
2498}
2499impl serde::Serialize for TieredCacheTracingRequest {
2500 #[allow(deprecated)]
2501 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2502 where
2503 S: serde::Serializer,
2504 {
2505 use serde::ser::SerializeStruct;
2506 let mut len = 0;
2507 if self.enable {
2508 len += 1;
2509 }
2510 if self.record_hybrid_insert_threshold_ms.is_some() {
2511 len += 1;
2512 }
2513 if self.record_hybrid_get_threshold_ms.is_some() {
2514 len += 1;
2515 }
2516 if self.record_hybrid_obtain_threshold_ms.is_some() {
2517 len += 1;
2518 }
2519 if self.record_hybrid_remove_threshold_ms.is_some() {
2520 len += 1;
2521 }
2522 if self.record_hybrid_fetch_threshold_ms.is_some() {
2523 len += 1;
2524 }
2525 let mut struct_ser = serializer.serialize_struct("monitor_service.TieredCacheTracingRequest", len)?;
2526 if self.enable {
2527 struct_ser.serialize_field("enable", &self.enable)?;
2528 }
2529 if let Some(v) = self.record_hybrid_insert_threshold_ms.as_ref() {
2530 struct_ser.serialize_field("recordHybridInsertThresholdMs", v)?;
2531 }
2532 if let Some(v) = self.record_hybrid_get_threshold_ms.as_ref() {
2533 struct_ser.serialize_field("recordHybridGetThresholdMs", v)?;
2534 }
2535 if let Some(v) = self.record_hybrid_obtain_threshold_ms.as_ref() {
2536 struct_ser.serialize_field("recordHybridObtainThresholdMs", v)?;
2537 }
2538 if let Some(v) = self.record_hybrid_remove_threshold_ms.as_ref() {
2539 struct_ser.serialize_field("recordHybridRemoveThresholdMs", v)?;
2540 }
2541 if let Some(v) = self.record_hybrid_fetch_threshold_ms.as_ref() {
2542 struct_ser.serialize_field("recordHybridFetchThresholdMs", v)?;
2543 }
2544 struct_ser.end()
2545 }
2546}
2547impl<'de> serde::Deserialize<'de> for TieredCacheTracingRequest {
2548 #[allow(deprecated)]
2549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2550 where
2551 D: serde::Deserializer<'de>,
2552 {
2553 const FIELDS: &[&str] = &[
2554 "enable",
2555 "record_hybrid_insert_threshold_ms",
2556 "recordHybridInsertThresholdMs",
2557 "record_hybrid_get_threshold_ms",
2558 "recordHybridGetThresholdMs",
2559 "record_hybrid_obtain_threshold_ms",
2560 "recordHybridObtainThresholdMs",
2561 "record_hybrid_remove_threshold_ms",
2562 "recordHybridRemoveThresholdMs",
2563 "record_hybrid_fetch_threshold_ms",
2564 "recordHybridFetchThresholdMs",
2565 ];
2566
2567 #[allow(clippy::enum_variant_names)]
2568 enum GeneratedField {
2569 Enable,
2570 RecordHybridInsertThresholdMs,
2571 RecordHybridGetThresholdMs,
2572 RecordHybridObtainThresholdMs,
2573 RecordHybridRemoveThresholdMs,
2574 RecordHybridFetchThresholdMs,
2575 }
2576 impl<'de> serde::Deserialize<'de> for GeneratedField {
2577 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2578 where
2579 D: serde::Deserializer<'de>,
2580 {
2581 struct GeneratedVisitor;
2582
2583 impl serde::de::Visitor<'_> for GeneratedVisitor {
2584 type Value = GeneratedField;
2585
2586 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2587 write!(formatter, "expected one of: {:?}", &FIELDS)
2588 }
2589
2590 #[allow(unused_variables)]
2591 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2592 where
2593 E: serde::de::Error,
2594 {
2595 match value {
2596 "enable" => Ok(GeneratedField::Enable),
2597 "recordHybridInsertThresholdMs" | "record_hybrid_insert_threshold_ms" => Ok(GeneratedField::RecordHybridInsertThresholdMs),
2598 "recordHybridGetThresholdMs" | "record_hybrid_get_threshold_ms" => Ok(GeneratedField::RecordHybridGetThresholdMs),
2599 "recordHybridObtainThresholdMs" | "record_hybrid_obtain_threshold_ms" => Ok(GeneratedField::RecordHybridObtainThresholdMs),
2600 "recordHybridRemoveThresholdMs" | "record_hybrid_remove_threshold_ms" => Ok(GeneratedField::RecordHybridRemoveThresholdMs),
2601 "recordHybridFetchThresholdMs" | "record_hybrid_fetch_threshold_ms" => Ok(GeneratedField::RecordHybridFetchThresholdMs),
2602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2603 }
2604 }
2605 }
2606 deserializer.deserialize_identifier(GeneratedVisitor)
2607 }
2608 }
2609 struct GeneratedVisitor;
2610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2611 type Value = TieredCacheTracingRequest;
2612
2613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2614 formatter.write_str("struct monitor_service.TieredCacheTracingRequest")
2615 }
2616
2617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TieredCacheTracingRequest, V::Error>
2618 where
2619 V: serde::de::MapAccess<'de>,
2620 {
2621 let mut enable__ = None;
2622 let mut record_hybrid_insert_threshold_ms__ = None;
2623 let mut record_hybrid_get_threshold_ms__ = None;
2624 let mut record_hybrid_obtain_threshold_ms__ = None;
2625 let mut record_hybrid_remove_threshold_ms__ = None;
2626 let mut record_hybrid_fetch_threshold_ms__ = None;
2627 while let Some(k) = map_.next_key()? {
2628 match k {
2629 GeneratedField::Enable => {
2630 if enable__.is_some() {
2631 return Err(serde::de::Error::duplicate_field("enable"));
2632 }
2633 enable__ = Some(map_.next_value()?);
2634 }
2635 GeneratedField::RecordHybridInsertThresholdMs => {
2636 if record_hybrid_insert_threshold_ms__.is_some() {
2637 return Err(serde::de::Error::duplicate_field("recordHybridInsertThresholdMs"));
2638 }
2639 record_hybrid_insert_threshold_ms__ =
2640 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2641 ;
2642 }
2643 GeneratedField::RecordHybridGetThresholdMs => {
2644 if record_hybrid_get_threshold_ms__.is_some() {
2645 return Err(serde::de::Error::duplicate_field("recordHybridGetThresholdMs"));
2646 }
2647 record_hybrid_get_threshold_ms__ =
2648 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2649 ;
2650 }
2651 GeneratedField::RecordHybridObtainThresholdMs => {
2652 if record_hybrid_obtain_threshold_ms__.is_some() {
2653 return Err(serde::de::Error::duplicate_field("recordHybridObtainThresholdMs"));
2654 }
2655 record_hybrid_obtain_threshold_ms__ =
2656 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2657 ;
2658 }
2659 GeneratedField::RecordHybridRemoveThresholdMs => {
2660 if record_hybrid_remove_threshold_ms__.is_some() {
2661 return Err(serde::de::Error::duplicate_field("recordHybridRemoveThresholdMs"));
2662 }
2663 record_hybrid_remove_threshold_ms__ =
2664 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2665 ;
2666 }
2667 GeneratedField::RecordHybridFetchThresholdMs => {
2668 if record_hybrid_fetch_threshold_ms__.is_some() {
2669 return Err(serde::de::Error::duplicate_field("recordHybridFetchThresholdMs"));
2670 }
2671 record_hybrid_fetch_threshold_ms__ =
2672 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2673 ;
2674 }
2675 }
2676 }
2677 Ok(TieredCacheTracingRequest {
2678 enable: enable__.unwrap_or_default(),
2679 record_hybrid_insert_threshold_ms: record_hybrid_insert_threshold_ms__,
2680 record_hybrid_get_threshold_ms: record_hybrid_get_threshold_ms__,
2681 record_hybrid_obtain_threshold_ms: record_hybrid_obtain_threshold_ms__,
2682 record_hybrid_remove_threshold_ms: record_hybrid_remove_threshold_ms__,
2683 record_hybrid_fetch_threshold_ms: record_hybrid_fetch_threshold_ms__,
2684 })
2685 }
2686 }
2687 deserializer.deserialize_struct("monitor_service.TieredCacheTracingRequest", FIELDS, GeneratedVisitor)
2688 }
2689}
2690impl serde::Serialize for TieredCacheTracingResponse {
2691 #[allow(deprecated)]
2692 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2693 where
2694 S: serde::Serializer,
2695 {
2696 use serde::ser::SerializeStruct;
2697 let len = 0;
2698 let struct_ser = serializer.serialize_struct("monitor_service.TieredCacheTracingResponse", len)?;
2699 struct_ser.end()
2700 }
2701}
2702impl<'de> serde::Deserialize<'de> for TieredCacheTracingResponse {
2703 #[allow(deprecated)]
2704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2705 where
2706 D: serde::Deserializer<'de>,
2707 {
2708 const FIELDS: &[&str] = &[
2709 ];
2710
2711 #[allow(clippy::enum_variant_names)]
2712 enum GeneratedField {
2713 }
2714 impl<'de> serde::Deserialize<'de> for GeneratedField {
2715 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2716 where
2717 D: serde::Deserializer<'de>,
2718 {
2719 struct GeneratedVisitor;
2720
2721 impl serde::de::Visitor<'_> for GeneratedVisitor {
2722 type Value = GeneratedField;
2723
2724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2725 write!(formatter, "expected one of: {:?}", &FIELDS)
2726 }
2727
2728 #[allow(unused_variables)]
2729 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2730 where
2731 E: serde::de::Error,
2732 {
2733 Err(serde::de::Error::unknown_field(value, FIELDS))
2734 }
2735 }
2736 deserializer.deserialize_identifier(GeneratedVisitor)
2737 }
2738 }
2739 struct GeneratedVisitor;
2740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2741 type Value = TieredCacheTracingResponse;
2742
2743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2744 formatter.write_str("struct monitor_service.TieredCacheTracingResponse")
2745 }
2746
2747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TieredCacheTracingResponse, V::Error>
2748 where
2749 V: serde::de::MapAccess<'de>,
2750 {
2751 while map_.next_key::<GeneratedField>()?.is_some() {
2752 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2753 }
2754 Ok(TieredCacheTracingResponse {
2755 })
2756 }
2757 }
2758 deserializer.deserialize_struct("monitor_service.TieredCacheTracingResponse", FIELDS, GeneratedVisitor)
2759 }
2760}