1#![recursion_limit = "100000000"]
5#![allow(bare_trait_objects)]
6#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals, unused_crate_dependencies, clippy::all)]
7
8pub use self::errors::*;
9pub use self::types::*;
10
11pub mod types;
12
13#[doc(hidden)]
14pub mod dependencies {
15 pub use common as common;
16}
17
18pub mod services {
19 pub mod meta_service {
20 #[derive(Clone, Debug)]
21 pub enum CreateSpaceExn {
22 #[doc(hidden)]
23 Success(crate::types::ExecResp),
24 ApplicationException(::fbthrift::ApplicationException),
25 }
26
27 impl ::std::convert::From<crate::errors::meta_service::CreateSpaceError> for CreateSpaceExn {
28 fn from(err: crate::errors::meta_service::CreateSpaceError) -> Self {
29 match err {
30 crate::errors::meta_service::CreateSpaceError::ApplicationException(aexn) => CreateSpaceExn::ApplicationException(aexn),
31 crate::errors::meta_service::CreateSpaceError::ThriftError(err) => CreateSpaceExn::ApplicationException(::fbthrift::ApplicationException {
32 message: err.to_string(),
33 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
34 }),
35 }
36 }
37 }
38
39 impl ::std::convert::From<::fbthrift::ApplicationException> for CreateSpaceExn {
40 fn from(exn: ::fbthrift::ApplicationException) -> Self {
41 Self::ApplicationException(exn)
42 }
43 }
44
45 impl ::fbthrift::ExceptionInfo for CreateSpaceExn {
46 fn exn_name(&self) -> &'static str {
47 match self {
48 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
49 Self::ApplicationException(aexn) => aexn.exn_name(),
50 }
51 }
52
53 fn exn_value(&self) -> String {
54 match self {
55 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
56 Self::ApplicationException(aexn) => aexn.exn_value(),
57 }
58 }
59
60 fn exn_is_declared(&self) -> bool {
61 match self {
62 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
63 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
64 }
65 }
66 }
67
68 impl ::fbthrift::ResultInfo for CreateSpaceExn {
69 fn result_type(&self) -> ::fbthrift::ResultType {
70 match self {
71 Self::Success(_) => ::fbthrift::ResultType::Return,
72 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
73 }
74 }
75 }
76
77 impl ::fbthrift::GetTType for CreateSpaceExn {
78 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
79 }
80
81 impl<P> ::fbthrift::Serialize<P> for CreateSpaceExn
82 where
83 P: ::fbthrift::ProtocolWriter,
84 {
85 fn write(&self, p: &mut P) {
86 if let Self::ApplicationException(aexn) = self {
87 return aexn.write(p);
88 }
89 p.write_struct_begin("CreateSpace");
90 match self {
91 Self::Success(inner) => {
92 p.write_field_begin(
93 "Success",
94 ::fbthrift::TType::Struct,
95 0i16,
96 );
97 inner.write(p);
98 p.write_field_end();
99 }
100 Self::ApplicationException(_aexn) => unreachable!(),
101 }
102 p.write_field_stop();
103 p.write_struct_end();
104 }
105 }
106
107 impl<P> ::fbthrift::Deserialize<P> for CreateSpaceExn
108 where
109 P: ::fbthrift::ProtocolReader,
110 {
111 fn read(p: &mut P) -> ::anyhow::Result<Self> {
112 static RETURNS: &[::fbthrift::Field] = &[
113 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
114 ];
115 let _ = p.read_struct_begin(|_| ())?;
116 let mut once = false;
117 let mut alt = ::std::option::Option::None;
118 loop {
119 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
120 match ((fty, fid as ::std::primitive::i32), once) {
121 ((::fbthrift::TType::Stop, _), _) => {
122 p.read_field_end()?;
123 break;
124 }
125 ((::fbthrift::TType::Struct, 0i32), false) => {
126 once = true;
127 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
128 }
129 ((ty, _id), false) => p.skip(ty)?,
130 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
131 ::fbthrift::ApplicationException::new(
132 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
133 format!(
134 "unwanted extra union {} field ty {:?} id {}",
135 "CreateSpaceExn",
136 badty,
137 badid,
138 ),
139 )
140 )),
141 }
142 p.read_field_end()?;
143 }
144 p.read_struct_end()?;
145 alt.ok_or_else(||
146 ::fbthrift::ApplicationException::new(
147 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
148 format!("Empty union {}", "CreateSpaceExn"),
149 )
150 .into(),
151 )
152 }
153 }
154
155 #[derive(Clone, Debug)]
156 pub enum DropSpaceExn {
157 #[doc(hidden)]
158 Success(crate::types::ExecResp),
159 ApplicationException(::fbthrift::ApplicationException),
160 }
161
162 impl ::std::convert::From<crate::errors::meta_service::DropSpaceError> for DropSpaceExn {
163 fn from(err: crate::errors::meta_service::DropSpaceError) -> Self {
164 match err {
165 crate::errors::meta_service::DropSpaceError::ApplicationException(aexn) => DropSpaceExn::ApplicationException(aexn),
166 crate::errors::meta_service::DropSpaceError::ThriftError(err) => DropSpaceExn::ApplicationException(::fbthrift::ApplicationException {
167 message: err.to_string(),
168 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
169 }),
170 }
171 }
172 }
173
174 impl ::std::convert::From<::fbthrift::ApplicationException> for DropSpaceExn {
175 fn from(exn: ::fbthrift::ApplicationException) -> Self {
176 Self::ApplicationException(exn)
177 }
178 }
179
180 impl ::fbthrift::ExceptionInfo for DropSpaceExn {
181 fn exn_name(&self) -> &'static str {
182 match self {
183 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
184 Self::ApplicationException(aexn) => aexn.exn_name(),
185 }
186 }
187
188 fn exn_value(&self) -> String {
189 match self {
190 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
191 Self::ApplicationException(aexn) => aexn.exn_value(),
192 }
193 }
194
195 fn exn_is_declared(&self) -> bool {
196 match self {
197 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
198 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
199 }
200 }
201 }
202
203 impl ::fbthrift::ResultInfo for DropSpaceExn {
204 fn result_type(&self) -> ::fbthrift::ResultType {
205 match self {
206 Self::Success(_) => ::fbthrift::ResultType::Return,
207 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
208 }
209 }
210 }
211
212 impl ::fbthrift::GetTType for DropSpaceExn {
213 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
214 }
215
216 impl<P> ::fbthrift::Serialize<P> for DropSpaceExn
217 where
218 P: ::fbthrift::ProtocolWriter,
219 {
220 fn write(&self, p: &mut P) {
221 if let Self::ApplicationException(aexn) = self {
222 return aexn.write(p);
223 }
224 p.write_struct_begin("DropSpace");
225 match self {
226 Self::Success(inner) => {
227 p.write_field_begin(
228 "Success",
229 ::fbthrift::TType::Struct,
230 0i16,
231 );
232 inner.write(p);
233 p.write_field_end();
234 }
235 Self::ApplicationException(_aexn) => unreachable!(),
236 }
237 p.write_field_stop();
238 p.write_struct_end();
239 }
240 }
241
242 impl<P> ::fbthrift::Deserialize<P> for DropSpaceExn
243 where
244 P: ::fbthrift::ProtocolReader,
245 {
246 fn read(p: &mut P) -> ::anyhow::Result<Self> {
247 static RETURNS: &[::fbthrift::Field] = &[
248 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
249 ];
250 let _ = p.read_struct_begin(|_| ())?;
251 let mut once = false;
252 let mut alt = ::std::option::Option::None;
253 loop {
254 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
255 match ((fty, fid as ::std::primitive::i32), once) {
256 ((::fbthrift::TType::Stop, _), _) => {
257 p.read_field_end()?;
258 break;
259 }
260 ((::fbthrift::TType::Struct, 0i32), false) => {
261 once = true;
262 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
263 }
264 ((ty, _id), false) => p.skip(ty)?,
265 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
266 ::fbthrift::ApplicationException::new(
267 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
268 format!(
269 "unwanted extra union {} field ty {:?} id {}",
270 "DropSpaceExn",
271 badty,
272 badid,
273 ),
274 )
275 )),
276 }
277 p.read_field_end()?;
278 }
279 p.read_struct_end()?;
280 alt.ok_or_else(||
281 ::fbthrift::ApplicationException::new(
282 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
283 format!("Empty union {}", "DropSpaceExn"),
284 )
285 .into(),
286 )
287 }
288 }
289
290 #[derive(Clone, Debug)]
291 pub enum GetSpaceExn {
292 #[doc(hidden)]
293 Success(crate::types::GetSpaceResp),
294 ApplicationException(::fbthrift::ApplicationException),
295 }
296
297 impl ::std::convert::From<crate::errors::meta_service::GetSpaceError> for GetSpaceExn {
298 fn from(err: crate::errors::meta_service::GetSpaceError) -> Self {
299 match err {
300 crate::errors::meta_service::GetSpaceError::ApplicationException(aexn) => GetSpaceExn::ApplicationException(aexn),
301 crate::errors::meta_service::GetSpaceError::ThriftError(err) => GetSpaceExn::ApplicationException(::fbthrift::ApplicationException {
302 message: err.to_string(),
303 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
304 }),
305 }
306 }
307 }
308
309 impl ::std::convert::From<::fbthrift::ApplicationException> for GetSpaceExn {
310 fn from(exn: ::fbthrift::ApplicationException) -> Self {
311 Self::ApplicationException(exn)
312 }
313 }
314
315 impl ::fbthrift::ExceptionInfo for GetSpaceExn {
316 fn exn_name(&self) -> &'static str {
317 match self {
318 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
319 Self::ApplicationException(aexn) => aexn.exn_name(),
320 }
321 }
322
323 fn exn_value(&self) -> String {
324 match self {
325 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
326 Self::ApplicationException(aexn) => aexn.exn_value(),
327 }
328 }
329
330 fn exn_is_declared(&self) -> bool {
331 match self {
332 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
333 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
334 }
335 }
336 }
337
338 impl ::fbthrift::ResultInfo for GetSpaceExn {
339 fn result_type(&self) -> ::fbthrift::ResultType {
340 match self {
341 Self::Success(_) => ::fbthrift::ResultType::Return,
342 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
343 }
344 }
345 }
346
347 impl ::fbthrift::GetTType for GetSpaceExn {
348 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
349 }
350
351 impl<P> ::fbthrift::Serialize<P> for GetSpaceExn
352 where
353 P: ::fbthrift::ProtocolWriter,
354 {
355 fn write(&self, p: &mut P) {
356 if let Self::ApplicationException(aexn) = self {
357 return aexn.write(p);
358 }
359 p.write_struct_begin("GetSpace");
360 match self {
361 Self::Success(inner) => {
362 p.write_field_begin(
363 "Success",
364 ::fbthrift::TType::Struct,
365 0i16,
366 );
367 inner.write(p);
368 p.write_field_end();
369 }
370 Self::ApplicationException(_aexn) => unreachable!(),
371 }
372 p.write_field_stop();
373 p.write_struct_end();
374 }
375 }
376
377 impl<P> ::fbthrift::Deserialize<P> for GetSpaceExn
378 where
379 P: ::fbthrift::ProtocolReader,
380 {
381 fn read(p: &mut P) -> ::anyhow::Result<Self> {
382 static RETURNS: &[::fbthrift::Field] = &[
383 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
384 ];
385 let _ = p.read_struct_begin(|_| ())?;
386 let mut once = false;
387 let mut alt = ::std::option::Option::None;
388 loop {
389 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
390 match ((fty, fid as ::std::primitive::i32), once) {
391 ((::fbthrift::TType::Stop, _), _) => {
392 p.read_field_end()?;
393 break;
394 }
395 ((::fbthrift::TType::Struct, 0i32), false) => {
396 once = true;
397 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
398 }
399 ((ty, _id), false) => p.skip(ty)?,
400 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
401 ::fbthrift::ApplicationException::new(
402 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
403 format!(
404 "unwanted extra union {} field ty {:?} id {}",
405 "GetSpaceExn",
406 badty,
407 badid,
408 ),
409 )
410 )),
411 }
412 p.read_field_end()?;
413 }
414 p.read_struct_end()?;
415 alt.ok_or_else(||
416 ::fbthrift::ApplicationException::new(
417 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
418 format!("Empty union {}", "GetSpaceExn"),
419 )
420 .into(),
421 )
422 }
423 }
424
425 #[derive(Clone, Debug)]
426 pub enum ListSpacesExn {
427 #[doc(hidden)]
428 Success(crate::types::ListSpacesResp),
429 ApplicationException(::fbthrift::ApplicationException),
430 }
431
432 impl ::std::convert::From<crate::errors::meta_service::ListSpacesError> for ListSpacesExn {
433 fn from(err: crate::errors::meta_service::ListSpacesError) -> Self {
434 match err {
435 crate::errors::meta_service::ListSpacesError::ApplicationException(aexn) => ListSpacesExn::ApplicationException(aexn),
436 crate::errors::meta_service::ListSpacesError::ThriftError(err) => ListSpacesExn::ApplicationException(::fbthrift::ApplicationException {
437 message: err.to_string(),
438 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
439 }),
440 }
441 }
442 }
443
444 impl ::std::convert::From<::fbthrift::ApplicationException> for ListSpacesExn {
445 fn from(exn: ::fbthrift::ApplicationException) -> Self {
446 Self::ApplicationException(exn)
447 }
448 }
449
450 impl ::fbthrift::ExceptionInfo for ListSpacesExn {
451 fn exn_name(&self) -> &'static str {
452 match self {
453 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
454 Self::ApplicationException(aexn) => aexn.exn_name(),
455 }
456 }
457
458 fn exn_value(&self) -> String {
459 match self {
460 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
461 Self::ApplicationException(aexn) => aexn.exn_value(),
462 }
463 }
464
465 fn exn_is_declared(&self) -> bool {
466 match self {
467 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
468 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
469 }
470 }
471 }
472
473 impl ::fbthrift::ResultInfo for ListSpacesExn {
474 fn result_type(&self) -> ::fbthrift::ResultType {
475 match self {
476 Self::Success(_) => ::fbthrift::ResultType::Return,
477 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
478 }
479 }
480 }
481
482 impl ::fbthrift::GetTType for ListSpacesExn {
483 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
484 }
485
486 impl<P> ::fbthrift::Serialize<P> for ListSpacesExn
487 where
488 P: ::fbthrift::ProtocolWriter,
489 {
490 fn write(&self, p: &mut P) {
491 if let Self::ApplicationException(aexn) = self {
492 return aexn.write(p);
493 }
494 p.write_struct_begin("ListSpaces");
495 match self {
496 Self::Success(inner) => {
497 p.write_field_begin(
498 "Success",
499 ::fbthrift::TType::Struct,
500 0i16,
501 );
502 inner.write(p);
503 p.write_field_end();
504 }
505 Self::ApplicationException(_aexn) => unreachable!(),
506 }
507 p.write_field_stop();
508 p.write_struct_end();
509 }
510 }
511
512 impl<P> ::fbthrift::Deserialize<P> for ListSpacesExn
513 where
514 P: ::fbthrift::ProtocolReader,
515 {
516 fn read(p: &mut P) -> ::anyhow::Result<Self> {
517 static RETURNS: &[::fbthrift::Field] = &[
518 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
519 ];
520 let _ = p.read_struct_begin(|_| ())?;
521 let mut once = false;
522 let mut alt = ::std::option::Option::None;
523 loop {
524 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
525 match ((fty, fid as ::std::primitive::i32), once) {
526 ((::fbthrift::TType::Stop, _), _) => {
527 p.read_field_end()?;
528 break;
529 }
530 ((::fbthrift::TType::Struct, 0i32), false) => {
531 once = true;
532 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
533 }
534 ((ty, _id), false) => p.skip(ty)?,
535 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
536 ::fbthrift::ApplicationException::new(
537 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
538 format!(
539 "unwanted extra union {} field ty {:?} id {}",
540 "ListSpacesExn",
541 badty,
542 badid,
543 ),
544 )
545 )),
546 }
547 p.read_field_end()?;
548 }
549 p.read_struct_end()?;
550 alt.ok_or_else(||
551 ::fbthrift::ApplicationException::new(
552 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
553 format!("Empty union {}", "ListSpacesExn"),
554 )
555 .into(),
556 )
557 }
558 }
559
560 #[derive(Clone, Debug)]
561 pub enum CreateTagExn {
562 #[doc(hidden)]
563 Success(crate::types::ExecResp),
564 ApplicationException(::fbthrift::ApplicationException),
565 }
566
567 impl ::std::convert::From<crate::errors::meta_service::CreateTagError> for CreateTagExn {
568 fn from(err: crate::errors::meta_service::CreateTagError) -> Self {
569 match err {
570 crate::errors::meta_service::CreateTagError::ApplicationException(aexn) => CreateTagExn::ApplicationException(aexn),
571 crate::errors::meta_service::CreateTagError::ThriftError(err) => CreateTagExn::ApplicationException(::fbthrift::ApplicationException {
572 message: err.to_string(),
573 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
574 }),
575 }
576 }
577 }
578
579 impl ::std::convert::From<::fbthrift::ApplicationException> for CreateTagExn {
580 fn from(exn: ::fbthrift::ApplicationException) -> Self {
581 Self::ApplicationException(exn)
582 }
583 }
584
585 impl ::fbthrift::ExceptionInfo for CreateTagExn {
586 fn exn_name(&self) -> &'static str {
587 match self {
588 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
589 Self::ApplicationException(aexn) => aexn.exn_name(),
590 }
591 }
592
593 fn exn_value(&self) -> String {
594 match self {
595 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
596 Self::ApplicationException(aexn) => aexn.exn_value(),
597 }
598 }
599
600 fn exn_is_declared(&self) -> bool {
601 match self {
602 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
603 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
604 }
605 }
606 }
607
608 impl ::fbthrift::ResultInfo for CreateTagExn {
609 fn result_type(&self) -> ::fbthrift::ResultType {
610 match self {
611 Self::Success(_) => ::fbthrift::ResultType::Return,
612 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
613 }
614 }
615 }
616
617 impl ::fbthrift::GetTType for CreateTagExn {
618 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
619 }
620
621 impl<P> ::fbthrift::Serialize<P> for CreateTagExn
622 where
623 P: ::fbthrift::ProtocolWriter,
624 {
625 fn write(&self, p: &mut P) {
626 if let Self::ApplicationException(aexn) = self {
627 return aexn.write(p);
628 }
629 p.write_struct_begin("CreateTag");
630 match self {
631 Self::Success(inner) => {
632 p.write_field_begin(
633 "Success",
634 ::fbthrift::TType::Struct,
635 0i16,
636 );
637 inner.write(p);
638 p.write_field_end();
639 }
640 Self::ApplicationException(_aexn) => unreachable!(),
641 }
642 p.write_field_stop();
643 p.write_struct_end();
644 }
645 }
646
647 impl<P> ::fbthrift::Deserialize<P> for CreateTagExn
648 where
649 P: ::fbthrift::ProtocolReader,
650 {
651 fn read(p: &mut P) -> ::anyhow::Result<Self> {
652 static RETURNS: &[::fbthrift::Field] = &[
653 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
654 ];
655 let _ = p.read_struct_begin(|_| ())?;
656 let mut once = false;
657 let mut alt = ::std::option::Option::None;
658 loop {
659 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
660 match ((fty, fid as ::std::primitive::i32), once) {
661 ((::fbthrift::TType::Stop, _), _) => {
662 p.read_field_end()?;
663 break;
664 }
665 ((::fbthrift::TType::Struct, 0i32), false) => {
666 once = true;
667 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
668 }
669 ((ty, _id), false) => p.skip(ty)?,
670 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
671 ::fbthrift::ApplicationException::new(
672 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
673 format!(
674 "unwanted extra union {} field ty {:?} id {}",
675 "CreateTagExn",
676 badty,
677 badid,
678 ),
679 )
680 )),
681 }
682 p.read_field_end()?;
683 }
684 p.read_struct_end()?;
685 alt.ok_or_else(||
686 ::fbthrift::ApplicationException::new(
687 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
688 format!("Empty union {}", "CreateTagExn"),
689 )
690 .into(),
691 )
692 }
693 }
694
695 #[derive(Clone, Debug)]
696 pub enum AlterTagExn {
697 #[doc(hidden)]
698 Success(crate::types::ExecResp),
699 ApplicationException(::fbthrift::ApplicationException),
700 }
701
702 impl ::std::convert::From<crate::errors::meta_service::AlterTagError> for AlterTagExn {
703 fn from(err: crate::errors::meta_service::AlterTagError) -> Self {
704 match err {
705 crate::errors::meta_service::AlterTagError::ApplicationException(aexn) => AlterTagExn::ApplicationException(aexn),
706 crate::errors::meta_service::AlterTagError::ThriftError(err) => AlterTagExn::ApplicationException(::fbthrift::ApplicationException {
707 message: err.to_string(),
708 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
709 }),
710 }
711 }
712 }
713
714 impl ::std::convert::From<::fbthrift::ApplicationException> for AlterTagExn {
715 fn from(exn: ::fbthrift::ApplicationException) -> Self {
716 Self::ApplicationException(exn)
717 }
718 }
719
720 impl ::fbthrift::ExceptionInfo for AlterTagExn {
721 fn exn_name(&self) -> &'static str {
722 match self {
723 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
724 Self::ApplicationException(aexn) => aexn.exn_name(),
725 }
726 }
727
728 fn exn_value(&self) -> String {
729 match self {
730 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
731 Self::ApplicationException(aexn) => aexn.exn_value(),
732 }
733 }
734
735 fn exn_is_declared(&self) -> bool {
736 match self {
737 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
738 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
739 }
740 }
741 }
742
743 impl ::fbthrift::ResultInfo for AlterTagExn {
744 fn result_type(&self) -> ::fbthrift::ResultType {
745 match self {
746 Self::Success(_) => ::fbthrift::ResultType::Return,
747 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
748 }
749 }
750 }
751
752 impl ::fbthrift::GetTType for AlterTagExn {
753 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
754 }
755
756 impl<P> ::fbthrift::Serialize<P> for AlterTagExn
757 where
758 P: ::fbthrift::ProtocolWriter,
759 {
760 fn write(&self, p: &mut P) {
761 if let Self::ApplicationException(aexn) = self {
762 return aexn.write(p);
763 }
764 p.write_struct_begin("AlterTag");
765 match self {
766 Self::Success(inner) => {
767 p.write_field_begin(
768 "Success",
769 ::fbthrift::TType::Struct,
770 0i16,
771 );
772 inner.write(p);
773 p.write_field_end();
774 }
775 Self::ApplicationException(_aexn) => unreachable!(),
776 }
777 p.write_field_stop();
778 p.write_struct_end();
779 }
780 }
781
782 impl<P> ::fbthrift::Deserialize<P> for AlterTagExn
783 where
784 P: ::fbthrift::ProtocolReader,
785 {
786 fn read(p: &mut P) -> ::anyhow::Result<Self> {
787 static RETURNS: &[::fbthrift::Field] = &[
788 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
789 ];
790 let _ = p.read_struct_begin(|_| ())?;
791 let mut once = false;
792 let mut alt = ::std::option::Option::None;
793 loop {
794 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
795 match ((fty, fid as ::std::primitive::i32), once) {
796 ((::fbthrift::TType::Stop, _), _) => {
797 p.read_field_end()?;
798 break;
799 }
800 ((::fbthrift::TType::Struct, 0i32), false) => {
801 once = true;
802 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
803 }
804 ((ty, _id), false) => p.skip(ty)?,
805 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
806 ::fbthrift::ApplicationException::new(
807 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
808 format!(
809 "unwanted extra union {} field ty {:?} id {}",
810 "AlterTagExn",
811 badty,
812 badid,
813 ),
814 )
815 )),
816 }
817 p.read_field_end()?;
818 }
819 p.read_struct_end()?;
820 alt.ok_or_else(||
821 ::fbthrift::ApplicationException::new(
822 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
823 format!("Empty union {}", "AlterTagExn"),
824 )
825 .into(),
826 )
827 }
828 }
829
830 #[derive(Clone, Debug)]
831 pub enum DropTagExn {
832 #[doc(hidden)]
833 Success(crate::types::ExecResp),
834 ApplicationException(::fbthrift::ApplicationException),
835 }
836
837 impl ::std::convert::From<crate::errors::meta_service::DropTagError> for DropTagExn {
838 fn from(err: crate::errors::meta_service::DropTagError) -> Self {
839 match err {
840 crate::errors::meta_service::DropTagError::ApplicationException(aexn) => DropTagExn::ApplicationException(aexn),
841 crate::errors::meta_service::DropTagError::ThriftError(err) => DropTagExn::ApplicationException(::fbthrift::ApplicationException {
842 message: err.to_string(),
843 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
844 }),
845 }
846 }
847 }
848
849 impl ::std::convert::From<::fbthrift::ApplicationException> for DropTagExn {
850 fn from(exn: ::fbthrift::ApplicationException) -> Self {
851 Self::ApplicationException(exn)
852 }
853 }
854
855 impl ::fbthrift::ExceptionInfo for DropTagExn {
856 fn exn_name(&self) -> &'static str {
857 match self {
858 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
859 Self::ApplicationException(aexn) => aexn.exn_name(),
860 }
861 }
862
863 fn exn_value(&self) -> String {
864 match self {
865 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
866 Self::ApplicationException(aexn) => aexn.exn_value(),
867 }
868 }
869
870 fn exn_is_declared(&self) -> bool {
871 match self {
872 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
873 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
874 }
875 }
876 }
877
878 impl ::fbthrift::ResultInfo for DropTagExn {
879 fn result_type(&self) -> ::fbthrift::ResultType {
880 match self {
881 Self::Success(_) => ::fbthrift::ResultType::Return,
882 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
883 }
884 }
885 }
886
887 impl ::fbthrift::GetTType for DropTagExn {
888 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
889 }
890
891 impl<P> ::fbthrift::Serialize<P> for DropTagExn
892 where
893 P: ::fbthrift::ProtocolWriter,
894 {
895 fn write(&self, p: &mut P) {
896 if let Self::ApplicationException(aexn) = self {
897 return aexn.write(p);
898 }
899 p.write_struct_begin("DropTag");
900 match self {
901 Self::Success(inner) => {
902 p.write_field_begin(
903 "Success",
904 ::fbthrift::TType::Struct,
905 0i16,
906 );
907 inner.write(p);
908 p.write_field_end();
909 }
910 Self::ApplicationException(_aexn) => unreachable!(),
911 }
912 p.write_field_stop();
913 p.write_struct_end();
914 }
915 }
916
917 impl<P> ::fbthrift::Deserialize<P> for DropTagExn
918 where
919 P: ::fbthrift::ProtocolReader,
920 {
921 fn read(p: &mut P) -> ::anyhow::Result<Self> {
922 static RETURNS: &[::fbthrift::Field] = &[
923 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
924 ];
925 let _ = p.read_struct_begin(|_| ())?;
926 let mut once = false;
927 let mut alt = ::std::option::Option::None;
928 loop {
929 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
930 match ((fty, fid as ::std::primitive::i32), once) {
931 ((::fbthrift::TType::Stop, _), _) => {
932 p.read_field_end()?;
933 break;
934 }
935 ((::fbthrift::TType::Struct, 0i32), false) => {
936 once = true;
937 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
938 }
939 ((ty, _id), false) => p.skip(ty)?,
940 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
941 ::fbthrift::ApplicationException::new(
942 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
943 format!(
944 "unwanted extra union {} field ty {:?} id {}",
945 "DropTagExn",
946 badty,
947 badid,
948 ),
949 )
950 )),
951 }
952 p.read_field_end()?;
953 }
954 p.read_struct_end()?;
955 alt.ok_or_else(||
956 ::fbthrift::ApplicationException::new(
957 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
958 format!("Empty union {}", "DropTagExn"),
959 )
960 .into(),
961 )
962 }
963 }
964
965 #[derive(Clone, Debug)]
966 pub enum GetTagExn {
967 #[doc(hidden)]
968 Success(crate::types::GetTagResp),
969 ApplicationException(::fbthrift::ApplicationException),
970 }
971
972 impl ::std::convert::From<crate::errors::meta_service::GetTagError> for GetTagExn {
973 fn from(err: crate::errors::meta_service::GetTagError) -> Self {
974 match err {
975 crate::errors::meta_service::GetTagError::ApplicationException(aexn) => GetTagExn::ApplicationException(aexn),
976 crate::errors::meta_service::GetTagError::ThriftError(err) => GetTagExn::ApplicationException(::fbthrift::ApplicationException {
977 message: err.to_string(),
978 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
979 }),
980 }
981 }
982 }
983
984 impl ::std::convert::From<::fbthrift::ApplicationException> for GetTagExn {
985 fn from(exn: ::fbthrift::ApplicationException) -> Self {
986 Self::ApplicationException(exn)
987 }
988 }
989
990 impl ::fbthrift::ExceptionInfo for GetTagExn {
991 fn exn_name(&self) -> &'static str {
992 match self {
993 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
994 Self::ApplicationException(aexn) => aexn.exn_name(),
995 }
996 }
997
998 fn exn_value(&self) -> String {
999 match self {
1000 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1001 Self::ApplicationException(aexn) => aexn.exn_value(),
1002 }
1003 }
1004
1005 fn exn_is_declared(&self) -> bool {
1006 match self {
1007 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1008 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1009 }
1010 }
1011 }
1012
1013 impl ::fbthrift::ResultInfo for GetTagExn {
1014 fn result_type(&self) -> ::fbthrift::ResultType {
1015 match self {
1016 Self::Success(_) => ::fbthrift::ResultType::Return,
1017 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1018 }
1019 }
1020 }
1021
1022 impl ::fbthrift::GetTType for GetTagExn {
1023 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1024 }
1025
1026 impl<P> ::fbthrift::Serialize<P> for GetTagExn
1027 where
1028 P: ::fbthrift::ProtocolWriter,
1029 {
1030 fn write(&self, p: &mut P) {
1031 if let Self::ApplicationException(aexn) = self {
1032 return aexn.write(p);
1033 }
1034 p.write_struct_begin("GetTag");
1035 match self {
1036 Self::Success(inner) => {
1037 p.write_field_begin(
1038 "Success",
1039 ::fbthrift::TType::Struct,
1040 0i16,
1041 );
1042 inner.write(p);
1043 p.write_field_end();
1044 }
1045 Self::ApplicationException(_aexn) => unreachable!(),
1046 }
1047 p.write_field_stop();
1048 p.write_struct_end();
1049 }
1050 }
1051
1052 impl<P> ::fbthrift::Deserialize<P> for GetTagExn
1053 where
1054 P: ::fbthrift::ProtocolReader,
1055 {
1056 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1057 static RETURNS: &[::fbthrift::Field] = &[
1058 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
1059 ];
1060 let _ = p.read_struct_begin(|_| ())?;
1061 let mut once = false;
1062 let mut alt = ::std::option::Option::None;
1063 loop {
1064 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
1065 match ((fty, fid as ::std::primitive::i32), once) {
1066 ((::fbthrift::TType::Stop, _), _) => {
1067 p.read_field_end()?;
1068 break;
1069 }
1070 ((::fbthrift::TType::Struct, 0i32), false) => {
1071 once = true;
1072 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
1073 }
1074 ((ty, _id), false) => p.skip(ty)?,
1075 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1076 ::fbthrift::ApplicationException::new(
1077 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1078 format!(
1079 "unwanted extra union {} field ty {:?} id {}",
1080 "GetTagExn",
1081 badty,
1082 badid,
1083 ),
1084 )
1085 )),
1086 }
1087 p.read_field_end()?;
1088 }
1089 p.read_struct_end()?;
1090 alt.ok_or_else(||
1091 ::fbthrift::ApplicationException::new(
1092 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1093 format!("Empty union {}", "GetTagExn"),
1094 )
1095 .into(),
1096 )
1097 }
1098 }
1099
1100 #[derive(Clone, Debug)]
1101 pub enum ListTagsExn {
1102 #[doc(hidden)]
1103 Success(crate::types::ListTagsResp),
1104 ApplicationException(::fbthrift::ApplicationException),
1105 }
1106
1107 impl ::std::convert::From<crate::errors::meta_service::ListTagsError> for ListTagsExn {
1108 fn from(err: crate::errors::meta_service::ListTagsError) -> Self {
1109 match err {
1110 crate::errors::meta_service::ListTagsError::ApplicationException(aexn) => ListTagsExn::ApplicationException(aexn),
1111 crate::errors::meta_service::ListTagsError::ThriftError(err) => ListTagsExn::ApplicationException(::fbthrift::ApplicationException {
1112 message: err.to_string(),
1113 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
1114 }),
1115 }
1116 }
1117 }
1118
1119 impl ::std::convert::From<::fbthrift::ApplicationException> for ListTagsExn {
1120 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1121 Self::ApplicationException(exn)
1122 }
1123 }
1124
1125 impl ::fbthrift::ExceptionInfo for ListTagsExn {
1126 fn exn_name(&self) -> &'static str {
1127 match self {
1128 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
1129 Self::ApplicationException(aexn) => aexn.exn_name(),
1130 }
1131 }
1132
1133 fn exn_value(&self) -> String {
1134 match self {
1135 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1136 Self::ApplicationException(aexn) => aexn.exn_value(),
1137 }
1138 }
1139
1140 fn exn_is_declared(&self) -> bool {
1141 match self {
1142 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1143 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1144 }
1145 }
1146 }
1147
1148 impl ::fbthrift::ResultInfo for ListTagsExn {
1149 fn result_type(&self) -> ::fbthrift::ResultType {
1150 match self {
1151 Self::Success(_) => ::fbthrift::ResultType::Return,
1152 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1153 }
1154 }
1155 }
1156
1157 impl ::fbthrift::GetTType for ListTagsExn {
1158 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1159 }
1160
1161 impl<P> ::fbthrift::Serialize<P> for ListTagsExn
1162 where
1163 P: ::fbthrift::ProtocolWriter,
1164 {
1165 fn write(&self, p: &mut P) {
1166 if let Self::ApplicationException(aexn) = self {
1167 return aexn.write(p);
1168 }
1169 p.write_struct_begin("ListTags");
1170 match self {
1171 Self::Success(inner) => {
1172 p.write_field_begin(
1173 "Success",
1174 ::fbthrift::TType::Struct,
1175 0i16,
1176 );
1177 inner.write(p);
1178 p.write_field_end();
1179 }
1180 Self::ApplicationException(_aexn) => unreachable!(),
1181 }
1182 p.write_field_stop();
1183 p.write_struct_end();
1184 }
1185 }
1186
1187 impl<P> ::fbthrift::Deserialize<P> for ListTagsExn
1188 where
1189 P: ::fbthrift::ProtocolReader,
1190 {
1191 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1192 static RETURNS: &[::fbthrift::Field] = &[
1193 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
1194 ];
1195 let _ = p.read_struct_begin(|_| ())?;
1196 let mut once = false;
1197 let mut alt = ::std::option::Option::None;
1198 loop {
1199 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
1200 match ((fty, fid as ::std::primitive::i32), once) {
1201 ((::fbthrift::TType::Stop, _), _) => {
1202 p.read_field_end()?;
1203 break;
1204 }
1205 ((::fbthrift::TType::Struct, 0i32), false) => {
1206 once = true;
1207 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
1208 }
1209 ((ty, _id), false) => p.skip(ty)?,
1210 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1211 ::fbthrift::ApplicationException::new(
1212 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1213 format!(
1214 "unwanted extra union {} field ty {:?} id {}",
1215 "ListTagsExn",
1216 badty,
1217 badid,
1218 ),
1219 )
1220 )),
1221 }
1222 p.read_field_end()?;
1223 }
1224 p.read_struct_end()?;
1225 alt.ok_or_else(||
1226 ::fbthrift::ApplicationException::new(
1227 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1228 format!("Empty union {}", "ListTagsExn"),
1229 )
1230 .into(),
1231 )
1232 }
1233 }
1234
1235 #[derive(Clone, Debug)]
1236 pub enum CreateEdgeExn {
1237 #[doc(hidden)]
1238 Success(crate::types::ExecResp),
1239 ApplicationException(::fbthrift::ApplicationException),
1240 }
1241
1242 impl ::std::convert::From<crate::errors::meta_service::CreateEdgeError> for CreateEdgeExn {
1243 fn from(err: crate::errors::meta_service::CreateEdgeError) -> Self {
1244 match err {
1245 crate::errors::meta_service::CreateEdgeError::ApplicationException(aexn) => CreateEdgeExn::ApplicationException(aexn),
1246 crate::errors::meta_service::CreateEdgeError::ThriftError(err) => CreateEdgeExn::ApplicationException(::fbthrift::ApplicationException {
1247 message: err.to_string(),
1248 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
1249 }),
1250 }
1251 }
1252 }
1253
1254 impl ::std::convert::From<::fbthrift::ApplicationException> for CreateEdgeExn {
1255 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1256 Self::ApplicationException(exn)
1257 }
1258 }
1259
1260 impl ::fbthrift::ExceptionInfo for CreateEdgeExn {
1261 fn exn_name(&self) -> &'static str {
1262 match self {
1263 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
1264 Self::ApplicationException(aexn) => aexn.exn_name(),
1265 }
1266 }
1267
1268 fn exn_value(&self) -> String {
1269 match self {
1270 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1271 Self::ApplicationException(aexn) => aexn.exn_value(),
1272 }
1273 }
1274
1275 fn exn_is_declared(&self) -> bool {
1276 match self {
1277 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1278 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1279 }
1280 }
1281 }
1282
1283 impl ::fbthrift::ResultInfo for CreateEdgeExn {
1284 fn result_type(&self) -> ::fbthrift::ResultType {
1285 match self {
1286 Self::Success(_) => ::fbthrift::ResultType::Return,
1287 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1288 }
1289 }
1290 }
1291
1292 impl ::fbthrift::GetTType for CreateEdgeExn {
1293 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1294 }
1295
1296 impl<P> ::fbthrift::Serialize<P> for CreateEdgeExn
1297 where
1298 P: ::fbthrift::ProtocolWriter,
1299 {
1300 fn write(&self, p: &mut P) {
1301 if let Self::ApplicationException(aexn) = self {
1302 return aexn.write(p);
1303 }
1304 p.write_struct_begin("CreateEdge");
1305 match self {
1306 Self::Success(inner) => {
1307 p.write_field_begin(
1308 "Success",
1309 ::fbthrift::TType::Struct,
1310 0i16,
1311 );
1312 inner.write(p);
1313 p.write_field_end();
1314 }
1315 Self::ApplicationException(_aexn) => unreachable!(),
1316 }
1317 p.write_field_stop();
1318 p.write_struct_end();
1319 }
1320 }
1321
1322 impl<P> ::fbthrift::Deserialize<P> for CreateEdgeExn
1323 where
1324 P: ::fbthrift::ProtocolReader,
1325 {
1326 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1327 static RETURNS: &[::fbthrift::Field] = &[
1328 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
1329 ];
1330 let _ = p.read_struct_begin(|_| ())?;
1331 let mut once = false;
1332 let mut alt = ::std::option::Option::None;
1333 loop {
1334 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
1335 match ((fty, fid as ::std::primitive::i32), once) {
1336 ((::fbthrift::TType::Stop, _), _) => {
1337 p.read_field_end()?;
1338 break;
1339 }
1340 ((::fbthrift::TType::Struct, 0i32), false) => {
1341 once = true;
1342 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
1343 }
1344 ((ty, _id), false) => p.skip(ty)?,
1345 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1346 ::fbthrift::ApplicationException::new(
1347 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1348 format!(
1349 "unwanted extra union {} field ty {:?} id {}",
1350 "CreateEdgeExn",
1351 badty,
1352 badid,
1353 ),
1354 )
1355 )),
1356 }
1357 p.read_field_end()?;
1358 }
1359 p.read_struct_end()?;
1360 alt.ok_or_else(||
1361 ::fbthrift::ApplicationException::new(
1362 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1363 format!("Empty union {}", "CreateEdgeExn"),
1364 )
1365 .into(),
1366 )
1367 }
1368 }
1369
1370 #[derive(Clone, Debug)]
1371 pub enum AlterEdgeExn {
1372 #[doc(hidden)]
1373 Success(crate::types::ExecResp),
1374 ApplicationException(::fbthrift::ApplicationException),
1375 }
1376
1377 impl ::std::convert::From<crate::errors::meta_service::AlterEdgeError> for AlterEdgeExn {
1378 fn from(err: crate::errors::meta_service::AlterEdgeError) -> Self {
1379 match err {
1380 crate::errors::meta_service::AlterEdgeError::ApplicationException(aexn) => AlterEdgeExn::ApplicationException(aexn),
1381 crate::errors::meta_service::AlterEdgeError::ThriftError(err) => AlterEdgeExn::ApplicationException(::fbthrift::ApplicationException {
1382 message: err.to_string(),
1383 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
1384 }),
1385 }
1386 }
1387 }
1388
1389 impl ::std::convert::From<::fbthrift::ApplicationException> for AlterEdgeExn {
1390 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1391 Self::ApplicationException(exn)
1392 }
1393 }
1394
1395 impl ::fbthrift::ExceptionInfo for AlterEdgeExn {
1396 fn exn_name(&self) -> &'static str {
1397 match self {
1398 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
1399 Self::ApplicationException(aexn) => aexn.exn_name(),
1400 }
1401 }
1402
1403 fn exn_value(&self) -> String {
1404 match self {
1405 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1406 Self::ApplicationException(aexn) => aexn.exn_value(),
1407 }
1408 }
1409
1410 fn exn_is_declared(&self) -> bool {
1411 match self {
1412 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1413 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1414 }
1415 }
1416 }
1417
1418 impl ::fbthrift::ResultInfo for AlterEdgeExn {
1419 fn result_type(&self) -> ::fbthrift::ResultType {
1420 match self {
1421 Self::Success(_) => ::fbthrift::ResultType::Return,
1422 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1423 }
1424 }
1425 }
1426
1427 impl ::fbthrift::GetTType for AlterEdgeExn {
1428 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1429 }
1430
1431 impl<P> ::fbthrift::Serialize<P> for AlterEdgeExn
1432 where
1433 P: ::fbthrift::ProtocolWriter,
1434 {
1435 fn write(&self, p: &mut P) {
1436 if let Self::ApplicationException(aexn) = self {
1437 return aexn.write(p);
1438 }
1439 p.write_struct_begin("AlterEdge");
1440 match self {
1441 Self::Success(inner) => {
1442 p.write_field_begin(
1443 "Success",
1444 ::fbthrift::TType::Struct,
1445 0i16,
1446 );
1447 inner.write(p);
1448 p.write_field_end();
1449 }
1450 Self::ApplicationException(_aexn) => unreachable!(),
1451 }
1452 p.write_field_stop();
1453 p.write_struct_end();
1454 }
1455 }
1456
1457 impl<P> ::fbthrift::Deserialize<P> for AlterEdgeExn
1458 where
1459 P: ::fbthrift::ProtocolReader,
1460 {
1461 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1462 static RETURNS: &[::fbthrift::Field] = &[
1463 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
1464 ];
1465 let _ = p.read_struct_begin(|_| ())?;
1466 let mut once = false;
1467 let mut alt = ::std::option::Option::None;
1468 loop {
1469 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
1470 match ((fty, fid as ::std::primitive::i32), once) {
1471 ((::fbthrift::TType::Stop, _), _) => {
1472 p.read_field_end()?;
1473 break;
1474 }
1475 ((::fbthrift::TType::Struct, 0i32), false) => {
1476 once = true;
1477 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
1478 }
1479 ((ty, _id), false) => p.skip(ty)?,
1480 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1481 ::fbthrift::ApplicationException::new(
1482 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1483 format!(
1484 "unwanted extra union {} field ty {:?} id {}",
1485 "AlterEdgeExn",
1486 badty,
1487 badid,
1488 ),
1489 )
1490 )),
1491 }
1492 p.read_field_end()?;
1493 }
1494 p.read_struct_end()?;
1495 alt.ok_or_else(||
1496 ::fbthrift::ApplicationException::new(
1497 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1498 format!("Empty union {}", "AlterEdgeExn"),
1499 )
1500 .into(),
1501 )
1502 }
1503 }
1504
1505 #[derive(Clone, Debug)]
1506 pub enum DropEdgeExn {
1507 #[doc(hidden)]
1508 Success(crate::types::ExecResp),
1509 ApplicationException(::fbthrift::ApplicationException),
1510 }
1511
1512 impl ::std::convert::From<crate::errors::meta_service::DropEdgeError> for DropEdgeExn {
1513 fn from(err: crate::errors::meta_service::DropEdgeError) -> Self {
1514 match err {
1515 crate::errors::meta_service::DropEdgeError::ApplicationException(aexn) => DropEdgeExn::ApplicationException(aexn),
1516 crate::errors::meta_service::DropEdgeError::ThriftError(err) => DropEdgeExn::ApplicationException(::fbthrift::ApplicationException {
1517 message: err.to_string(),
1518 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
1519 }),
1520 }
1521 }
1522 }
1523
1524 impl ::std::convert::From<::fbthrift::ApplicationException> for DropEdgeExn {
1525 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1526 Self::ApplicationException(exn)
1527 }
1528 }
1529
1530 impl ::fbthrift::ExceptionInfo for DropEdgeExn {
1531 fn exn_name(&self) -> &'static str {
1532 match self {
1533 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
1534 Self::ApplicationException(aexn) => aexn.exn_name(),
1535 }
1536 }
1537
1538 fn exn_value(&self) -> String {
1539 match self {
1540 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1541 Self::ApplicationException(aexn) => aexn.exn_value(),
1542 }
1543 }
1544
1545 fn exn_is_declared(&self) -> bool {
1546 match self {
1547 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1548 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1549 }
1550 }
1551 }
1552
1553 impl ::fbthrift::ResultInfo for DropEdgeExn {
1554 fn result_type(&self) -> ::fbthrift::ResultType {
1555 match self {
1556 Self::Success(_) => ::fbthrift::ResultType::Return,
1557 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1558 }
1559 }
1560 }
1561
1562 impl ::fbthrift::GetTType for DropEdgeExn {
1563 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1564 }
1565
1566 impl<P> ::fbthrift::Serialize<P> for DropEdgeExn
1567 where
1568 P: ::fbthrift::ProtocolWriter,
1569 {
1570 fn write(&self, p: &mut P) {
1571 if let Self::ApplicationException(aexn) = self {
1572 return aexn.write(p);
1573 }
1574 p.write_struct_begin("DropEdge");
1575 match self {
1576 Self::Success(inner) => {
1577 p.write_field_begin(
1578 "Success",
1579 ::fbthrift::TType::Struct,
1580 0i16,
1581 );
1582 inner.write(p);
1583 p.write_field_end();
1584 }
1585 Self::ApplicationException(_aexn) => unreachable!(),
1586 }
1587 p.write_field_stop();
1588 p.write_struct_end();
1589 }
1590 }
1591
1592 impl<P> ::fbthrift::Deserialize<P> for DropEdgeExn
1593 where
1594 P: ::fbthrift::ProtocolReader,
1595 {
1596 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1597 static RETURNS: &[::fbthrift::Field] = &[
1598 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
1599 ];
1600 let _ = p.read_struct_begin(|_| ())?;
1601 let mut once = false;
1602 let mut alt = ::std::option::Option::None;
1603 loop {
1604 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
1605 match ((fty, fid as ::std::primitive::i32), once) {
1606 ((::fbthrift::TType::Stop, _), _) => {
1607 p.read_field_end()?;
1608 break;
1609 }
1610 ((::fbthrift::TType::Struct, 0i32), false) => {
1611 once = true;
1612 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
1613 }
1614 ((ty, _id), false) => p.skip(ty)?,
1615 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1616 ::fbthrift::ApplicationException::new(
1617 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1618 format!(
1619 "unwanted extra union {} field ty {:?} id {}",
1620 "DropEdgeExn",
1621 badty,
1622 badid,
1623 ),
1624 )
1625 )),
1626 }
1627 p.read_field_end()?;
1628 }
1629 p.read_struct_end()?;
1630 alt.ok_or_else(||
1631 ::fbthrift::ApplicationException::new(
1632 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1633 format!("Empty union {}", "DropEdgeExn"),
1634 )
1635 .into(),
1636 )
1637 }
1638 }
1639
1640 #[derive(Clone, Debug)]
1641 pub enum GetEdgeExn {
1642 #[doc(hidden)]
1643 Success(crate::types::GetEdgeResp),
1644 ApplicationException(::fbthrift::ApplicationException),
1645 }
1646
1647 impl ::std::convert::From<crate::errors::meta_service::GetEdgeError> for GetEdgeExn {
1648 fn from(err: crate::errors::meta_service::GetEdgeError) -> Self {
1649 match err {
1650 crate::errors::meta_service::GetEdgeError::ApplicationException(aexn) => GetEdgeExn::ApplicationException(aexn),
1651 crate::errors::meta_service::GetEdgeError::ThriftError(err) => GetEdgeExn::ApplicationException(::fbthrift::ApplicationException {
1652 message: err.to_string(),
1653 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
1654 }),
1655 }
1656 }
1657 }
1658
1659 impl ::std::convert::From<::fbthrift::ApplicationException> for GetEdgeExn {
1660 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1661 Self::ApplicationException(exn)
1662 }
1663 }
1664
1665 impl ::fbthrift::ExceptionInfo for GetEdgeExn {
1666 fn exn_name(&self) -> &'static str {
1667 match self {
1668 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
1669 Self::ApplicationException(aexn) => aexn.exn_name(),
1670 }
1671 }
1672
1673 fn exn_value(&self) -> String {
1674 match self {
1675 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1676 Self::ApplicationException(aexn) => aexn.exn_value(),
1677 }
1678 }
1679
1680 fn exn_is_declared(&self) -> bool {
1681 match self {
1682 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1683 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1684 }
1685 }
1686 }
1687
1688 impl ::fbthrift::ResultInfo for GetEdgeExn {
1689 fn result_type(&self) -> ::fbthrift::ResultType {
1690 match self {
1691 Self::Success(_) => ::fbthrift::ResultType::Return,
1692 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1693 }
1694 }
1695 }
1696
1697 impl ::fbthrift::GetTType for GetEdgeExn {
1698 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1699 }
1700
1701 impl<P> ::fbthrift::Serialize<P> for GetEdgeExn
1702 where
1703 P: ::fbthrift::ProtocolWriter,
1704 {
1705 fn write(&self, p: &mut P) {
1706 if let Self::ApplicationException(aexn) = self {
1707 return aexn.write(p);
1708 }
1709 p.write_struct_begin("GetEdge");
1710 match self {
1711 Self::Success(inner) => {
1712 p.write_field_begin(
1713 "Success",
1714 ::fbthrift::TType::Struct,
1715 0i16,
1716 );
1717 inner.write(p);
1718 p.write_field_end();
1719 }
1720 Self::ApplicationException(_aexn) => unreachable!(),
1721 }
1722 p.write_field_stop();
1723 p.write_struct_end();
1724 }
1725 }
1726
1727 impl<P> ::fbthrift::Deserialize<P> for GetEdgeExn
1728 where
1729 P: ::fbthrift::ProtocolReader,
1730 {
1731 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1732 static RETURNS: &[::fbthrift::Field] = &[
1733 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
1734 ];
1735 let _ = p.read_struct_begin(|_| ())?;
1736 let mut once = false;
1737 let mut alt = ::std::option::Option::None;
1738 loop {
1739 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
1740 match ((fty, fid as ::std::primitive::i32), once) {
1741 ((::fbthrift::TType::Stop, _), _) => {
1742 p.read_field_end()?;
1743 break;
1744 }
1745 ((::fbthrift::TType::Struct, 0i32), false) => {
1746 once = true;
1747 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
1748 }
1749 ((ty, _id), false) => p.skip(ty)?,
1750 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1751 ::fbthrift::ApplicationException::new(
1752 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1753 format!(
1754 "unwanted extra union {} field ty {:?} id {}",
1755 "GetEdgeExn",
1756 badty,
1757 badid,
1758 ),
1759 )
1760 )),
1761 }
1762 p.read_field_end()?;
1763 }
1764 p.read_struct_end()?;
1765 alt.ok_or_else(||
1766 ::fbthrift::ApplicationException::new(
1767 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1768 format!("Empty union {}", "GetEdgeExn"),
1769 )
1770 .into(),
1771 )
1772 }
1773 }
1774
1775 #[derive(Clone, Debug)]
1776 pub enum ListEdgesExn {
1777 #[doc(hidden)]
1778 Success(crate::types::ListEdgesResp),
1779 ApplicationException(::fbthrift::ApplicationException),
1780 }
1781
1782 impl ::std::convert::From<crate::errors::meta_service::ListEdgesError> for ListEdgesExn {
1783 fn from(err: crate::errors::meta_service::ListEdgesError) -> Self {
1784 match err {
1785 crate::errors::meta_service::ListEdgesError::ApplicationException(aexn) => ListEdgesExn::ApplicationException(aexn),
1786 crate::errors::meta_service::ListEdgesError::ThriftError(err) => ListEdgesExn::ApplicationException(::fbthrift::ApplicationException {
1787 message: err.to_string(),
1788 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
1789 }),
1790 }
1791 }
1792 }
1793
1794 impl ::std::convert::From<::fbthrift::ApplicationException> for ListEdgesExn {
1795 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1796 Self::ApplicationException(exn)
1797 }
1798 }
1799
1800 impl ::fbthrift::ExceptionInfo for ListEdgesExn {
1801 fn exn_name(&self) -> &'static str {
1802 match self {
1803 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
1804 Self::ApplicationException(aexn) => aexn.exn_name(),
1805 }
1806 }
1807
1808 fn exn_value(&self) -> String {
1809 match self {
1810 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1811 Self::ApplicationException(aexn) => aexn.exn_value(),
1812 }
1813 }
1814
1815 fn exn_is_declared(&self) -> bool {
1816 match self {
1817 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1818 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1819 }
1820 }
1821 }
1822
1823 impl ::fbthrift::ResultInfo for ListEdgesExn {
1824 fn result_type(&self) -> ::fbthrift::ResultType {
1825 match self {
1826 Self::Success(_) => ::fbthrift::ResultType::Return,
1827 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1828 }
1829 }
1830 }
1831
1832 impl ::fbthrift::GetTType for ListEdgesExn {
1833 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1834 }
1835
1836 impl<P> ::fbthrift::Serialize<P> for ListEdgesExn
1837 where
1838 P: ::fbthrift::ProtocolWriter,
1839 {
1840 fn write(&self, p: &mut P) {
1841 if let Self::ApplicationException(aexn) = self {
1842 return aexn.write(p);
1843 }
1844 p.write_struct_begin("ListEdges");
1845 match self {
1846 Self::Success(inner) => {
1847 p.write_field_begin(
1848 "Success",
1849 ::fbthrift::TType::Struct,
1850 0i16,
1851 );
1852 inner.write(p);
1853 p.write_field_end();
1854 }
1855 Self::ApplicationException(_aexn) => unreachable!(),
1856 }
1857 p.write_field_stop();
1858 p.write_struct_end();
1859 }
1860 }
1861
1862 impl<P> ::fbthrift::Deserialize<P> for ListEdgesExn
1863 where
1864 P: ::fbthrift::ProtocolReader,
1865 {
1866 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1867 static RETURNS: &[::fbthrift::Field] = &[
1868 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
1869 ];
1870 let _ = p.read_struct_begin(|_| ())?;
1871 let mut once = false;
1872 let mut alt = ::std::option::Option::None;
1873 loop {
1874 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
1875 match ((fty, fid as ::std::primitive::i32), once) {
1876 ((::fbthrift::TType::Stop, _), _) => {
1877 p.read_field_end()?;
1878 break;
1879 }
1880 ((::fbthrift::TType::Struct, 0i32), false) => {
1881 once = true;
1882 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
1883 }
1884 ((ty, _id), false) => p.skip(ty)?,
1885 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1886 ::fbthrift::ApplicationException::new(
1887 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1888 format!(
1889 "unwanted extra union {} field ty {:?} id {}",
1890 "ListEdgesExn",
1891 badty,
1892 badid,
1893 ),
1894 )
1895 )),
1896 }
1897 p.read_field_end()?;
1898 }
1899 p.read_struct_end()?;
1900 alt.ok_or_else(||
1901 ::fbthrift::ApplicationException::new(
1902 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1903 format!("Empty union {}", "ListEdgesExn"),
1904 )
1905 .into(),
1906 )
1907 }
1908 }
1909
1910 #[derive(Clone, Debug)]
1911 pub enum ListHostsExn {
1912 #[doc(hidden)]
1913 Success(crate::types::ListHostsResp),
1914 ApplicationException(::fbthrift::ApplicationException),
1915 }
1916
1917 impl ::std::convert::From<crate::errors::meta_service::ListHostsError> for ListHostsExn {
1918 fn from(err: crate::errors::meta_service::ListHostsError) -> Self {
1919 match err {
1920 crate::errors::meta_service::ListHostsError::ApplicationException(aexn) => ListHostsExn::ApplicationException(aexn),
1921 crate::errors::meta_service::ListHostsError::ThriftError(err) => ListHostsExn::ApplicationException(::fbthrift::ApplicationException {
1922 message: err.to_string(),
1923 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
1924 }),
1925 }
1926 }
1927 }
1928
1929 impl ::std::convert::From<::fbthrift::ApplicationException> for ListHostsExn {
1930 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1931 Self::ApplicationException(exn)
1932 }
1933 }
1934
1935 impl ::fbthrift::ExceptionInfo for ListHostsExn {
1936 fn exn_name(&self) -> &'static str {
1937 match self {
1938 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
1939 Self::ApplicationException(aexn) => aexn.exn_name(),
1940 }
1941 }
1942
1943 fn exn_value(&self) -> String {
1944 match self {
1945 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
1946 Self::ApplicationException(aexn) => aexn.exn_value(),
1947 }
1948 }
1949
1950 fn exn_is_declared(&self) -> bool {
1951 match self {
1952 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
1953 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
1954 }
1955 }
1956 }
1957
1958 impl ::fbthrift::ResultInfo for ListHostsExn {
1959 fn result_type(&self) -> ::fbthrift::ResultType {
1960 match self {
1961 Self::Success(_) => ::fbthrift::ResultType::Return,
1962 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
1963 }
1964 }
1965 }
1966
1967 impl ::fbthrift::GetTType for ListHostsExn {
1968 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1969 }
1970
1971 impl<P> ::fbthrift::Serialize<P> for ListHostsExn
1972 where
1973 P: ::fbthrift::ProtocolWriter,
1974 {
1975 fn write(&self, p: &mut P) {
1976 if let Self::ApplicationException(aexn) = self {
1977 return aexn.write(p);
1978 }
1979 p.write_struct_begin("ListHosts");
1980 match self {
1981 Self::Success(inner) => {
1982 p.write_field_begin(
1983 "Success",
1984 ::fbthrift::TType::Struct,
1985 0i16,
1986 );
1987 inner.write(p);
1988 p.write_field_end();
1989 }
1990 Self::ApplicationException(_aexn) => unreachable!(),
1991 }
1992 p.write_field_stop();
1993 p.write_struct_end();
1994 }
1995 }
1996
1997 impl<P> ::fbthrift::Deserialize<P> for ListHostsExn
1998 where
1999 P: ::fbthrift::ProtocolReader,
2000 {
2001 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2002 static RETURNS: &[::fbthrift::Field] = &[
2003 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2004 ];
2005 let _ = p.read_struct_begin(|_| ())?;
2006 let mut once = false;
2007 let mut alt = ::std::option::Option::None;
2008 loop {
2009 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2010 match ((fty, fid as ::std::primitive::i32), once) {
2011 ((::fbthrift::TType::Stop, _), _) => {
2012 p.read_field_end()?;
2013 break;
2014 }
2015 ((::fbthrift::TType::Struct, 0i32), false) => {
2016 once = true;
2017 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2018 }
2019 ((ty, _id), false) => p.skip(ty)?,
2020 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2021 ::fbthrift::ApplicationException::new(
2022 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2023 format!(
2024 "unwanted extra union {} field ty {:?} id {}",
2025 "ListHostsExn",
2026 badty,
2027 badid,
2028 ),
2029 )
2030 )),
2031 }
2032 p.read_field_end()?;
2033 }
2034 p.read_struct_end()?;
2035 alt.ok_or_else(||
2036 ::fbthrift::ApplicationException::new(
2037 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2038 format!("Empty union {}", "ListHostsExn"),
2039 )
2040 .into(),
2041 )
2042 }
2043 }
2044
2045 #[derive(Clone, Debug)]
2046 pub enum GetPartsAllocExn {
2047 #[doc(hidden)]
2048 Success(crate::types::GetPartsAllocResp),
2049 ApplicationException(::fbthrift::ApplicationException),
2050 }
2051
2052 impl ::std::convert::From<crate::errors::meta_service::GetPartsAllocError> for GetPartsAllocExn {
2053 fn from(err: crate::errors::meta_service::GetPartsAllocError) -> Self {
2054 match err {
2055 crate::errors::meta_service::GetPartsAllocError::ApplicationException(aexn) => GetPartsAllocExn::ApplicationException(aexn),
2056 crate::errors::meta_service::GetPartsAllocError::ThriftError(err) => GetPartsAllocExn::ApplicationException(::fbthrift::ApplicationException {
2057 message: err.to_string(),
2058 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
2059 }),
2060 }
2061 }
2062 }
2063
2064 impl ::std::convert::From<::fbthrift::ApplicationException> for GetPartsAllocExn {
2065 fn from(exn: ::fbthrift::ApplicationException) -> Self {
2066 Self::ApplicationException(exn)
2067 }
2068 }
2069
2070 impl ::fbthrift::ExceptionInfo for GetPartsAllocExn {
2071 fn exn_name(&self) -> &'static str {
2072 match self {
2073 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
2074 Self::ApplicationException(aexn) => aexn.exn_name(),
2075 }
2076 }
2077
2078 fn exn_value(&self) -> String {
2079 match self {
2080 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
2081 Self::ApplicationException(aexn) => aexn.exn_value(),
2082 }
2083 }
2084
2085 fn exn_is_declared(&self) -> bool {
2086 match self {
2087 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
2088 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
2089 }
2090 }
2091 }
2092
2093 impl ::fbthrift::ResultInfo for GetPartsAllocExn {
2094 fn result_type(&self) -> ::fbthrift::ResultType {
2095 match self {
2096 Self::Success(_) => ::fbthrift::ResultType::Return,
2097 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
2098 }
2099 }
2100 }
2101
2102 impl ::fbthrift::GetTType for GetPartsAllocExn {
2103 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
2104 }
2105
2106 impl<P> ::fbthrift::Serialize<P> for GetPartsAllocExn
2107 where
2108 P: ::fbthrift::ProtocolWriter,
2109 {
2110 fn write(&self, p: &mut P) {
2111 if let Self::ApplicationException(aexn) = self {
2112 return aexn.write(p);
2113 }
2114 p.write_struct_begin("GetPartsAlloc");
2115 match self {
2116 Self::Success(inner) => {
2117 p.write_field_begin(
2118 "Success",
2119 ::fbthrift::TType::Struct,
2120 0i16,
2121 );
2122 inner.write(p);
2123 p.write_field_end();
2124 }
2125 Self::ApplicationException(_aexn) => unreachable!(),
2126 }
2127 p.write_field_stop();
2128 p.write_struct_end();
2129 }
2130 }
2131
2132 impl<P> ::fbthrift::Deserialize<P> for GetPartsAllocExn
2133 where
2134 P: ::fbthrift::ProtocolReader,
2135 {
2136 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2137 static RETURNS: &[::fbthrift::Field] = &[
2138 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2139 ];
2140 let _ = p.read_struct_begin(|_| ())?;
2141 let mut once = false;
2142 let mut alt = ::std::option::Option::None;
2143 loop {
2144 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2145 match ((fty, fid as ::std::primitive::i32), once) {
2146 ((::fbthrift::TType::Stop, _), _) => {
2147 p.read_field_end()?;
2148 break;
2149 }
2150 ((::fbthrift::TType::Struct, 0i32), false) => {
2151 once = true;
2152 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2153 }
2154 ((ty, _id), false) => p.skip(ty)?,
2155 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2156 ::fbthrift::ApplicationException::new(
2157 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2158 format!(
2159 "unwanted extra union {} field ty {:?} id {}",
2160 "GetPartsAllocExn",
2161 badty,
2162 badid,
2163 ),
2164 )
2165 )),
2166 }
2167 p.read_field_end()?;
2168 }
2169 p.read_struct_end()?;
2170 alt.ok_or_else(||
2171 ::fbthrift::ApplicationException::new(
2172 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2173 format!("Empty union {}", "GetPartsAllocExn"),
2174 )
2175 .into(),
2176 )
2177 }
2178 }
2179
2180 #[derive(Clone, Debug)]
2181 pub enum ListPartsExn {
2182 #[doc(hidden)]
2183 Success(crate::types::ListPartsResp),
2184 ApplicationException(::fbthrift::ApplicationException),
2185 }
2186
2187 impl ::std::convert::From<crate::errors::meta_service::ListPartsError> for ListPartsExn {
2188 fn from(err: crate::errors::meta_service::ListPartsError) -> Self {
2189 match err {
2190 crate::errors::meta_service::ListPartsError::ApplicationException(aexn) => ListPartsExn::ApplicationException(aexn),
2191 crate::errors::meta_service::ListPartsError::ThriftError(err) => ListPartsExn::ApplicationException(::fbthrift::ApplicationException {
2192 message: err.to_string(),
2193 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
2194 }),
2195 }
2196 }
2197 }
2198
2199 impl ::std::convert::From<::fbthrift::ApplicationException> for ListPartsExn {
2200 fn from(exn: ::fbthrift::ApplicationException) -> Self {
2201 Self::ApplicationException(exn)
2202 }
2203 }
2204
2205 impl ::fbthrift::ExceptionInfo for ListPartsExn {
2206 fn exn_name(&self) -> &'static str {
2207 match self {
2208 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
2209 Self::ApplicationException(aexn) => aexn.exn_name(),
2210 }
2211 }
2212
2213 fn exn_value(&self) -> String {
2214 match self {
2215 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
2216 Self::ApplicationException(aexn) => aexn.exn_value(),
2217 }
2218 }
2219
2220 fn exn_is_declared(&self) -> bool {
2221 match self {
2222 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
2223 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
2224 }
2225 }
2226 }
2227
2228 impl ::fbthrift::ResultInfo for ListPartsExn {
2229 fn result_type(&self) -> ::fbthrift::ResultType {
2230 match self {
2231 Self::Success(_) => ::fbthrift::ResultType::Return,
2232 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
2233 }
2234 }
2235 }
2236
2237 impl ::fbthrift::GetTType for ListPartsExn {
2238 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
2239 }
2240
2241 impl<P> ::fbthrift::Serialize<P> for ListPartsExn
2242 where
2243 P: ::fbthrift::ProtocolWriter,
2244 {
2245 fn write(&self, p: &mut P) {
2246 if let Self::ApplicationException(aexn) = self {
2247 return aexn.write(p);
2248 }
2249 p.write_struct_begin("ListParts");
2250 match self {
2251 Self::Success(inner) => {
2252 p.write_field_begin(
2253 "Success",
2254 ::fbthrift::TType::Struct,
2255 0i16,
2256 );
2257 inner.write(p);
2258 p.write_field_end();
2259 }
2260 Self::ApplicationException(_aexn) => unreachable!(),
2261 }
2262 p.write_field_stop();
2263 p.write_struct_end();
2264 }
2265 }
2266
2267 impl<P> ::fbthrift::Deserialize<P> for ListPartsExn
2268 where
2269 P: ::fbthrift::ProtocolReader,
2270 {
2271 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2272 static RETURNS: &[::fbthrift::Field] = &[
2273 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2274 ];
2275 let _ = p.read_struct_begin(|_| ())?;
2276 let mut once = false;
2277 let mut alt = ::std::option::Option::None;
2278 loop {
2279 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2280 match ((fty, fid as ::std::primitive::i32), once) {
2281 ((::fbthrift::TType::Stop, _), _) => {
2282 p.read_field_end()?;
2283 break;
2284 }
2285 ((::fbthrift::TType::Struct, 0i32), false) => {
2286 once = true;
2287 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2288 }
2289 ((ty, _id), false) => p.skip(ty)?,
2290 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2291 ::fbthrift::ApplicationException::new(
2292 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2293 format!(
2294 "unwanted extra union {} field ty {:?} id {}",
2295 "ListPartsExn",
2296 badty,
2297 badid,
2298 ),
2299 )
2300 )),
2301 }
2302 p.read_field_end()?;
2303 }
2304 p.read_struct_end()?;
2305 alt.ok_or_else(||
2306 ::fbthrift::ApplicationException::new(
2307 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2308 format!("Empty union {}", "ListPartsExn"),
2309 )
2310 .into(),
2311 )
2312 }
2313 }
2314
2315 #[derive(Clone, Debug)]
2316 pub enum MultiPutExn {
2317 #[doc(hidden)]
2318 Success(crate::types::ExecResp),
2319 ApplicationException(::fbthrift::ApplicationException),
2320 }
2321
2322 impl ::std::convert::From<crate::errors::meta_service::MultiPutError> for MultiPutExn {
2323 fn from(err: crate::errors::meta_service::MultiPutError) -> Self {
2324 match err {
2325 crate::errors::meta_service::MultiPutError::ApplicationException(aexn) => MultiPutExn::ApplicationException(aexn),
2326 crate::errors::meta_service::MultiPutError::ThriftError(err) => MultiPutExn::ApplicationException(::fbthrift::ApplicationException {
2327 message: err.to_string(),
2328 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
2329 }),
2330 }
2331 }
2332 }
2333
2334 impl ::std::convert::From<::fbthrift::ApplicationException> for MultiPutExn {
2335 fn from(exn: ::fbthrift::ApplicationException) -> Self {
2336 Self::ApplicationException(exn)
2337 }
2338 }
2339
2340 impl ::fbthrift::ExceptionInfo for MultiPutExn {
2341 fn exn_name(&self) -> &'static str {
2342 match self {
2343 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
2344 Self::ApplicationException(aexn) => aexn.exn_name(),
2345 }
2346 }
2347
2348 fn exn_value(&self) -> String {
2349 match self {
2350 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
2351 Self::ApplicationException(aexn) => aexn.exn_value(),
2352 }
2353 }
2354
2355 fn exn_is_declared(&self) -> bool {
2356 match self {
2357 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
2358 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
2359 }
2360 }
2361 }
2362
2363 impl ::fbthrift::ResultInfo for MultiPutExn {
2364 fn result_type(&self) -> ::fbthrift::ResultType {
2365 match self {
2366 Self::Success(_) => ::fbthrift::ResultType::Return,
2367 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
2368 }
2369 }
2370 }
2371
2372 impl ::fbthrift::GetTType for MultiPutExn {
2373 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
2374 }
2375
2376 impl<P> ::fbthrift::Serialize<P> for MultiPutExn
2377 where
2378 P: ::fbthrift::ProtocolWriter,
2379 {
2380 fn write(&self, p: &mut P) {
2381 if let Self::ApplicationException(aexn) = self {
2382 return aexn.write(p);
2383 }
2384 p.write_struct_begin("MultiPut");
2385 match self {
2386 Self::Success(inner) => {
2387 p.write_field_begin(
2388 "Success",
2389 ::fbthrift::TType::Struct,
2390 0i16,
2391 );
2392 inner.write(p);
2393 p.write_field_end();
2394 }
2395 Self::ApplicationException(_aexn) => unreachable!(),
2396 }
2397 p.write_field_stop();
2398 p.write_struct_end();
2399 }
2400 }
2401
2402 impl<P> ::fbthrift::Deserialize<P> for MultiPutExn
2403 where
2404 P: ::fbthrift::ProtocolReader,
2405 {
2406 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2407 static RETURNS: &[::fbthrift::Field] = &[
2408 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2409 ];
2410 let _ = p.read_struct_begin(|_| ())?;
2411 let mut once = false;
2412 let mut alt = ::std::option::Option::None;
2413 loop {
2414 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2415 match ((fty, fid as ::std::primitive::i32), once) {
2416 ((::fbthrift::TType::Stop, _), _) => {
2417 p.read_field_end()?;
2418 break;
2419 }
2420 ((::fbthrift::TType::Struct, 0i32), false) => {
2421 once = true;
2422 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2423 }
2424 ((ty, _id), false) => p.skip(ty)?,
2425 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2426 ::fbthrift::ApplicationException::new(
2427 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2428 format!(
2429 "unwanted extra union {} field ty {:?} id {}",
2430 "MultiPutExn",
2431 badty,
2432 badid,
2433 ),
2434 )
2435 )),
2436 }
2437 p.read_field_end()?;
2438 }
2439 p.read_struct_end()?;
2440 alt.ok_or_else(||
2441 ::fbthrift::ApplicationException::new(
2442 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2443 format!("Empty union {}", "MultiPutExn"),
2444 )
2445 .into(),
2446 )
2447 }
2448 }
2449
2450 #[derive(Clone, Debug)]
2451 pub enum GetExn {
2452 #[doc(hidden)]
2453 Success(crate::types::GetResp),
2454 ApplicationException(::fbthrift::ApplicationException),
2455 }
2456
2457 impl ::std::convert::From<crate::errors::meta_service::GetError> for GetExn {
2458 fn from(err: crate::errors::meta_service::GetError) -> Self {
2459 match err {
2460 crate::errors::meta_service::GetError::ApplicationException(aexn) => GetExn::ApplicationException(aexn),
2461 crate::errors::meta_service::GetError::ThriftError(err) => GetExn::ApplicationException(::fbthrift::ApplicationException {
2462 message: err.to_string(),
2463 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
2464 }),
2465 }
2466 }
2467 }
2468
2469 impl ::std::convert::From<::fbthrift::ApplicationException> for GetExn {
2470 fn from(exn: ::fbthrift::ApplicationException) -> Self {
2471 Self::ApplicationException(exn)
2472 }
2473 }
2474
2475 impl ::fbthrift::ExceptionInfo for GetExn {
2476 fn exn_name(&self) -> &'static str {
2477 match self {
2478 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
2479 Self::ApplicationException(aexn) => aexn.exn_name(),
2480 }
2481 }
2482
2483 fn exn_value(&self) -> String {
2484 match self {
2485 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
2486 Self::ApplicationException(aexn) => aexn.exn_value(),
2487 }
2488 }
2489
2490 fn exn_is_declared(&self) -> bool {
2491 match self {
2492 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
2493 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
2494 }
2495 }
2496 }
2497
2498 impl ::fbthrift::ResultInfo for GetExn {
2499 fn result_type(&self) -> ::fbthrift::ResultType {
2500 match self {
2501 Self::Success(_) => ::fbthrift::ResultType::Return,
2502 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
2503 }
2504 }
2505 }
2506
2507 impl ::fbthrift::GetTType for GetExn {
2508 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
2509 }
2510
2511 impl<P> ::fbthrift::Serialize<P> for GetExn
2512 where
2513 P: ::fbthrift::ProtocolWriter,
2514 {
2515 fn write(&self, p: &mut P) {
2516 if let Self::ApplicationException(aexn) = self {
2517 return aexn.write(p);
2518 }
2519 p.write_struct_begin("Get");
2520 match self {
2521 Self::Success(inner) => {
2522 p.write_field_begin(
2523 "Success",
2524 ::fbthrift::TType::Struct,
2525 0i16,
2526 );
2527 inner.write(p);
2528 p.write_field_end();
2529 }
2530 Self::ApplicationException(_aexn) => unreachable!(),
2531 }
2532 p.write_field_stop();
2533 p.write_struct_end();
2534 }
2535 }
2536
2537 impl<P> ::fbthrift::Deserialize<P> for GetExn
2538 where
2539 P: ::fbthrift::ProtocolReader,
2540 {
2541 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2542 static RETURNS: &[::fbthrift::Field] = &[
2543 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2544 ];
2545 let _ = p.read_struct_begin(|_| ())?;
2546 let mut once = false;
2547 let mut alt = ::std::option::Option::None;
2548 loop {
2549 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2550 match ((fty, fid as ::std::primitive::i32), once) {
2551 ((::fbthrift::TType::Stop, _), _) => {
2552 p.read_field_end()?;
2553 break;
2554 }
2555 ((::fbthrift::TType::Struct, 0i32), false) => {
2556 once = true;
2557 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2558 }
2559 ((ty, _id), false) => p.skip(ty)?,
2560 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2561 ::fbthrift::ApplicationException::new(
2562 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2563 format!(
2564 "unwanted extra union {} field ty {:?} id {}",
2565 "GetExn",
2566 badty,
2567 badid,
2568 ),
2569 )
2570 )),
2571 }
2572 p.read_field_end()?;
2573 }
2574 p.read_struct_end()?;
2575 alt.ok_or_else(||
2576 ::fbthrift::ApplicationException::new(
2577 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2578 format!("Empty union {}", "GetExn"),
2579 )
2580 .into(),
2581 )
2582 }
2583 }
2584
2585 #[derive(Clone, Debug)]
2586 pub enum MultiGetExn {
2587 #[doc(hidden)]
2588 Success(crate::types::MultiGetResp),
2589 ApplicationException(::fbthrift::ApplicationException),
2590 }
2591
2592 impl ::std::convert::From<crate::errors::meta_service::MultiGetError> for MultiGetExn {
2593 fn from(err: crate::errors::meta_service::MultiGetError) -> Self {
2594 match err {
2595 crate::errors::meta_service::MultiGetError::ApplicationException(aexn) => MultiGetExn::ApplicationException(aexn),
2596 crate::errors::meta_service::MultiGetError::ThriftError(err) => MultiGetExn::ApplicationException(::fbthrift::ApplicationException {
2597 message: err.to_string(),
2598 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
2599 }),
2600 }
2601 }
2602 }
2603
2604 impl ::std::convert::From<::fbthrift::ApplicationException> for MultiGetExn {
2605 fn from(exn: ::fbthrift::ApplicationException) -> Self {
2606 Self::ApplicationException(exn)
2607 }
2608 }
2609
2610 impl ::fbthrift::ExceptionInfo for MultiGetExn {
2611 fn exn_name(&self) -> &'static str {
2612 match self {
2613 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
2614 Self::ApplicationException(aexn) => aexn.exn_name(),
2615 }
2616 }
2617
2618 fn exn_value(&self) -> String {
2619 match self {
2620 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
2621 Self::ApplicationException(aexn) => aexn.exn_value(),
2622 }
2623 }
2624
2625 fn exn_is_declared(&self) -> bool {
2626 match self {
2627 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
2628 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
2629 }
2630 }
2631 }
2632
2633 impl ::fbthrift::ResultInfo for MultiGetExn {
2634 fn result_type(&self) -> ::fbthrift::ResultType {
2635 match self {
2636 Self::Success(_) => ::fbthrift::ResultType::Return,
2637 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
2638 }
2639 }
2640 }
2641
2642 impl ::fbthrift::GetTType for MultiGetExn {
2643 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
2644 }
2645
2646 impl<P> ::fbthrift::Serialize<P> for MultiGetExn
2647 where
2648 P: ::fbthrift::ProtocolWriter,
2649 {
2650 fn write(&self, p: &mut P) {
2651 if let Self::ApplicationException(aexn) = self {
2652 return aexn.write(p);
2653 }
2654 p.write_struct_begin("MultiGet");
2655 match self {
2656 Self::Success(inner) => {
2657 p.write_field_begin(
2658 "Success",
2659 ::fbthrift::TType::Struct,
2660 0i16,
2661 );
2662 inner.write(p);
2663 p.write_field_end();
2664 }
2665 Self::ApplicationException(_aexn) => unreachable!(),
2666 }
2667 p.write_field_stop();
2668 p.write_struct_end();
2669 }
2670 }
2671
2672 impl<P> ::fbthrift::Deserialize<P> for MultiGetExn
2673 where
2674 P: ::fbthrift::ProtocolReader,
2675 {
2676 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2677 static RETURNS: &[::fbthrift::Field] = &[
2678 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2679 ];
2680 let _ = p.read_struct_begin(|_| ())?;
2681 let mut once = false;
2682 let mut alt = ::std::option::Option::None;
2683 loop {
2684 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2685 match ((fty, fid as ::std::primitive::i32), once) {
2686 ((::fbthrift::TType::Stop, _), _) => {
2687 p.read_field_end()?;
2688 break;
2689 }
2690 ((::fbthrift::TType::Struct, 0i32), false) => {
2691 once = true;
2692 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2693 }
2694 ((ty, _id), false) => p.skip(ty)?,
2695 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2696 ::fbthrift::ApplicationException::new(
2697 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2698 format!(
2699 "unwanted extra union {} field ty {:?} id {}",
2700 "MultiGetExn",
2701 badty,
2702 badid,
2703 ),
2704 )
2705 )),
2706 }
2707 p.read_field_end()?;
2708 }
2709 p.read_struct_end()?;
2710 alt.ok_or_else(||
2711 ::fbthrift::ApplicationException::new(
2712 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2713 format!("Empty union {}", "MultiGetExn"),
2714 )
2715 .into(),
2716 )
2717 }
2718 }
2719
2720 #[derive(Clone, Debug)]
2721 pub enum RemoveExn {
2722 #[doc(hidden)]
2723 Success(crate::types::ExecResp),
2724 ApplicationException(::fbthrift::ApplicationException),
2725 }
2726
2727 impl ::std::convert::From<crate::errors::meta_service::RemoveError> for RemoveExn {
2728 fn from(err: crate::errors::meta_service::RemoveError) -> Self {
2729 match err {
2730 crate::errors::meta_service::RemoveError::ApplicationException(aexn) => RemoveExn::ApplicationException(aexn),
2731 crate::errors::meta_service::RemoveError::ThriftError(err) => RemoveExn::ApplicationException(::fbthrift::ApplicationException {
2732 message: err.to_string(),
2733 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
2734 }),
2735 }
2736 }
2737 }
2738
2739 impl ::std::convert::From<::fbthrift::ApplicationException> for RemoveExn {
2740 fn from(exn: ::fbthrift::ApplicationException) -> Self {
2741 Self::ApplicationException(exn)
2742 }
2743 }
2744
2745 impl ::fbthrift::ExceptionInfo for RemoveExn {
2746 fn exn_name(&self) -> &'static str {
2747 match self {
2748 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
2749 Self::ApplicationException(aexn) => aexn.exn_name(),
2750 }
2751 }
2752
2753 fn exn_value(&self) -> String {
2754 match self {
2755 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
2756 Self::ApplicationException(aexn) => aexn.exn_value(),
2757 }
2758 }
2759
2760 fn exn_is_declared(&self) -> bool {
2761 match self {
2762 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
2763 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
2764 }
2765 }
2766 }
2767
2768 impl ::fbthrift::ResultInfo for RemoveExn {
2769 fn result_type(&self) -> ::fbthrift::ResultType {
2770 match self {
2771 Self::Success(_) => ::fbthrift::ResultType::Return,
2772 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
2773 }
2774 }
2775 }
2776
2777 impl ::fbthrift::GetTType for RemoveExn {
2778 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
2779 }
2780
2781 impl<P> ::fbthrift::Serialize<P> for RemoveExn
2782 where
2783 P: ::fbthrift::ProtocolWriter,
2784 {
2785 fn write(&self, p: &mut P) {
2786 if let Self::ApplicationException(aexn) = self {
2787 return aexn.write(p);
2788 }
2789 p.write_struct_begin("Remove");
2790 match self {
2791 Self::Success(inner) => {
2792 p.write_field_begin(
2793 "Success",
2794 ::fbthrift::TType::Struct,
2795 0i16,
2796 );
2797 inner.write(p);
2798 p.write_field_end();
2799 }
2800 Self::ApplicationException(_aexn) => unreachable!(),
2801 }
2802 p.write_field_stop();
2803 p.write_struct_end();
2804 }
2805 }
2806
2807 impl<P> ::fbthrift::Deserialize<P> for RemoveExn
2808 where
2809 P: ::fbthrift::ProtocolReader,
2810 {
2811 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2812 static RETURNS: &[::fbthrift::Field] = &[
2813 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2814 ];
2815 let _ = p.read_struct_begin(|_| ())?;
2816 let mut once = false;
2817 let mut alt = ::std::option::Option::None;
2818 loop {
2819 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2820 match ((fty, fid as ::std::primitive::i32), once) {
2821 ((::fbthrift::TType::Stop, _), _) => {
2822 p.read_field_end()?;
2823 break;
2824 }
2825 ((::fbthrift::TType::Struct, 0i32), false) => {
2826 once = true;
2827 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2828 }
2829 ((ty, _id), false) => p.skip(ty)?,
2830 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2831 ::fbthrift::ApplicationException::new(
2832 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2833 format!(
2834 "unwanted extra union {} field ty {:?} id {}",
2835 "RemoveExn",
2836 badty,
2837 badid,
2838 ),
2839 )
2840 )),
2841 }
2842 p.read_field_end()?;
2843 }
2844 p.read_struct_end()?;
2845 alt.ok_or_else(||
2846 ::fbthrift::ApplicationException::new(
2847 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2848 format!("Empty union {}", "RemoveExn"),
2849 )
2850 .into(),
2851 )
2852 }
2853 }
2854
2855 #[derive(Clone, Debug)]
2856 pub enum RemoveRangeExn {
2857 #[doc(hidden)]
2858 Success(crate::types::ExecResp),
2859 ApplicationException(::fbthrift::ApplicationException),
2860 }
2861
2862 impl ::std::convert::From<crate::errors::meta_service::RemoveRangeError> for RemoveRangeExn {
2863 fn from(err: crate::errors::meta_service::RemoveRangeError) -> Self {
2864 match err {
2865 crate::errors::meta_service::RemoveRangeError::ApplicationException(aexn) => RemoveRangeExn::ApplicationException(aexn),
2866 crate::errors::meta_service::RemoveRangeError::ThriftError(err) => RemoveRangeExn::ApplicationException(::fbthrift::ApplicationException {
2867 message: err.to_string(),
2868 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
2869 }),
2870 }
2871 }
2872 }
2873
2874 impl ::std::convert::From<::fbthrift::ApplicationException> for RemoveRangeExn {
2875 fn from(exn: ::fbthrift::ApplicationException) -> Self {
2876 Self::ApplicationException(exn)
2877 }
2878 }
2879
2880 impl ::fbthrift::ExceptionInfo for RemoveRangeExn {
2881 fn exn_name(&self) -> &'static str {
2882 match self {
2883 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
2884 Self::ApplicationException(aexn) => aexn.exn_name(),
2885 }
2886 }
2887
2888 fn exn_value(&self) -> String {
2889 match self {
2890 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
2891 Self::ApplicationException(aexn) => aexn.exn_value(),
2892 }
2893 }
2894
2895 fn exn_is_declared(&self) -> bool {
2896 match self {
2897 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
2898 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
2899 }
2900 }
2901 }
2902
2903 impl ::fbthrift::ResultInfo for RemoveRangeExn {
2904 fn result_type(&self) -> ::fbthrift::ResultType {
2905 match self {
2906 Self::Success(_) => ::fbthrift::ResultType::Return,
2907 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
2908 }
2909 }
2910 }
2911
2912 impl ::fbthrift::GetTType for RemoveRangeExn {
2913 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
2914 }
2915
2916 impl<P> ::fbthrift::Serialize<P> for RemoveRangeExn
2917 where
2918 P: ::fbthrift::ProtocolWriter,
2919 {
2920 fn write(&self, p: &mut P) {
2921 if let Self::ApplicationException(aexn) = self {
2922 return aexn.write(p);
2923 }
2924 p.write_struct_begin("RemoveRange");
2925 match self {
2926 Self::Success(inner) => {
2927 p.write_field_begin(
2928 "Success",
2929 ::fbthrift::TType::Struct,
2930 0i16,
2931 );
2932 inner.write(p);
2933 p.write_field_end();
2934 }
2935 Self::ApplicationException(_aexn) => unreachable!(),
2936 }
2937 p.write_field_stop();
2938 p.write_struct_end();
2939 }
2940 }
2941
2942 impl<P> ::fbthrift::Deserialize<P> for RemoveRangeExn
2943 where
2944 P: ::fbthrift::ProtocolReader,
2945 {
2946 fn read(p: &mut P) -> ::anyhow::Result<Self> {
2947 static RETURNS: &[::fbthrift::Field] = &[
2948 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
2949 ];
2950 let _ = p.read_struct_begin(|_| ())?;
2951 let mut once = false;
2952 let mut alt = ::std::option::Option::None;
2953 loop {
2954 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
2955 match ((fty, fid as ::std::primitive::i32), once) {
2956 ((::fbthrift::TType::Stop, _), _) => {
2957 p.read_field_end()?;
2958 break;
2959 }
2960 ((::fbthrift::TType::Struct, 0i32), false) => {
2961 once = true;
2962 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
2963 }
2964 ((ty, _id), false) => p.skip(ty)?,
2965 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
2966 ::fbthrift::ApplicationException::new(
2967 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
2968 format!(
2969 "unwanted extra union {} field ty {:?} id {}",
2970 "RemoveRangeExn",
2971 badty,
2972 badid,
2973 ),
2974 )
2975 )),
2976 }
2977 p.read_field_end()?;
2978 }
2979 p.read_struct_end()?;
2980 alt.ok_or_else(||
2981 ::fbthrift::ApplicationException::new(
2982 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
2983 format!("Empty union {}", "RemoveRangeExn"),
2984 )
2985 .into(),
2986 )
2987 }
2988 }
2989
2990 #[derive(Clone, Debug)]
2991 pub enum ScanExn {
2992 #[doc(hidden)]
2993 Success(crate::types::ScanResp),
2994 ApplicationException(::fbthrift::ApplicationException),
2995 }
2996
2997 impl ::std::convert::From<crate::errors::meta_service::ScanError> for ScanExn {
2998 fn from(err: crate::errors::meta_service::ScanError) -> Self {
2999 match err {
3000 crate::errors::meta_service::ScanError::ApplicationException(aexn) => ScanExn::ApplicationException(aexn),
3001 crate::errors::meta_service::ScanError::ThriftError(err) => ScanExn::ApplicationException(::fbthrift::ApplicationException {
3002 message: err.to_string(),
3003 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3004 }),
3005 }
3006 }
3007 }
3008
3009 impl ::std::convert::From<::fbthrift::ApplicationException> for ScanExn {
3010 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3011 Self::ApplicationException(exn)
3012 }
3013 }
3014
3015 impl ::fbthrift::ExceptionInfo for ScanExn {
3016 fn exn_name(&self) -> &'static str {
3017 match self {
3018 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3019 Self::ApplicationException(aexn) => aexn.exn_name(),
3020 }
3021 }
3022
3023 fn exn_value(&self) -> String {
3024 match self {
3025 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3026 Self::ApplicationException(aexn) => aexn.exn_value(),
3027 }
3028 }
3029
3030 fn exn_is_declared(&self) -> bool {
3031 match self {
3032 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3033 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3034 }
3035 }
3036 }
3037
3038 impl ::fbthrift::ResultInfo for ScanExn {
3039 fn result_type(&self) -> ::fbthrift::ResultType {
3040 match self {
3041 Self::Success(_) => ::fbthrift::ResultType::Return,
3042 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3043 }
3044 }
3045 }
3046
3047 impl ::fbthrift::GetTType for ScanExn {
3048 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3049 }
3050
3051 impl<P> ::fbthrift::Serialize<P> for ScanExn
3052 where
3053 P: ::fbthrift::ProtocolWriter,
3054 {
3055 fn write(&self, p: &mut P) {
3056 if let Self::ApplicationException(aexn) = self {
3057 return aexn.write(p);
3058 }
3059 p.write_struct_begin("Scan");
3060 match self {
3061 Self::Success(inner) => {
3062 p.write_field_begin(
3063 "Success",
3064 ::fbthrift::TType::Struct,
3065 0i16,
3066 );
3067 inner.write(p);
3068 p.write_field_end();
3069 }
3070 Self::ApplicationException(_aexn) => unreachable!(),
3071 }
3072 p.write_field_stop();
3073 p.write_struct_end();
3074 }
3075 }
3076
3077 impl<P> ::fbthrift::Deserialize<P> for ScanExn
3078 where
3079 P: ::fbthrift::ProtocolReader,
3080 {
3081 fn read(p: &mut P) -> ::anyhow::Result<Self> {
3082 static RETURNS: &[::fbthrift::Field] = &[
3083 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
3084 ];
3085 let _ = p.read_struct_begin(|_| ())?;
3086 let mut once = false;
3087 let mut alt = ::std::option::Option::None;
3088 loop {
3089 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
3090 match ((fty, fid as ::std::primitive::i32), once) {
3091 ((::fbthrift::TType::Stop, _), _) => {
3092 p.read_field_end()?;
3093 break;
3094 }
3095 ((::fbthrift::TType::Struct, 0i32), false) => {
3096 once = true;
3097 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
3098 }
3099 ((ty, _id), false) => p.skip(ty)?,
3100 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
3101 ::fbthrift::ApplicationException::new(
3102 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
3103 format!(
3104 "unwanted extra union {} field ty {:?} id {}",
3105 "ScanExn",
3106 badty,
3107 badid,
3108 ),
3109 )
3110 )),
3111 }
3112 p.read_field_end()?;
3113 }
3114 p.read_struct_end()?;
3115 alt.ok_or_else(||
3116 ::fbthrift::ApplicationException::new(
3117 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
3118 format!("Empty union {}", "ScanExn"),
3119 )
3120 .into(),
3121 )
3122 }
3123 }
3124
3125 #[derive(Clone, Debug)]
3126 pub enum CreateTagIndexExn {
3127 #[doc(hidden)]
3128 Success(crate::types::ExecResp),
3129 ApplicationException(::fbthrift::ApplicationException),
3130 }
3131
3132 impl ::std::convert::From<crate::errors::meta_service::CreateTagIndexError> for CreateTagIndexExn {
3133 fn from(err: crate::errors::meta_service::CreateTagIndexError) -> Self {
3134 match err {
3135 crate::errors::meta_service::CreateTagIndexError::ApplicationException(aexn) => CreateTagIndexExn::ApplicationException(aexn),
3136 crate::errors::meta_service::CreateTagIndexError::ThriftError(err) => CreateTagIndexExn::ApplicationException(::fbthrift::ApplicationException {
3137 message: err.to_string(),
3138 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3139 }),
3140 }
3141 }
3142 }
3143
3144 impl ::std::convert::From<::fbthrift::ApplicationException> for CreateTagIndexExn {
3145 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3146 Self::ApplicationException(exn)
3147 }
3148 }
3149
3150 impl ::fbthrift::ExceptionInfo for CreateTagIndexExn {
3151 fn exn_name(&self) -> &'static str {
3152 match self {
3153 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3154 Self::ApplicationException(aexn) => aexn.exn_name(),
3155 }
3156 }
3157
3158 fn exn_value(&self) -> String {
3159 match self {
3160 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3161 Self::ApplicationException(aexn) => aexn.exn_value(),
3162 }
3163 }
3164
3165 fn exn_is_declared(&self) -> bool {
3166 match self {
3167 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3168 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3169 }
3170 }
3171 }
3172
3173 impl ::fbthrift::ResultInfo for CreateTagIndexExn {
3174 fn result_type(&self) -> ::fbthrift::ResultType {
3175 match self {
3176 Self::Success(_) => ::fbthrift::ResultType::Return,
3177 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3178 }
3179 }
3180 }
3181
3182 impl ::fbthrift::GetTType for CreateTagIndexExn {
3183 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3184 }
3185
3186 impl<P> ::fbthrift::Serialize<P> for CreateTagIndexExn
3187 where
3188 P: ::fbthrift::ProtocolWriter,
3189 {
3190 fn write(&self, p: &mut P) {
3191 if let Self::ApplicationException(aexn) = self {
3192 return aexn.write(p);
3193 }
3194 p.write_struct_begin("CreateTagIndex");
3195 match self {
3196 Self::Success(inner) => {
3197 p.write_field_begin(
3198 "Success",
3199 ::fbthrift::TType::Struct,
3200 0i16,
3201 );
3202 inner.write(p);
3203 p.write_field_end();
3204 }
3205 Self::ApplicationException(_aexn) => unreachable!(),
3206 }
3207 p.write_field_stop();
3208 p.write_struct_end();
3209 }
3210 }
3211
3212 impl<P> ::fbthrift::Deserialize<P> for CreateTagIndexExn
3213 where
3214 P: ::fbthrift::ProtocolReader,
3215 {
3216 fn read(p: &mut P) -> ::anyhow::Result<Self> {
3217 static RETURNS: &[::fbthrift::Field] = &[
3218 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
3219 ];
3220 let _ = p.read_struct_begin(|_| ())?;
3221 let mut once = false;
3222 let mut alt = ::std::option::Option::None;
3223 loop {
3224 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
3225 match ((fty, fid as ::std::primitive::i32), once) {
3226 ((::fbthrift::TType::Stop, _), _) => {
3227 p.read_field_end()?;
3228 break;
3229 }
3230 ((::fbthrift::TType::Struct, 0i32), false) => {
3231 once = true;
3232 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
3233 }
3234 ((ty, _id), false) => p.skip(ty)?,
3235 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
3236 ::fbthrift::ApplicationException::new(
3237 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
3238 format!(
3239 "unwanted extra union {} field ty {:?} id {}",
3240 "CreateTagIndexExn",
3241 badty,
3242 badid,
3243 ),
3244 )
3245 )),
3246 }
3247 p.read_field_end()?;
3248 }
3249 p.read_struct_end()?;
3250 alt.ok_or_else(||
3251 ::fbthrift::ApplicationException::new(
3252 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
3253 format!("Empty union {}", "CreateTagIndexExn"),
3254 )
3255 .into(),
3256 )
3257 }
3258 }
3259
3260 #[derive(Clone, Debug)]
3261 pub enum DropTagIndexExn {
3262 #[doc(hidden)]
3263 Success(crate::types::ExecResp),
3264 ApplicationException(::fbthrift::ApplicationException),
3265 }
3266
3267 impl ::std::convert::From<crate::errors::meta_service::DropTagIndexError> for DropTagIndexExn {
3268 fn from(err: crate::errors::meta_service::DropTagIndexError) -> Self {
3269 match err {
3270 crate::errors::meta_service::DropTagIndexError::ApplicationException(aexn) => DropTagIndexExn::ApplicationException(aexn),
3271 crate::errors::meta_service::DropTagIndexError::ThriftError(err) => DropTagIndexExn::ApplicationException(::fbthrift::ApplicationException {
3272 message: err.to_string(),
3273 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3274 }),
3275 }
3276 }
3277 }
3278
3279 impl ::std::convert::From<::fbthrift::ApplicationException> for DropTagIndexExn {
3280 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3281 Self::ApplicationException(exn)
3282 }
3283 }
3284
3285 impl ::fbthrift::ExceptionInfo for DropTagIndexExn {
3286 fn exn_name(&self) -> &'static str {
3287 match self {
3288 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3289 Self::ApplicationException(aexn) => aexn.exn_name(),
3290 }
3291 }
3292
3293 fn exn_value(&self) -> String {
3294 match self {
3295 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3296 Self::ApplicationException(aexn) => aexn.exn_value(),
3297 }
3298 }
3299
3300 fn exn_is_declared(&self) -> bool {
3301 match self {
3302 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3303 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3304 }
3305 }
3306 }
3307
3308 impl ::fbthrift::ResultInfo for DropTagIndexExn {
3309 fn result_type(&self) -> ::fbthrift::ResultType {
3310 match self {
3311 Self::Success(_) => ::fbthrift::ResultType::Return,
3312 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3313 }
3314 }
3315 }
3316
3317 impl ::fbthrift::GetTType for DropTagIndexExn {
3318 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3319 }
3320
3321 impl<P> ::fbthrift::Serialize<P> for DropTagIndexExn
3322 where
3323 P: ::fbthrift::ProtocolWriter,
3324 {
3325 fn write(&self, p: &mut P) {
3326 if let Self::ApplicationException(aexn) = self {
3327 return aexn.write(p);
3328 }
3329 p.write_struct_begin("DropTagIndex");
3330 match self {
3331 Self::Success(inner) => {
3332 p.write_field_begin(
3333 "Success",
3334 ::fbthrift::TType::Struct,
3335 0i16,
3336 );
3337 inner.write(p);
3338 p.write_field_end();
3339 }
3340 Self::ApplicationException(_aexn) => unreachable!(),
3341 }
3342 p.write_field_stop();
3343 p.write_struct_end();
3344 }
3345 }
3346
3347 impl<P> ::fbthrift::Deserialize<P> for DropTagIndexExn
3348 where
3349 P: ::fbthrift::ProtocolReader,
3350 {
3351 fn read(p: &mut P) -> ::anyhow::Result<Self> {
3352 static RETURNS: &[::fbthrift::Field] = &[
3353 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
3354 ];
3355 let _ = p.read_struct_begin(|_| ())?;
3356 let mut once = false;
3357 let mut alt = ::std::option::Option::None;
3358 loop {
3359 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
3360 match ((fty, fid as ::std::primitive::i32), once) {
3361 ((::fbthrift::TType::Stop, _), _) => {
3362 p.read_field_end()?;
3363 break;
3364 }
3365 ((::fbthrift::TType::Struct, 0i32), false) => {
3366 once = true;
3367 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
3368 }
3369 ((ty, _id), false) => p.skip(ty)?,
3370 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
3371 ::fbthrift::ApplicationException::new(
3372 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
3373 format!(
3374 "unwanted extra union {} field ty {:?} id {}",
3375 "DropTagIndexExn",
3376 badty,
3377 badid,
3378 ),
3379 )
3380 )),
3381 }
3382 p.read_field_end()?;
3383 }
3384 p.read_struct_end()?;
3385 alt.ok_or_else(||
3386 ::fbthrift::ApplicationException::new(
3387 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
3388 format!("Empty union {}", "DropTagIndexExn"),
3389 )
3390 .into(),
3391 )
3392 }
3393 }
3394
3395 #[derive(Clone, Debug)]
3396 pub enum GetTagIndexExn {
3397 #[doc(hidden)]
3398 Success(crate::types::GetTagIndexResp),
3399 ApplicationException(::fbthrift::ApplicationException),
3400 }
3401
3402 impl ::std::convert::From<crate::errors::meta_service::GetTagIndexError> for GetTagIndexExn {
3403 fn from(err: crate::errors::meta_service::GetTagIndexError) -> Self {
3404 match err {
3405 crate::errors::meta_service::GetTagIndexError::ApplicationException(aexn) => GetTagIndexExn::ApplicationException(aexn),
3406 crate::errors::meta_service::GetTagIndexError::ThriftError(err) => GetTagIndexExn::ApplicationException(::fbthrift::ApplicationException {
3407 message: err.to_string(),
3408 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3409 }),
3410 }
3411 }
3412 }
3413
3414 impl ::std::convert::From<::fbthrift::ApplicationException> for GetTagIndexExn {
3415 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3416 Self::ApplicationException(exn)
3417 }
3418 }
3419
3420 impl ::fbthrift::ExceptionInfo for GetTagIndexExn {
3421 fn exn_name(&self) -> &'static str {
3422 match self {
3423 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3424 Self::ApplicationException(aexn) => aexn.exn_name(),
3425 }
3426 }
3427
3428 fn exn_value(&self) -> String {
3429 match self {
3430 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3431 Self::ApplicationException(aexn) => aexn.exn_value(),
3432 }
3433 }
3434
3435 fn exn_is_declared(&self) -> bool {
3436 match self {
3437 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3438 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3439 }
3440 }
3441 }
3442
3443 impl ::fbthrift::ResultInfo for GetTagIndexExn {
3444 fn result_type(&self) -> ::fbthrift::ResultType {
3445 match self {
3446 Self::Success(_) => ::fbthrift::ResultType::Return,
3447 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3448 }
3449 }
3450 }
3451
3452 impl ::fbthrift::GetTType for GetTagIndexExn {
3453 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3454 }
3455
3456 impl<P> ::fbthrift::Serialize<P> for GetTagIndexExn
3457 where
3458 P: ::fbthrift::ProtocolWriter,
3459 {
3460 fn write(&self, p: &mut P) {
3461 if let Self::ApplicationException(aexn) = self {
3462 return aexn.write(p);
3463 }
3464 p.write_struct_begin("GetTagIndex");
3465 match self {
3466 Self::Success(inner) => {
3467 p.write_field_begin(
3468 "Success",
3469 ::fbthrift::TType::Struct,
3470 0i16,
3471 );
3472 inner.write(p);
3473 p.write_field_end();
3474 }
3475 Self::ApplicationException(_aexn) => unreachable!(),
3476 }
3477 p.write_field_stop();
3478 p.write_struct_end();
3479 }
3480 }
3481
3482 impl<P> ::fbthrift::Deserialize<P> for GetTagIndexExn
3483 where
3484 P: ::fbthrift::ProtocolReader,
3485 {
3486 fn read(p: &mut P) -> ::anyhow::Result<Self> {
3487 static RETURNS: &[::fbthrift::Field] = &[
3488 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
3489 ];
3490 let _ = p.read_struct_begin(|_| ())?;
3491 let mut once = false;
3492 let mut alt = ::std::option::Option::None;
3493 loop {
3494 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
3495 match ((fty, fid as ::std::primitive::i32), once) {
3496 ((::fbthrift::TType::Stop, _), _) => {
3497 p.read_field_end()?;
3498 break;
3499 }
3500 ((::fbthrift::TType::Struct, 0i32), false) => {
3501 once = true;
3502 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
3503 }
3504 ((ty, _id), false) => p.skip(ty)?,
3505 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
3506 ::fbthrift::ApplicationException::new(
3507 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
3508 format!(
3509 "unwanted extra union {} field ty {:?} id {}",
3510 "GetTagIndexExn",
3511 badty,
3512 badid,
3513 ),
3514 )
3515 )),
3516 }
3517 p.read_field_end()?;
3518 }
3519 p.read_struct_end()?;
3520 alt.ok_or_else(||
3521 ::fbthrift::ApplicationException::new(
3522 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
3523 format!("Empty union {}", "GetTagIndexExn"),
3524 )
3525 .into(),
3526 )
3527 }
3528 }
3529
3530 #[derive(Clone, Debug)]
3531 pub enum ListTagIndexesExn {
3532 #[doc(hidden)]
3533 Success(crate::types::ListTagIndexesResp),
3534 ApplicationException(::fbthrift::ApplicationException),
3535 }
3536
3537 impl ::std::convert::From<crate::errors::meta_service::ListTagIndexesError> for ListTagIndexesExn {
3538 fn from(err: crate::errors::meta_service::ListTagIndexesError) -> Self {
3539 match err {
3540 crate::errors::meta_service::ListTagIndexesError::ApplicationException(aexn) => ListTagIndexesExn::ApplicationException(aexn),
3541 crate::errors::meta_service::ListTagIndexesError::ThriftError(err) => ListTagIndexesExn::ApplicationException(::fbthrift::ApplicationException {
3542 message: err.to_string(),
3543 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3544 }),
3545 }
3546 }
3547 }
3548
3549 impl ::std::convert::From<::fbthrift::ApplicationException> for ListTagIndexesExn {
3550 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3551 Self::ApplicationException(exn)
3552 }
3553 }
3554
3555 impl ::fbthrift::ExceptionInfo for ListTagIndexesExn {
3556 fn exn_name(&self) -> &'static str {
3557 match self {
3558 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3559 Self::ApplicationException(aexn) => aexn.exn_name(),
3560 }
3561 }
3562
3563 fn exn_value(&self) -> String {
3564 match self {
3565 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3566 Self::ApplicationException(aexn) => aexn.exn_value(),
3567 }
3568 }
3569
3570 fn exn_is_declared(&self) -> bool {
3571 match self {
3572 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3573 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3574 }
3575 }
3576 }
3577
3578 impl ::fbthrift::ResultInfo for ListTagIndexesExn {
3579 fn result_type(&self) -> ::fbthrift::ResultType {
3580 match self {
3581 Self::Success(_) => ::fbthrift::ResultType::Return,
3582 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3583 }
3584 }
3585 }
3586
3587 impl ::fbthrift::GetTType for ListTagIndexesExn {
3588 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3589 }
3590
3591 impl<P> ::fbthrift::Serialize<P> for ListTagIndexesExn
3592 where
3593 P: ::fbthrift::ProtocolWriter,
3594 {
3595 fn write(&self, p: &mut P) {
3596 if let Self::ApplicationException(aexn) = self {
3597 return aexn.write(p);
3598 }
3599 p.write_struct_begin("ListTagIndexes");
3600 match self {
3601 Self::Success(inner) => {
3602 p.write_field_begin(
3603 "Success",
3604 ::fbthrift::TType::Struct,
3605 0i16,
3606 );
3607 inner.write(p);
3608 p.write_field_end();
3609 }
3610 Self::ApplicationException(_aexn) => unreachable!(),
3611 }
3612 p.write_field_stop();
3613 p.write_struct_end();
3614 }
3615 }
3616
3617 impl<P> ::fbthrift::Deserialize<P> for ListTagIndexesExn
3618 where
3619 P: ::fbthrift::ProtocolReader,
3620 {
3621 fn read(p: &mut P) -> ::anyhow::Result<Self> {
3622 static RETURNS: &[::fbthrift::Field] = &[
3623 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
3624 ];
3625 let _ = p.read_struct_begin(|_| ())?;
3626 let mut once = false;
3627 let mut alt = ::std::option::Option::None;
3628 loop {
3629 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
3630 match ((fty, fid as ::std::primitive::i32), once) {
3631 ((::fbthrift::TType::Stop, _), _) => {
3632 p.read_field_end()?;
3633 break;
3634 }
3635 ((::fbthrift::TType::Struct, 0i32), false) => {
3636 once = true;
3637 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
3638 }
3639 ((ty, _id), false) => p.skip(ty)?,
3640 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
3641 ::fbthrift::ApplicationException::new(
3642 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
3643 format!(
3644 "unwanted extra union {} field ty {:?} id {}",
3645 "ListTagIndexesExn",
3646 badty,
3647 badid,
3648 ),
3649 )
3650 )),
3651 }
3652 p.read_field_end()?;
3653 }
3654 p.read_struct_end()?;
3655 alt.ok_or_else(||
3656 ::fbthrift::ApplicationException::new(
3657 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
3658 format!("Empty union {}", "ListTagIndexesExn"),
3659 )
3660 .into(),
3661 )
3662 }
3663 }
3664
3665 #[derive(Clone, Debug)]
3666 pub enum RebuildTagIndexExn {
3667 #[doc(hidden)]
3668 Success(crate::types::ExecResp),
3669 ApplicationException(::fbthrift::ApplicationException),
3670 }
3671
3672 impl ::std::convert::From<crate::errors::meta_service::RebuildTagIndexError> for RebuildTagIndexExn {
3673 fn from(err: crate::errors::meta_service::RebuildTagIndexError) -> Self {
3674 match err {
3675 crate::errors::meta_service::RebuildTagIndexError::ApplicationException(aexn) => RebuildTagIndexExn::ApplicationException(aexn),
3676 crate::errors::meta_service::RebuildTagIndexError::ThriftError(err) => RebuildTagIndexExn::ApplicationException(::fbthrift::ApplicationException {
3677 message: err.to_string(),
3678 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3679 }),
3680 }
3681 }
3682 }
3683
3684 impl ::std::convert::From<::fbthrift::ApplicationException> for RebuildTagIndexExn {
3685 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3686 Self::ApplicationException(exn)
3687 }
3688 }
3689
3690 impl ::fbthrift::ExceptionInfo for RebuildTagIndexExn {
3691 fn exn_name(&self) -> &'static str {
3692 match self {
3693 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3694 Self::ApplicationException(aexn) => aexn.exn_name(),
3695 }
3696 }
3697
3698 fn exn_value(&self) -> String {
3699 match self {
3700 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3701 Self::ApplicationException(aexn) => aexn.exn_value(),
3702 }
3703 }
3704
3705 fn exn_is_declared(&self) -> bool {
3706 match self {
3707 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3708 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3709 }
3710 }
3711 }
3712
3713 impl ::fbthrift::ResultInfo for RebuildTagIndexExn {
3714 fn result_type(&self) -> ::fbthrift::ResultType {
3715 match self {
3716 Self::Success(_) => ::fbthrift::ResultType::Return,
3717 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3718 }
3719 }
3720 }
3721
3722 impl ::fbthrift::GetTType for RebuildTagIndexExn {
3723 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3724 }
3725
3726 impl<P> ::fbthrift::Serialize<P> for RebuildTagIndexExn
3727 where
3728 P: ::fbthrift::ProtocolWriter,
3729 {
3730 fn write(&self, p: &mut P) {
3731 if let Self::ApplicationException(aexn) = self {
3732 return aexn.write(p);
3733 }
3734 p.write_struct_begin("RebuildTagIndex");
3735 match self {
3736 Self::Success(inner) => {
3737 p.write_field_begin(
3738 "Success",
3739 ::fbthrift::TType::Struct,
3740 0i16,
3741 );
3742 inner.write(p);
3743 p.write_field_end();
3744 }
3745 Self::ApplicationException(_aexn) => unreachable!(),
3746 }
3747 p.write_field_stop();
3748 p.write_struct_end();
3749 }
3750 }
3751
3752 impl<P> ::fbthrift::Deserialize<P> for RebuildTagIndexExn
3753 where
3754 P: ::fbthrift::ProtocolReader,
3755 {
3756 fn read(p: &mut P) -> ::anyhow::Result<Self> {
3757 static RETURNS: &[::fbthrift::Field] = &[
3758 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
3759 ];
3760 let _ = p.read_struct_begin(|_| ())?;
3761 let mut once = false;
3762 let mut alt = ::std::option::Option::None;
3763 loop {
3764 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
3765 match ((fty, fid as ::std::primitive::i32), once) {
3766 ((::fbthrift::TType::Stop, _), _) => {
3767 p.read_field_end()?;
3768 break;
3769 }
3770 ((::fbthrift::TType::Struct, 0i32), false) => {
3771 once = true;
3772 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
3773 }
3774 ((ty, _id), false) => p.skip(ty)?,
3775 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
3776 ::fbthrift::ApplicationException::new(
3777 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
3778 format!(
3779 "unwanted extra union {} field ty {:?} id {}",
3780 "RebuildTagIndexExn",
3781 badty,
3782 badid,
3783 ),
3784 )
3785 )),
3786 }
3787 p.read_field_end()?;
3788 }
3789 p.read_struct_end()?;
3790 alt.ok_or_else(||
3791 ::fbthrift::ApplicationException::new(
3792 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
3793 format!("Empty union {}", "RebuildTagIndexExn"),
3794 )
3795 .into(),
3796 )
3797 }
3798 }
3799
3800 #[derive(Clone, Debug)]
3801 pub enum ListTagIndexStatusExn {
3802 #[doc(hidden)]
3803 Success(crate::types::ListIndexStatusResp),
3804 ApplicationException(::fbthrift::ApplicationException),
3805 }
3806
3807 impl ::std::convert::From<crate::errors::meta_service::ListTagIndexStatusError> for ListTagIndexStatusExn {
3808 fn from(err: crate::errors::meta_service::ListTagIndexStatusError) -> Self {
3809 match err {
3810 crate::errors::meta_service::ListTagIndexStatusError::ApplicationException(aexn) => ListTagIndexStatusExn::ApplicationException(aexn),
3811 crate::errors::meta_service::ListTagIndexStatusError::ThriftError(err) => ListTagIndexStatusExn::ApplicationException(::fbthrift::ApplicationException {
3812 message: err.to_string(),
3813 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3814 }),
3815 }
3816 }
3817 }
3818
3819 impl ::std::convert::From<::fbthrift::ApplicationException> for ListTagIndexStatusExn {
3820 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3821 Self::ApplicationException(exn)
3822 }
3823 }
3824
3825 impl ::fbthrift::ExceptionInfo for ListTagIndexStatusExn {
3826 fn exn_name(&self) -> &'static str {
3827 match self {
3828 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3829 Self::ApplicationException(aexn) => aexn.exn_name(),
3830 }
3831 }
3832
3833 fn exn_value(&self) -> String {
3834 match self {
3835 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3836 Self::ApplicationException(aexn) => aexn.exn_value(),
3837 }
3838 }
3839
3840 fn exn_is_declared(&self) -> bool {
3841 match self {
3842 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3843 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3844 }
3845 }
3846 }
3847
3848 impl ::fbthrift::ResultInfo for ListTagIndexStatusExn {
3849 fn result_type(&self) -> ::fbthrift::ResultType {
3850 match self {
3851 Self::Success(_) => ::fbthrift::ResultType::Return,
3852 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3853 }
3854 }
3855 }
3856
3857 impl ::fbthrift::GetTType for ListTagIndexStatusExn {
3858 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3859 }
3860
3861 impl<P> ::fbthrift::Serialize<P> for ListTagIndexStatusExn
3862 where
3863 P: ::fbthrift::ProtocolWriter,
3864 {
3865 fn write(&self, p: &mut P) {
3866 if let Self::ApplicationException(aexn) = self {
3867 return aexn.write(p);
3868 }
3869 p.write_struct_begin("ListTagIndexStatus");
3870 match self {
3871 Self::Success(inner) => {
3872 p.write_field_begin(
3873 "Success",
3874 ::fbthrift::TType::Struct,
3875 0i16,
3876 );
3877 inner.write(p);
3878 p.write_field_end();
3879 }
3880 Self::ApplicationException(_aexn) => unreachable!(),
3881 }
3882 p.write_field_stop();
3883 p.write_struct_end();
3884 }
3885 }
3886
3887 impl<P> ::fbthrift::Deserialize<P> for ListTagIndexStatusExn
3888 where
3889 P: ::fbthrift::ProtocolReader,
3890 {
3891 fn read(p: &mut P) -> ::anyhow::Result<Self> {
3892 static RETURNS: &[::fbthrift::Field] = &[
3893 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
3894 ];
3895 let _ = p.read_struct_begin(|_| ())?;
3896 let mut once = false;
3897 let mut alt = ::std::option::Option::None;
3898 loop {
3899 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
3900 match ((fty, fid as ::std::primitive::i32), once) {
3901 ((::fbthrift::TType::Stop, _), _) => {
3902 p.read_field_end()?;
3903 break;
3904 }
3905 ((::fbthrift::TType::Struct, 0i32), false) => {
3906 once = true;
3907 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
3908 }
3909 ((ty, _id), false) => p.skip(ty)?,
3910 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
3911 ::fbthrift::ApplicationException::new(
3912 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
3913 format!(
3914 "unwanted extra union {} field ty {:?} id {}",
3915 "ListTagIndexStatusExn",
3916 badty,
3917 badid,
3918 ),
3919 )
3920 )),
3921 }
3922 p.read_field_end()?;
3923 }
3924 p.read_struct_end()?;
3925 alt.ok_or_else(||
3926 ::fbthrift::ApplicationException::new(
3927 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
3928 format!("Empty union {}", "ListTagIndexStatusExn"),
3929 )
3930 .into(),
3931 )
3932 }
3933 }
3934
3935 #[derive(Clone, Debug)]
3936 pub enum CreateEdgeIndexExn {
3937 #[doc(hidden)]
3938 Success(crate::types::ExecResp),
3939 ApplicationException(::fbthrift::ApplicationException),
3940 }
3941
3942 impl ::std::convert::From<crate::errors::meta_service::CreateEdgeIndexError> for CreateEdgeIndexExn {
3943 fn from(err: crate::errors::meta_service::CreateEdgeIndexError) -> Self {
3944 match err {
3945 crate::errors::meta_service::CreateEdgeIndexError::ApplicationException(aexn) => CreateEdgeIndexExn::ApplicationException(aexn),
3946 crate::errors::meta_service::CreateEdgeIndexError::ThriftError(err) => CreateEdgeIndexExn::ApplicationException(::fbthrift::ApplicationException {
3947 message: err.to_string(),
3948 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
3949 }),
3950 }
3951 }
3952 }
3953
3954 impl ::std::convert::From<::fbthrift::ApplicationException> for CreateEdgeIndexExn {
3955 fn from(exn: ::fbthrift::ApplicationException) -> Self {
3956 Self::ApplicationException(exn)
3957 }
3958 }
3959
3960 impl ::fbthrift::ExceptionInfo for CreateEdgeIndexExn {
3961 fn exn_name(&self) -> &'static str {
3962 match self {
3963 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
3964 Self::ApplicationException(aexn) => aexn.exn_name(),
3965 }
3966 }
3967
3968 fn exn_value(&self) -> String {
3969 match self {
3970 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
3971 Self::ApplicationException(aexn) => aexn.exn_value(),
3972 }
3973 }
3974
3975 fn exn_is_declared(&self) -> bool {
3976 match self {
3977 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
3978 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
3979 }
3980 }
3981 }
3982
3983 impl ::fbthrift::ResultInfo for CreateEdgeIndexExn {
3984 fn result_type(&self) -> ::fbthrift::ResultType {
3985 match self {
3986 Self::Success(_) => ::fbthrift::ResultType::Return,
3987 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
3988 }
3989 }
3990 }
3991
3992 impl ::fbthrift::GetTType for CreateEdgeIndexExn {
3993 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
3994 }
3995
3996 impl<P> ::fbthrift::Serialize<P> for CreateEdgeIndexExn
3997 where
3998 P: ::fbthrift::ProtocolWriter,
3999 {
4000 fn write(&self, p: &mut P) {
4001 if let Self::ApplicationException(aexn) = self {
4002 return aexn.write(p);
4003 }
4004 p.write_struct_begin("CreateEdgeIndex");
4005 match self {
4006 Self::Success(inner) => {
4007 p.write_field_begin(
4008 "Success",
4009 ::fbthrift::TType::Struct,
4010 0i16,
4011 );
4012 inner.write(p);
4013 p.write_field_end();
4014 }
4015 Self::ApplicationException(_aexn) => unreachable!(),
4016 }
4017 p.write_field_stop();
4018 p.write_struct_end();
4019 }
4020 }
4021
4022 impl<P> ::fbthrift::Deserialize<P> for CreateEdgeIndexExn
4023 where
4024 P: ::fbthrift::ProtocolReader,
4025 {
4026 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4027 static RETURNS: &[::fbthrift::Field] = &[
4028 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4029 ];
4030 let _ = p.read_struct_begin(|_| ())?;
4031 let mut once = false;
4032 let mut alt = ::std::option::Option::None;
4033 loop {
4034 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4035 match ((fty, fid as ::std::primitive::i32), once) {
4036 ((::fbthrift::TType::Stop, _), _) => {
4037 p.read_field_end()?;
4038 break;
4039 }
4040 ((::fbthrift::TType::Struct, 0i32), false) => {
4041 once = true;
4042 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4043 }
4044 ((ty, _id), false) => p.skip(ty)?,
4045 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4046 ::fbthrift::ApplicationException::new(
4047 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4048 format!(
4049 "unwanted extra union {} field ty {:?} id {}",
4050 "CreateEdgeIndexExn",
4051 badty,
4052 badid,
4053 ),
4054 )
4055 )),
4056 }
4057 p.read_field_end()?;
4058 }
4059 p.read_struct_end()?;
4060 alt.ok_or_else(||
4061 ::fbthrift::ApplicationException::new(
4062 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
4063 format!("Empty union {}", "CreateEdgeIndexExn"),
4064 )
4065 .into(),
4066 )
4067 }
4068 }
4069
4070 #[derive(Clone, Debug)]
4071 pub enum DropEdgeIndexExn {
4072 #[doc(hidden)]
4073 Success(crate::types::ExecResp),
4074 ApplicationException(::fbthrift::ApplicationException),
4075 }
4076
4077 impl ::std::convert::From<crate::errors::meta_service::DropEdgeIndexError> for DropEdgeIndexExn {
4078 fn from(err: crate::errors::meta_service::DropEdgeIndexError) -> Self {
4079 match err {
4080 crate::errors::meta_service::DropEdgeIndexError::ApplicationException(aexn) => DropEdgeIndexExn::ApplicationException(aexn),
4081 crate::errors::meta_service::DropEdgeIndexError::ThriftError(err) => DropEdgeIndexExn::ApplicationException(::fbthrift::ApplicationException {
4082 message: err.to_string(),
4083 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
4084 }),
4085 }
4086 }
4087 }
4088
4089 impl ::std::convert::From<::fbthrift::ApplicationException> for DropEdgeIndexExn {
4090 fn from(exn: ::fbthrift::ApplicationException) -> Self {
4091 Self::ApplicationException(exn)
4092 }
4093 }
4094
4095 impl ::fbthrift::ExceptionInfo for DropEdgeIndexExn {
4096 fn exn_name(&self) -> &'static str {
4097 match self {
4098 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
4099 Self::ApplicationException(aexn) => aexn.exn_name(),
4100 }
4101 }
4102
4103 fn exn_value(&self) -> String {
4104 match self {
4105 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
4106 Self::ApplicationException(aexn) => aexn.exn_value(),
4107 }
4108 }
4109
4110 fn exn_is_declared(&self) -> bool {
4111 match self {
4112 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
4113 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
4114 }
4115 }
4116 }
4117
4118 impl ::fbthrift::ResultInfo for DropEdgeIndexExn {
4119 fn result_type(&self) -> ::fbthrift::ResultType {
4120 match self {
4121 Self::Success(_) => ::fbthrift::ResultType::Return,
4122 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
4123 }
4124 }
4125 }
4126
4127 impl ::fbthrift::GetTType for DropEdgeIndexExn {
4128 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
4129 }
4130
4131 impl<P> ::fbthrift::Serialize<P> for DropEdgeIndexExn
4132 where
4133 P: ::fbthrift::ProtocolWriter,
4134 {
4135 fn write(&self, p: &mut P) {
4136 if let Self::ApplicationException(aexn) = self {
4137 return aexn.write(p);
4138 }
4139 p.write_struct_begin("DropEdgeIndex");
4140 match self {
4141 Self::Success(inner) => {
4142 p.write_field_begin(
4143 "Success",
4144 ::fbthrift::TType::Struct,
4145 0i16,
4146 );
4147 inner.write(p);
4148 p.write_field_end();
4149 }
4150 Self::ApplicationException(_aexn) => unreachable!(),
4151 }
4152 p.write_field_stop();
4153 p.write_struct_end();
4154 }
4155 }
4156
4157 impl<P> ::fbthrift::Deserialize<P> for DropEdgeIndexExn
4158 where
4159 P: ::fbthrift::ProtocolReader,
4160 {
4161 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4162 static RETURNS: &[::fbthrift::Field] = &[
4163 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4164 ];
4165 let _ = p.read_struct_begin(|_| ())?;
4166 let mut once = false;
4167 let mut alt = ::std::option::Option::None;
4168 loop {
4169 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4170 match ((fty, fid as ::std::primitive::i32), once) {
4171 ((::fbthrift::TType::Stop, _), _) => {
4172 p.read_field_end()?;
4173 break;
4174 }
4175 ((::fbthrift::TType::Struct, 0i32), false) => {
4176 once = true;
4177 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4178 }
4179 ((ty, _id), false) => p.skip(ty)?,
4180 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4181 ::fbthrift::ApplicationException::new(
4182 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4183 format!(
4184 "unwanted extra union {} field ty {:?} id {}",
4185 "DropEdgeIndexExn",
4186 badty,
4187 badid,
4188 ),
4189 )
4190 )),
4191 }
4192 p.read_field_end()?;
4193 }
4194 p.read_struct_end()?;
4195 alt.ok_or_else(||
4196 ::fbthrift::ApplicationException::new(
4197 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
4198 format!("Empty union {}", "DropEdgeIndexExn"),
4199 )
4200 .into(),
4201 )
4202 }
4203 }
4204
4205 #[derive(Clone, Debug)]
4206 pub enum GetEdgeIndexExn {
4207 #[doc(hidden)]
4208 Success(crate::types::GetEdgeIndexResp),
4209 ApplicationException(::fbthrift::ApplicationException),
4210 }
4211
4212 impl ::std::convert::From<crate::errors::meta_service::GetEdgeIndexError> for GetEdgeIndexExn {
4213 fn from(err: crate::errors::meta_service::GetEdgeIndexError) -> Self {
4214 match err {
4215 crate::errors::meta_service::GetEdgeIndexError::ApplicationException(aexn) => GetEdgeIndexExn::ApplicationException(aexn),
4216 crate::errors::meta_service::GetEdgeIndexError::ThriftError(err) => GetEdgeIndexExn::ApplicationException(::fbthrift::ApplicationException {
4217 message: err.to_string(),
4218 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
4219 }),
4220 }
4221 }
4222 }
4223
4224 impl ::std::convert::From<::fbthrift::ApplicationException> for GetEdgeIndexExn {
4225 fn from(exn: ::fbthrift::ApplicationException) -> Self {
4226 Self::ApplicationException(exn)
4227 }
4228 }
4229
4230 impl ::fbthrift::ExceptionInfo for GetEdgeIndexExn {
4231 fn exn_name(&self) -> &'static str {
4232 match self {
4233 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
4234 Self::ApplicationException(aexn) => aexn.exn_name(),
4235 }
4236 }
4237
4238 fn exn_value(&self) -> String {
4239 match self {
4240 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
4241 Self::ApplicationException(aexn) => aexn.exn_value(),
4242 }
4243 }
4244
4245 fn exn_is_declared(&self) -> bool {
4246 match self {
4247 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
4248 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
4249 }
4250 }
4251 }
4252
4253 impl ::fbthrift::ResultInfo for GetEdgeIndexExn {
4254 fn result_type(&self) -> ::fbthrift::ResultType {
4255 match self {
4256 Self::Success(_) => ::fbthrift::ResultType::Return,
4257 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
4258 }
4259 }
4260 }
4261
4262 impl ::fbthrift::GetTType for GetEdgeIndexExn {
4263 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
4264 }
4265
4266 impl<P> ::fbthrift::Serialize<P> for GetEdgeIndexExn
4267 where
4268 P: ::fbthrift::ProtocolWriter,
4269 {
4270 fn write(&self, p: &mut P) {
4271 if let Self::ApplicationException(aexn) = self {
4272 return aexn.write(p);
4273 }
4274 p.write_struct_begin("GetEdgeIndex");
4275 match self {
4276 Self::Success(inner) => {
4277 p.write_field_begin(
4278 "Success",
4279 ::fbthrift::TType::Struct,
4280 0i16,
4281 );
4282 inner.write(p);
4283 p.write_field_end();
4284 }
4285 Self::ApplicationException(_aexn) => unreachable!(),
4286 }
4287 p.write_field_stop();
4288 p.write_struct_end();
4289 }
4290 }
4291
4292 impl<P> ::fbthrift::Deserialize<P> for GetEdgeIndexExn
4293 where
4294 P: ::fbthrift::ProtocolReader,
4295 {
4296 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4297 static RETURNS: &[::fbthrift::Field] = &[
4298 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4299 ];
4300 let _ = p.read_struct_begin(|_| ())?;
4301 let mut once = false;
4302 let mut alt = ::std::option::Option::None;
4303 loop {
4304 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4305 match ((fty, fid as ::std::primitive::i32), once) {
4306 ((::fbthrift::TType::Stop, _), _) => {
4307 p.read_field_end()?;
4308 break;
4309 }
4310 ((::fbthrift::TType::Struct, 0i32), false) => {
4311 once = true;
4312 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4313 }
4314 ((ty, _id), false) => p.skip(ty)?,
4315 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4316 ::fbthrift::ApplicationException::new(
4317 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4318 format!(
4319 "unwanted extra union {} field ty {:?} id {}",
4320 "GetEdgeIndexExn",
4321 badty,
4322 badid,
4323 ),
4324 )
4325 )),
4326 }
4327 p.read_field_end()?;
4328 }
4329 p.read_struct_end()?;
4330 alt.ok_or_else(||
4331 ::fbthrift::ApplicationException::new(
4332 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
4333 format!("Empty union {}", "GetEdgeIndexExn"),
4334 )
4335 .into(),
4336 )
4337 }
4338 }
4339
4340 #[derive(Clone, Debug)]
4341 pub enum ListEdgeIndexesExn {
4342 #[doc(hidden)]
4343 Success(crate::types::ListEdgeIndexesResp),
4344 ApplicationException(::fbthrift::ApplicationException),
4345 }
4346
4347 impl ::std::convert::From<crate::errors::meta_service::ListEdgeIndexesError> for ListEdgeIndexesExn {
4348 fn from(err: crate::errors::meta_service::ListEdgeIndexesError) -> Self {
4349 match err {
4350 crate::errors::meta_service::ListEdgeIndexesError::ApplicationException(aexn) => ListEdgeIndexesExn::ApplicationException(aexn),
4351 crate::errors::meta_service::ListEdgeIndexesError::ThriftError(err) => ListEdgeIndexesExn::ApplicationException(::fbthrift::ApplicationException {
4352 message: err.to_string(),
4353 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
4354 }),
4355 }
4356 }
4357 }
4358
4359 impl ::std::convert::From<::fbthrift::ApplicationException> for ListEdgeIndexesExn {
4360 fn from(exn: ::fbthrift::ApplicationException) -> Self {
4361 Self::ApplicationException(exn)
4362 }
4363 }
4364
4365 impl ::fbthrift::ExceptionInfo for ListEdgeIndexesExn {
4366 fn exn_name(&self) -> &'static str {
4367 match self {
4368 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
4369 Self::ApplicationException(aexn) => aexn.exn_name(),
4370 }
4371 }
4372
4373 fn exn_value(&self) -> String {
4374 match self {
4375 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
4376 Self::ApplicationException(aexn) => aexn.exn_value(),
4377 }
4378 }
4379
4380 fn exn_is_declared(&self) -> bool {
4381 match self {
4382 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
4383 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
4384 }
4385 }
4386 }
4387
4388 impl ::fbthrift::ResultInfo for ListEdgeIndexesExn {
4389 fn result_type(&self) -> ::fbthrift::ResultType {
4390 match self {
4391 Self::Success(_) => ::fbthrift::ResultType::Return,
4392 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
4393 }
4394 }
4395 }
4396
4397 impl ::fbthrift::GetTType for ListEdgeIndexesExn {
4398 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
4399 }
4400
4401 impl<P> ::fbthrift::Serialize<P> for ListEdgeIndexesExn
4402 where
4403 P: ::fbthrift::ProtocolWriter,
4404 {
4405 fn write(&self, p: &mut P) {
4406 if let Self::ApplicationException(aexn) = self {
4407 return aexn.write(p);
4408 }
4409 p.write_struct_begin("ListEdgeIndexes");
4410 match self {
4411 Self::Success(inner) => {
4412 p.write_field_begin(
4413 "Success",
4414 ::fbthrift::TType::Struct,
4415 0i16,
4416 );
4417 inner.write(p);
4418 p.write_field_end();
4419 }
4420 Self::ApplicationException(_aexn) => unreachable!(),
4421 }
4422 p.write_field_stop();
4423 p.write_struct_end();
4424 }
4425 }
4426
4427 impl<P> ::fbthrift::Deserialize<P> for ListEdgeIndexesExn
4428 where
4429 P: ::fbthrift::ProtocolReader,
4430 {
4431 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4432 static RETURNS: &[::fbthrift::Field] = &[
4433 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4434 ];
4435 let _ = p.read_struct_begin(|_| ())?;
4436 let mut once = false;
4437 let mut alt = ::std::option::Option::None;
4438 loop {
4439 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4440 match ((fty, fid as ::std::primitive::i32), once) {
4441 ((::fbthrift::TType::Stop, _), _) => {
4442 p.read_field_end()?;
4443 break;
4444 }
4445 ((::fbthrift::TType::Struct, 0i32), false) => {
4446 once = true;
4447 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4448 }
4449 ((ty, _id), false) => p.skip(ty)?,
4450 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4451 ::fbthrift::ApplicationException::new(
4452 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4453 format!(
4454 "unwanted extra union {} field ty {:?} id {}",
4455 "ListEdgeIndexesExn",
4456 badty,
4457 badid,
4458 ),
4459 )
4460 )),
4461 }
4462 p.read_field_end()?;
4463 }
4464 p.read_struct_end()?;
4465 alt.ok_or_else(||
4466 ::fbthrift::ApplicationException::new(
4467 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
4468 format!("Empty union {}", "ListEdgeIndexesExn"),
4469 )
4470 .into(),
4471 )
4472 }
4473 }
4474
4475 #[derive(Clone, Debug)]
4476 pub enum RebuildEdgeIndexExn {
4477 #[doc(hidden)]
4478 Success(crate::types::ExecResp),
4479 ApplicationException(::fbthrift::ApplicationException),
4480 }
4481
4482 impl ::std::convert::From<crate::errors::meta_service::RebuildEdgeIndexError> for RebuildEdgeIndexExn {
4483 fn from(err: crate::errors::meta_service::RebuildEdgeIndexError) -> Self {
4484 match err {
4485 crate::errors::meta_service::RebuildEdgeIndexError::ApplicationException(aexn) => RebuildEdgeIndexExn::ApplicationException(aexn),
4486 crate::errors::meta_service::RebuildEdgeIndexError::ThriftError(err) => RebuildEdgeIndexExn::ApplicationException(::fbthrift::ApplicationException {
4487 message: err.to_string(),
4488 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
4489 }),
4490 }
4491 }
4492 }
4493
4494 impl ::std::convert::From<::fbthrift::ApplicationException> for RebuildEdgeIndexExn {
4495 fn from(exn: ::fbthrift::ApplicationException) -> Self {
4496 Self::ApplicationException(exn)
4497 }
4498 }
4499
4500 impl ::fbthrift::ExceptionInfo for RebuildEdgeIndexExn {
4501 fn exn_name(&self) -> &'static str {
4502 match self {
4503 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
4504 Self::ApplicationException(aexn) => aexn.exn_name(),
4505 }
4506 }
4507
4508 fn exn_value(&self) -> String {
4509 match self {
4510 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
4511 Self::ApplicationException(aexn) => aexn.exn_value(),
4512 }
4513 }
4514
4515 fn exn_is_declared(&self) -> bool {
4516 match self {
4517 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
4518 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
4519 }
4520 }
4521 }
4522
4523 impl ::fbthrift::ResultInfo for RebuildEdgeIndexExn {
4524 fn result_type(&self) -> ::fbthrift::ResultType {
4525 match self {
4526 Self::Success(_) => ::fbthrift::ResultType::Return,
4527 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
4528 }
4529 }
4530 }
4531
4532 impl ::fbthrift::GetTType for RebuildEdgeIndexExn {
4533 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
4534 }
4535
4536 impl<P> ::fbthrift::Serialize<P> for RebuildEdgeIndexExn
4537 where
4538 P: ::fbthrift::ProtocolWriter,
4539 {
4540 fn write(&self, p: &mut P) {
4541 if let Self::ApplicationException(aexn) = self {
4542 return aexn.write(p);
4543 }
4544 p.write_struct_begin("RebuildEdgeIndex");
4545 match self {
4546 Self::Success(inner) => {
4547 p.write_field_begin(
4548 "Success",
4549 ::fbthrift::TType::Struct,
4550 0i16,
4551 );
4552 inner.write(p);
4553 p.write_field_end();
4554 }
4555 Self::ApplicationException(_aexn) => unreachable!(),
4556 }
4557 p.write_field_stop();
4558 p.write_struct_end();
4559 }
4560 }
4561
4562 impl<P> ::fbthrift::Deserialize<P> for RebuildEdgeIndexExn
4563 where
4564 P: ::fbthrift::ProtocolReader,
4565 {
4566 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4567 static RETURNS: &[::fbthrift::Field] = &[
4568 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4569 ];
4570 let _ = p.read_struct_begin(|_| ())?;
4571 let mut once = false;
4572 let mut alt = ::std::option::Option::None;
4573 loop {
4574 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4575 match ((fty, fid as ::std::primitive::i32), once) {
4576 ((::fbthrift::TType::Stop, _), _) => {
4577 p.read_field_end()?;
4578 break;
4579 }
4580 ((::fbthrift::TType::Struct, 0i32), false) => {
4581 once = true;
4582 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4583 }
4584 ((ty, _id), false) => p.skip(ty)?,
4585 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4586 ::fbthrift::ApplicationException::new(
4587 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4588 format!(
4589 "unwanted extra union {} field ty {:?} id {}",
4590 "RebuildEdgeIndexExn",
4591 badty,
4592 badid,
4593 ),
4594 )
4595 )),
4596 }
4597 p.read_field_end()?;
4598 }
4599 p.read_struct_end()?;
4600 alt.ok_or_else(||
4601 ::fbthrift::ApplicationException::new(
4602 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
4603 format!("Empty union {}", "RebuildEdgeIndexExn"),
4604 )
4605 .into(),
4606 )
4607 }
4608 }
4609
4610 #[derive(Clone, Debug)]
4611 pub enum ListEdgeIndexStatusExn {
4612 #[doc(hidden)]
4613 Success(crate::types::ListIndexStatusResp),
4614 ApplicationException(::fbthrift::ApplicationException),
4615 }
4616
4617 impl ::std::convert::From<crate::errors::meta_service::ListEdgeIndexStatusError> for ListEdgeIndexStatusExn {
4618 fn from(err: crate::errors::meta_service::ListEdgeIndexStatusError) -> Self {
4619 match err {
4620 crate::errors::meta_service::ListEdgeIndexStatusError::ApplicationException(aexn) => ListEdgeIndexStatusExn::ApplicationException(aexn),
4621 crate::errors::meta_service::ListEdgeIndexStatusError::ThriftError(err) => ListEdgeIndexStatusExn::ApplicationException(::fbthrift::ApplicationException {
4622 message: err.to_string(),
4623 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
4624 }),
4625 }
4626 }
4627 }
4628
4629 impl ::std::convert::From<::fbthrift::ApplicationException> for ListEdgeIndexStatusExn {
4630 fn from(exn: ::fbthrift::ApplicationException) -> Self {
4631 Self::ApplicationException(exn)
4632 }
4633 }
4634
4635 impl ::fbthrift::ExceptionInfo for ListEdgeIndexStatusExn {
4636 fn exn_name(&self) -> &'static str {
4637 match self {
4638 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
4639 Self::ApplicationException(aexn) => aexn.exn_name(),
4640 }
4641 }
4642
4643 fn exn_value(&self) -> String {
4644 match self {
4645 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
4646 Self::ApplicationException(aexn) => aexn.exn_value(),
4647 }
4648 }
4649
4650 fn exn_is_declared(&self) -> bool {
4651 match self {
4652 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
4653 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
4654 }
4655 }
4656 }
4657
4658 impl ::fbthrift::ResultInfo for ListEdgeIndexStatusExn {
4659 fn result_type(&self) -> ::fbthrift::ResultType {
4660 match self {
4661 Self::Success(_) => ::fbthrift::ResultType::Return,
4662 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
4663 }
4664 }
4665 }
4666
4667 impl ::fbthrift::GetTType for ListEdgeIndexStatusExn {
4668 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
4669 }
4670
4671 impl<P> ::fbthrift::Serialize<P> for ListEdgeIndexStatusExn
4672 where
4673 P: ::fbthrift::ProtocolWriter,
4674 {
4675 fn write(&self, p: &mut P) {
4676 if let Self::ApplicationException(aexn) = self {
4677 return aexn.write(p);
4678 }
4679 p.write_struct_begin("ListEdgeIndexStatus");
4680 match self {
4681 Self::Success(inner) => {
4682 p.write_field_begin(
4683 "Success",
4684 ::fbthrift::TType::Struct,
4685 0i16,
4686 );
4687 inner.write(p);
4688 p.write_field_end();
4689 }
4690 Self::ApplicationException(_aexn) => unreachable!(),
4691 }
4692 p.write_field_stop();
4693 p.write_struct_end();
4694 }
4695 }
4696
4697 impl<P> ::fbthrift::Deserialize<P> for ListEdgeIndexStatusExn
4698 where
4699 P: ::fbthrift::ProtocolReader,
4700 {
4701 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4702 static RETURNS: &[::fbthrift::Field] = &[
4703 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4704 ];
4705 let _ = p.read_struct_begin(|_| ())?;
4706 let mut once = false;
4707 let mut alt = ::std::option::Option::None;
4708 loop {
4709 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4710 match ((fty, fid as ::std::primitive::i32), once) {
4711 ((::fbthrift::TType::Stop, _), _) => {
4712 p.read_field_end()?;
4713 break;
4714 }
4715 ((::fbthrift::TType::Struct, 0i32), false) => {
4716 once = true;
4717 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4718 }
4719 ((ty, _id), false) => p.skip(ty)?,
4720 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4721 ::fbthrift::ApplicationException::new(
4722 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4723 format!(
4724 "unwanted extra union {} field ty {:?} id {}",
4725 "ListEdgeIndexStatusExn",
4726 badty,
4727 badid,
4728 ),
4729 )
4730 )),
4731 }
4732 p.read_field_end()?;
4733 }
4734 p.read_struct_end()?;
4735 alt.ok_or_else(||
4736 ::fbthrift::ApplicationException::new(
4737 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
4738 format!("Empty union {}", "ListEdgeIndexStatusExn"),
4739 )
4740 .into(),
4741 )
4742 }
4743 }
4744
4745 #[derive(Clone, Debug)]
4746 pub enum CreateUserExn {
4747 #[doc(hidden)]
4748 Success(crate::types::ExecResp),
4749 ApplicationException(::fbthrift::ApplicationException),
4750 }
4751
4752 impl ::std::convert::From<crate::errors::meta_service::CreateUserError> for CreateUserExn {
4753 fn from(err: crate::errors::meta_service::CreateUserError) -> Self {
4754 match err {
4755 crate::errors::meta_service::CreateUserError::ApplicationException(aexn) => CreateUserExn::ApplicationException(aexn),
4756 crate::errors::meta_service::CreateUserError::ThriftError(err) => CreateUserExn::ApplicationException(::fbthrift::ApplicationException {
4757 message: err.to_string(),
4758 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
4759 }),
4760 }
4761 }
4762 }
4763
4764 impl ::std::convert::From<::fbthrift::ApplicationException> for CreateUserExn {
4765 fn from(exn: ::fbthrift::ApplicationException) -> Self {
4766 Self::ApplicationException(exn)
4767 }
4768 }
4769
4770 impl ::fbthrift::ExceptionInfo for CreateUserExn {
4771 fn exn_name(&self) -> &'static str {
4772 match self {
4773 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
4774 Self::ApplicationException(aexn) => aexn.exn_name(),
4775 }
4776 }
4777
4778 fn exn_value(&self) -> String {
4779 match self {
4780 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
4781 Self::ApplicationException(aexn) => aexn.exn_value(),
4782 }
4783 }
4784
4785 fn exn_is_declared(&self) -> bool {
4786 match self {
4787 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
4788 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
4789 }
4790 }
4791 }
4792
4793 impl ::fbthrift::ResultInfo for CreateUserExn {
4794 fn result_type(&self) -> ::fbthrift::ResultType {
4795 match self {
4796 Self::Success(_) => ::fbthrift::ResultType::Return,
4797 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
4798 }
4799 }
4800 }
4801
4802 impl ::fbthrift::GetTType for CreateUserExn {
4803 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
4804 }
4805
4806 impl<P> ::fbthrift::Serialize<P> for CreateUserExn
4807 where
4808 P: ::fbthrift::ProtocolWriter,
4809 {
4810 fn write(&self, p: &mut P) {
4811 if let Self::ApplicationException(aexn) = self {
4812 return aexn.write(p);
4813 }
4814 p.write_struct_begin("CreateUser");
4815 match self {
4816 Self::Success(inner) => {
4817 p.write_field_begin(
4818 "Success",
4819 ::fbthrift::TType::Struct,
4820 0i16,
4821 );
4822 inner.write(p);
4823 p.write_field_end();
4824 }
4825 Self::ApplicationException(_aexn) => unreachable!(),
4826 }
4827 p.write_field_stop();
4828 p.write_struct_end();
4829 }
4830 }
4831
4832 impl<P> ::fbthrift::Deserialize<P> for CreateUserExn
4833 where
4834 P: ::fbthrift::ProtocolReader,
4835 {
4836 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4837 static RETURNS: &[::fbthrift::Field] = &[
4838 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4839 ];
4840 let _ = p.read_struct_begin(|_| ())?;
4841 let mut once = false;
4842 let mut alt = ::std::option::Option::None;
4843 loop {
4844 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4845 match ((fty, fid as ::std::primitive::i32), once) {
4846 ((::fbthrift::TType::Stop, _), _) => {
4847 p.read_field_end()?;
4848 break;
4849 }
4850 ((::fbthrift::TType::Struct, 0i32), false) => {
4851 once = true;
4852 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4853 }
4854 ((ty, _id), false) => p.skip(ty)?,
4855 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4856 ::fbthrift::ApplicationException::new(
4857 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4858 format!(
4859 "unwanted extra union {} field ty {:?} id {}",
4860 "CreateUserExn",
4861 badty,
4862 badid,
4863 ),
4864 )
4865 )),
4866 }
4867 p.read_field_end()?;
4868 }
4869 p.read_struct_end()?;
4870 alt.ok_or_else(||
4871 ::fbthrift::ApplicationException::new(
4872 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
4873 format!("Empty union {}", "CreateUserExn"),
4874 )
4875 .into(),
4876 )
4877 }
4878 }
4879
4880 #[derive(Clone, Debug)]
4881 pub enum DropUserExn {
4882 #[doc(hidden)]
4883 Success(crate::types::ExecResp),
4884 ApplicationException(::fbthrift::ApplicationException),
4885 }
4886
4887 impl ::std::convert::From<crate::errors::meta_service::DropUserError> for DropUserExn {
4888 fn from(err: crate::errors::meta_service::DropUserError) -> Self {
4889 match err {
4890 crate::errors::meta_service::DropUserError::ApplicationException(aexn) => DropUserExn::ApplicationException(aexn),
4891 crate::errors::meta_service::DropUserError::ThriftError(err) => DropUserExn::ApplicationException(::fbthrift::ApplicationException {
4892 message: err.to_string(),
4893 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
4894 }),
4895 }
4896 }
4897 }
4898
4899 impl ::std::convert::From<::fbthrift::ApplicationException> for DropUserExn {
4900 fn from(exn: ::fbthrift::ApplicationException) -> Self {
4901 Self::ApplicationException(exn)
4902 }
4903 }
4904
4905 impl ::fbthrift::ExceptionInfo for DropUserExn {
4906 fn exn_name(&self) -> &'static str {
4907 match self {
4908 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
4909 Self::ApplicationException(aexn) => aexn.exn_name(),
4910 }
4911 }
4912
4913 fn exn_value(&self) -> String {
4914 match self {
4915 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
4916 Self::ApplicationException(aexn) => aexn.exn_value(),
4917 }
4918 }
4919
4920 fn exn_is_declared(&self) -> bool {
4921 match self {
4922 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
4923 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
4924 }
4925 }
4926 }
4927
4928 impl ::fbthrift::ResultInfo for DropUserExn {
4929 fn result_type(&self) -> ::fbthrift::ResultType {
4930 match self {
4931 Self::Success(_) => ::fbthrift::ResultType::Return,
4932 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
4933 }
4934 }
4935 }
4936
4937 impl ::fbthrift::GetTType for DropUserExn {
4938 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
4939 }
4940
4941 impl<P> ::fbthrift::Serialize<P> for DropUserExn
4942 where
4943 P: ::fbthrift::ProtocolWriter,
4944 {
4945 fn write(&self, p: &mut P) {
4946 if let Self::ApplicationException(aexn) = self {
4947 return aexn.write(p);
4948 }
4949 p.write_struct_begin("DropUser");
4950 match self {
4951 Self::Success(inner) => {
4952 p.write_field_begin(
4953 "Success",
4954 ::fbthrift::TType::Struct,
4955 0i16,
4956 );
4957 inner.write(p);
4958 p.write_field_end();
4959 }
4960 Self::ApplicationException(_aexn) => unreachable!(),
4961 }
4962 p.write_field_stop();
4963 p.write_struct_end();
4964 }
4965 }
4966
4967 impl<P> ::fbthrift::Deserialize<P> for DropUserExn
4968 where
4969 P: ::fbthrift::ProtocolReader,
4970 {
4971 fn read(p: &mut P) -> ::anyhow::Result<Self> {
4972 static RETURNS: &[::fbthrift::Field] = &[
4973 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
4974 ];
4975 let _ = p.read_struct_begin(|_| ())?;
4976 let mut once = false;
4977 let mut alt = ::std::option::Option::None;
4978 loop {
4979 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
4980 match ((fty, fid as ::std::primitive::i32), once) {
4981 ((::fbthrift::TType::Stop, _), _) => {
4982 p.read_field_end()?;
4983 break;
4984 }
4985 ((::fbthrift::TType::Struct, 0i32), false) => {
4986 once = true;
4987 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
4988 }
4989 ((ty, _id), false) => p.skip(ty)?,
4990 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
4991 ::fbthrift::ApplicationException::new(
4992 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
4993 format!(
4994 "unwanted extra union {} field ty {:?} id {}",
4995 "DropUserExn",
4996 badty,
4997 badid,
4998 ),
4999 )
5000 )),
5001 }
5002 p.read_field_end()?;
5003 }
5004 p.read_struct_end()?;
5005 alt.ok_or_else(||
5006 ::fbthrift::ApplicationException::new(
5007 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5008 format!("Empty union {}", "DropUserExn"),
5009 )
5010 .into(),
5011 )
5012 }
5013 }
5014
5015 #[derive(Clone, Debug)]
5016 pub enum AlterUserExn {
5017 #[doc(hidden)]
5018 Success(crate::types::ExecResp),
5019 ApplicationException(::fbthrift::ApplicationException),
5020 }
5021
5022 impl ::std::convert::From<crate::errors::meta_service::AlterUserError> for AlterUserExn {
5023 fn from(err: crate::errors::meta_service::AlterUserError) -> Self {
5024 match err {
5025 crate::errors::meta_service::AlterUserError::ApplicationException(aexn) => AlterUserExn::ApplicationException(aexn),
5026 crate::errors::meta_service::AlterUserError::ThriftError(err) => AlterUserExn::ApplicationException(::fbthrift::ApplicationException {
5027 message: err.to_string(),
5028 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5029 }),
5030 }
5031 }
5032 }
5033
5034 impl ::std::convert::From<::fbthrift::ApplicationException> for AlterUserExn {
5035 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5036 Self::ApplicationException(exn)
5037 }
5038 }
5039
5040 impl ::fbthrift::ExceptionInfo for AlterUserExn {
5041 fn exn_name(&self) -> &'static str {
5042 match self {
5043 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5044 Self::ApplicationException(aexn) => aexn.exn_name(),
5045 }
5046 }
5047
5048 fn exn_value(&self) -> String {
5049 match self {
5050 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5051 Self::ApplicationException(aexn) => aexn.exn_value(),
5052 }
5053 }
5054
5055 fn exn_is_declared(&self) -> bool {
5056 match self {
5057 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
5058 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
5059 }
5060 }
5061 }
5062
5063 impl ::fbthrift::ResultInfo for AlterUserExn {
5064 fn result_type(&self) -> ::fbthrift::ResultType {
5065 match self {
5066 Self::Success(_) => ::fbthrift::ResultType::Return,
5067 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
5068 }
5069 }
5070 }
5071
5072 impl ::fbthrift::GetTType for AlterUserExn {
5073 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
5074 }
5075
5076 impl<P> ::fbthrift::Serialize<P> for AlterUserExn
5077 where
5078 P: ::fbthrift::ProtocolWriter,
5079 {
5080 fn write(&self, p: &mut P) {
5081 if let Self::ApplicationException(aexn) = self {
5082 return aexn.write(p);
5083 }
5084 p.write_struct_begin("AlterUser");
5085 match self {
5086 Self::Success(inner) => {
5087 p.write_field_begin(
5088 "Success",
5089 ::fbthrift::TType::Struct,
5090 0i16,
5091 );
5092 inner.write(p);
5093 p.write_field_end();
5094 }
5095 Self::ApplicationException(_aexn) => unreachable!(),
5096 }
5097 p.write_field_stop();
5098 p.write_struct_end();
5099 }
5100 }
5101
5102 impl<P> ::fbthrift::Deserialize<P> for AlterUserExn
5103 where
5104 P: ::fbthrift::ProtocolReader,
5105 {
5106 fn read(p: &mut P) -> ::anyhow::Result<Self> {
5107 static RETURNS: &[::fbthrift::Field] = &[
5108 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
5109 ];
5110 let _ = p.read_struct_begin(|_| ())?;
5111 let mut once = false;
5112 let mut alt = ::std::option::Option::None;
5113 loop {
5114 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
5115 match ((fty, fid as ::std::primitive::i32), once) {
5116 ((::fbthrift::TType::Stop, _), _) => {
5117 p.read_field_end()?;
5118 break;
5119 }
5120 ((::fbthrift::TType::Struct, 0i32), false) => {
5121 once = true;
5122 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
5123 }
5124 ((ty, _id), false) => p.skip(ty)?,
5125 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
5126 ::fbthrift::ApplicationException::new(
5127 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
5128 format!(
5129 "unwanted extra union {} field ty {:?} id {}",
5130 "AlterUserExn",
5131 badty,
5132 badid,
5133 ),
5134 )
5135 )),
5136 }
5137 p.read_field_end()?;
5138 }
5139 p.read_struct_end()?;
5140 alt.ok_or_else(||
5141 ::fbthrift::ApplicationException::new(
5142 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5143 format!("Empty union {}", "AlterUserExn"),
5144 )
5145 .into(),
5146 )
5147 }
5148 }
5149
5150 #[derive(Clone, Debug)]
5151 pub enum GrantRoleExn {
5152 #[doc(hidden)]
5153 Success(crate::types::ExecResp),
5154 ApplicationException(::fbthrift::ApplicationException),
5155 }
5156
5157 impl ::std::convert::From<crate::errors::meta_service::GrantRoleError> for GrantRoleExn {
5158 fn from(err: crate::errors::meta_service::GrantRoleError) -> Self {
5159 match err {
5160 crate::errors::meta_service::GrantRoleError::ApplicationException(aexn) => GrantRoleExn::ApplicationException(aexn),
5161 crate::errors::meta_service::GrantRoleError::ThriftError(err) => GrantRoleExn::ApplicationException(::fbthrift::ApplicationException {
5162 message: err.to_string(),
5163 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5164 }),
5165 }
5166 }
5167 }
5168
5169 impl ::std::convert::From<::fbthrift::ApplicationException> for GrantRoleExn {
5170 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5171 Self::ApplicationException(exn)
5172 }
5173 }
5174
5175 impl ::fbthrift::ExceptionInfo for GrantRoleExn {
5176 fn exn_name(&self) -> &'static str {
5177 match self {
5178 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5179 Self::ApplicationException(aexn) => aexn.exn_name(),
5180 }
5181 }
5182
5183 fn exn_value(&self) -> String {
5184 match self {
5185 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5186 Self::ApplicationException(aexn) => aexn.exn_value(),
5187 }
5188 }
5189
5190 fn exn_is_declared(&self) -> bool {
5191 match self {
5192 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
5193 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
5194 }
5195 }
5196 }
5197
5198 impl ::fbthrift::ResultInfo for GrantRoleExn {
5199 fn result_type(&self) -> ::fbthrift::ResultType {
5200 match self {
5201 Self::Success(_) => ::fbthrift::ResultType::Return,
5202 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
5203 }
5204 }
5205 }
5206
5207 impl ::fbthrift::GetTType for GrantRoleExn {
5208 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
5209 }
5210
5211 impl<P> ::fbthrift::Serialize<P> for GrantRoleExn
5212 where
5213 P: ::fbthrift::ProtocolWriter,
5214 {
5215 fn write(&self, p: &mut P) {
5216 if let Self::ApplicationException(aexn) = self {
5217 return aexn.write(p);
5218 }
5219 p.write_struct_begin("GrantRole");
5220 match self {
5221 Self::Success(inner) => {
5222 p.write_field_begin(
5223 "Success",
5224 ::fbthrift::TType::Struct,
5225 0i16,
5226 );
5227 inner.write(p);
5228 p.write_field_end();
5229 }
5230 Self::ApplicationException(_aexn) => unreachable!(),
5231 }
5232 p.write_field_stop();
5233 p.write_struct_end();
5234 }
5235 }
5236
5237 impl<P> ::fbthrift::Deserialize<P> for GrantRoleExn
5238 where
5239 P: ::fbthrift::ProtocolReader,
5240 {
5241 fn read(p: &mut P) -> ::anyhow::Result<Self> {
5242 static RETURNS: &[::fbthrift::Field] = &[
5243 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
5244 ];
5245 let _ = p.read_struct_begin(|_| ())?;
5246 let mut once = false;
5247 let mut alt = ::std::option::Option::None;
5248 loop {
5249 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
5250 match ((fty, fid as ::std::primitive::i32), once) {
5251 ((::fbthrift::TType::Stop, _), _) => {
5252 p.read_field_end()?;
5253 break;
5254 }
5255 ((::fbthrift::TType::Struct, 0i32), false) => {
5256 once = true;
5257 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
5258 }
5259 ((ty, _id), false) => p.skip(ty)?,
5260 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
5261 ::fbthrift::ApplicationException::new(
5262 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
5263 format!(
5264 "unwanted extra union {} field ty {:?} id {}",
5265 "GrantRoleExn",
5266 badty,
5267 badid,
5268 ),
5269 )
5270 )),
5271 }
5272 p.read_field_end()?;
5273 }
5274 p.read_struct_end()?;
5275 alt.ok_or_else(||
5276 ::fbthrift::ApplicationException::new(
5277 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5278 format!("Empty union {}", "GrantRoleExn"),
5279 )
5280 .into(),
5281 )
5282 }
5283 }
5284
5285 #[derive(Clone, Debug)]
5286 pub enum RevokeRoleExn {
5287 #[doc(hidden)]
5288 Success(crate::types::ExecResp),
5289 ApplicationException(::fbthrift::ApplicationException),
5290 }
5291
5292 impl ::std::convert::From<crate::errors::meta_service::RevokeRoleError> for RevokeRoleExn {
5293 fn from(err: crate::errors::meta_service::RevokeRoleError) -> Self {
5294 match err {
5295 crate::errors::meta_service::RevokeRoleError::ApplicationException(aexn) => RevokeRoleExn::ApplicationException(aexn),
5296 crate::errors::meta_service::RevokeRoleError::ThriftError(err) => RevokeRoleExn::ApplicationException(::fbthrift::ApplicationException {
5297 message: err.to_string(),
5298 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5299 }),
5300 }
5301 }
5302 }
5303
5304 impl ::std::convert::From<::fbthrift::ApplicationException> for RevokeRoleExn {
5305 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5306 Self::ApplicationException(exn)
5307 }
5308 }
5309
5310 impl ::fbthrift::ExceptionInfo for RevokeRoleExn {
5311 fn exn_name(&self) -> &'static str {
5312 match self {
5313 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5314 Self::ApplicationException(aexn) => aexn.exn_name(),
5315 }
5316 }
5317
5318 fn exn_value(&self) -> String {
5319 match self {
5320 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5321 Self::ApplicationException(aexn) => aexn.exn_value(),
5322 }
5323 }
5324
5325 fn exn_is_declared(&self) -> bool {
5326 match self {
5327 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
5328 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
5329 }
5330 }
5331 }
5332
5333 impl ::fbthrift::ResultInfo for RevokeRoleExn {
5334 fn result_type(&self) -> ::fbthrift::ResultType {
5335 match self {
5336 Self::Success(_) => ::fbthrift::ResultType::Return,
5337 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
5338 }
5339 }
5340 }
5341
5342 impl ::fbthrift::GetTType for RevokeRoleExn {
5343 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
5344 }
5345
5346 impl<P> ::fbthrift::Serialize<P> for RevokeRoleExn
5347 where
5348 P: ::fbthrift::ProtocolWriter,
5349 {
5350 fn write(&self, p: &mut P) {
5351 if let Self::ApplicationException(aexn) = self {
5352 return aexn.write(p);
5353 }
5354 p.write_struct_begin("RevokeRole");
5355 match self {
5356 Self::Success(inner) => {
5357 p.write_field_begin(
5358 "Success",
5359 ::fbthrift::TType::Struct,
5360 0i16,
5361 );
5362 inner.write(p);
5363 p.write_field_end();
5364 }
5365 Self::ApplicationException(_aexn) => unreachable!(),
5366 }
5367 p.write_field_stop();
5368 p.write_struct_end();
5369 }
5370 }
5371
5372 impl<P> ::fbthrift::Deserialize<P> for RevokeRoleExn
5373 where
5374 P: ::fbthrift::ProtocolReader,
5375 {
5376 fn read(p: &mut P) -> ::anyhow::Result<Self> {
5377 static RETURNS: &[::fbthrift::Field] = &[
5378 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
5379 ];
5380 let _ = p.read_struct_begin(|_| ())?;
5381 let mut once = false;
5382 let mut alt = ::std::option::Option::None;
5383 loop {
5384 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
5385 match ((fty, fid as ::std::primitive::i32), once) {
5386 ((::fbthrift::TType::Stop, _), _) => {
5387 p.read_field_end()?;
5388 break;
5389 }
5390 ((::fbthrift::TType::Struct, 0i32), false) => {
5391 once = true;
5392 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
5393 }
5394 ((ty, _id), false) => p.skip(ty)?,
5395 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
5396 ::fbthrift::ApplicationException::new(
5397 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
5398 format!(
5399 "unwanted extra union {} field ty {:?} id {}",
5400 "RevokeRoleExn",
5401 badty,
5402 badid,
5403 ),
5404 )
5405 )),
5406 }
5407 p.read_field_end()?;
5408 }
5409 p.read_struct_end()?;
5410 alt.ok_or_else(||
5411 ::fbthrift::ApplicationException::new(
5412 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5413 format!("Empty union {}", "RevokeRoleExn"),
5414 )
5415 .into(),
5416 )
5417 }
5418 }
5419
5420 #[derive(Clone, Debug)]
5421 pub enum ListUsersExn {
5422 #[doc(hidden)]
5423 Success(crate::types::ListUsersResp),
5424 ApplicationException(::fbthrift::ApplicationException),
5425 }
5426
5427 impl ::std::convert::From<crate::errors::meta_service::ListUsersError> for ListUsersExn {
5428 fn from(err: crate::errors::meta_service::ListUsersError) -> Self {
5429 match err {
5430 crate::errors::meta_service::ListUsersError::ApplicationException(aexn) => ListUsersExn::ApplicationException(aexn),
5431 crate::errors::meta_service::ListUsersError::ThriftError(err) => ListUsersExn::ApplicationException(::fbthrift::ApplicationException {
5432 message: err.to_string(),
5433 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5434 }),
5435 }
5436 }
5437 }
5438
5439 impl ::std::convert::From<::fbthrift::ApplicationException> for ListUsersExn {
5440 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5441 Self::ApplicationException(exn)
5442 }
5443 }
5444
5445 impl ::fbthrift::ExceptionInfo for ListUsersExn {
5446 fn exn_name(&self) -> &'static str {
5447 match self {
5448 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5449 Self::ApplicationException(aexn) => aexn.exn_name(),
5450 }
5451 }
5452
5453 fn exn_value(&self) -> String {
5454 match self {
5455 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5456 Self::ApplicationException(aexn) => aexn.exn_value(),
5457 }
5458 }
5459
5460 fn exn_is_declared(&self) -> bool {
5461 match self {
5462 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
5463 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
5464 }
5465 }
5466 }
5467
5468 impl ::fbthrift::ResultInfo for ListUsersExn {
5469 fn result_type(&self) -> ::fbthrift::ResultType {
5470 match self {
5471 Self::Success(_) => ::fbthrift::ResultType::Return,
5472 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
5473 }
5474 }
5475 }
5476
5477 impl ::fbthrift::GetTType for ListUsersExn {
5478 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
5479 }
5480
5481 impl<P> ::fbthrift::Serialize<P> for ListUsersExn
5482 where
5483 P: ::fbthrift::ProtocolWriter,
5484 {
5485 fn write(&self, p: &mut P) {
5486 if let Self::ApplicationException(aexn) = self {
5487 return aexn.write(p);
5488 }
5489 p.write_struct_begin("ListUsers");
5490 match self {
5491 Self::Success(inner) => {
5492 p.write_field_begin(
5493 "Success",
5494 ::fbthrift::TType::Struct,
5495 0i16,
5496 );
5497 inner.write(p);
5498 p.write_field_end();
5499 }
5500 Self::ApplicationException(_aexn) => unreachable!(),
5501 }
5502 p.write_field_stop();
5503 p.write_struct_end();
5504 }
5505 }
5506
5507 impl<P> ::fbthrift::Deserialize<P> for ListUsersExn
5508 where
5509 P: ::fbthrift::ProtocolReader,
5510 {
5511 fn read(p: &mut P) -> ::anyhow::Result<Self> {
5512 static RETURNS: &[::fbthrift::Field] = &[
5513 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
5514 ];
5515 let _ = p.read_struct_begin(|_| ())?;
5516 let mut once = false;
5517 let mut alt = ::std::option::Option::None;
5518 loop {
5519 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
5520 match ((fty, fid as ::std::primitive::i32), once) {
5521 ((::fbthrift::TType::Stop, _), _) => {
5522 p.read_field_end()?;
5523 break;
5524 }
5525 ((::fbthrift::TType::Struct, 0i32), false) => {
5526 once = true;
5527 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
5528 }
5529 ((ty, _id), false) => p.skip(ty)?,
5530 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
5531 ::fbthrift::ApplicationException::new(
5532 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
5533 format!(
5534 "unwanted extra union {} field ty {:?} id {}",
5535 "ListUsersExn",
5536 badty,
5537 badid,
5538 ),
5539 )
5540 )),
5541 }
5542 p.read_field_end()?;
5543 }
5544 p.read_struct_end()?;
5545 alt.ok_or_else(||
5546 ::fbthrift::ApplicationException::new(
5547 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5548 format!("Empty union {}", "ListUsersExn"),
5549 )
5550 .into(),
5551 )
5552 }
5553 }
5554
5555 #[derive(Clone, Debug)]
5556 pub enum ListRolesExn {
5557 #[doc(hidden)]
5558 Success(crate::types::ListRolesResp),
5559 ApplicationException(::fbthrift::ApplicationException),
5560 }
5561
5562 impl ::std::convert::From<crate::errors::meta_service::ListRolesError> for ListRolesExn {
5563 fn from(err: crate::errors::meta_service::ListRolesError) -> Self {
5564 match err {
5565 crate::errors::meta_service::ListRolesError::ApplicationException(aexn) => ListRolesExn::ApplicationException(aexn),
5566 crate::errors::meta_service::ListRolesError::ThriftError(err) => ListRolesExn::ApplicationException(::fbthrift::ApplicationException {
5567 message: err.to_string(),
5568 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5569 }),
5570 }
5571 }
5572 }
5573
5574 impl ::std::convert::From<::fbthrift::ApplicationException> for ListRolesExn {
5575 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5576 Self::ApplicationException(exn)
5577 }
5578 }
5579
5580 impl ::fbthrift::ExceptionInfo for ListRolesExn {
5581 fn exn_name(&self) -> &'static str {
5582 match self {
5583 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5584 Self::ApplicationException(aexn) => aexn.exn_name(),
5585 }
5586 }
5587
5588 fn exn_value(&self) -> String {
5589 match self {
5590 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5591 Self::ApplicationException(aexn) => aexn.exn_value(),
5592 }
5593 }
5594
5595 fn exn_is_declared(&self) -> bool {
5596 match self {
5597 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
5598 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
5599 }
5600 }
5601 }
5602
5603 impl ::fbthrift::ResultInfo for ListRolesExn {
5604 fn result_type(&self) -> ::fbthrift::ResultType {
5605 match self {
5606 Self::Success(_) => ::fbthrift::ResultType::Return,
5607 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
5608 }
5609 }
5610 }
5611
5612 impl ::fbthrift::GetTType for ListRolesExn {
5613 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
5614 }
5615
5616 impl<P> ::fbthrift::Serialize<P> for ListRolesExn
5617 where
5618 P: ::fbthrift::ProtocolWriter,
5619 {
5620 fn write(&self, p: &mut P) {
5621 if let Self::ApplicationException(aexn) = self {
5622 return aexn.write(p);
5623 }
5624 p.write_struct_begin("ListRoles");
5625 match self {
5626 Self::Success(inner) => {
5627 p.write_field_begin(
5628 "Success",
5629 ::fbthrift::TType::Struct,
5630 0i16,
5631 );
5632 inner.write(p);
5633 p.write_field_end();
5634 }
5635 Self::ApplicationException(_aexn) => unreachable!(),
5636 }
5637 p.write_field_stop();
5638 p.write_struct_end();
5639 }
5640 }
5641
5642 impl<P> ::fbthrift::Deserialize<P> for ListRolesExn
5643 where
5644 P: ::fbthrift::ProtocolReader,
5645 {
5646 fn read(p: &mut P) -> ::anyhow::Result<Self> {
5647 static RETURNS: &[::fbthrift::Field] = &[
5648 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
5649 ];
5650 let _ = p.read_struct_begin(|_| ())?;
5651 let mut once = false;
5652 let mut alt = ::std::option::Option::None;
5653 loop {
5654 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
5655 match ((fty, fid as ::std::primitive::i32), once) {
5656 ((::fbthrift::TType::Stop, _), _) => {
5657 p.read_field_end()?;
5658 break;
5659 }
5660 ((::fbthrift::TType::Struct, 0i32), false) => {
5661 once = true;
5662 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
5663 }
5664 ((ty, _id), false) => p.skip(ty)?,
5665 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
5666 ::fbthrift::ApplicationException::new(
5667 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
5668 format!(
5669 "unwanted extra union {} field ty {:?} id {}",
5670 "ListRolesExn",
5671 badty,
5672 badid,
5673 ),
5674 )
5675 )),
5676 }
5677 p.read_field_end()?;
5678 }
5679 p.read_struct_end()?;
5680 alt.ok_or_else(||
5681 ::fbthrift::ApplicationException::new(
5682 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5683 format!("Empty union {}", "ListRolesExn"),
5684 )
5685 .into(),
5686 )
5687 }
5688 }
5689
5690 #[derive(Clone, Debug)]
5691 pub enum GetUserRolesExn {
5692 #[doc(hidden)]
5693 Success(crate::types::ListRolesResp),
5694 ApplicationException(::fbthrift::ApplicationException),
5695 }
5696
5697 impl ::std::convert::From<crate::errors::meta_service::GetUserRolesError> for GetUserRolesExn {
5698 fn from(err: crate::errors::meta_service::GetUserRolesError) -> Self {
5699 match err {
5700 crate::errors::meta_service::GetUserRolesError::ApplicationException(aexn) => GetUserRolesExn::ApplicationException(aexn),
5701 crate::errors::meta_service::GetUserRolesError::ThriftError(err) => GetUserRolesExn::ApplicationException(::fbthrift::ApplicationException {
5702 message: err.to_string(),
5703 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5704 }),
5705 }
5706 }
5707 }
5708
5709 impl ::std::convert::From<::fbthrift::ApplicationException> for GetUserRolesExn {
5710 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5711 Self::ApplicationException(exn)
5712 }
5713 }
5714
5715 impl ::fbthrift::ExceptionInfo for GetUserRolesExn {
5716 fn exn_name(&self) -> &'static str {
5717 match self {
5718 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5719 Self::ApplicationException(aexn) => aexn.exn_name(),
5720 }
5721 }
5722
5723 fn exn_value(&self) -> String {
5724 match self {
5725 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5726 Self::ApplicationException(aexn) => aexn.exn_value(),
5727 }
5728 }
5729
5730 fn exn_is_declared(&self) -> bool {
5731 match self {
5732 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
5733 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
5734 }
5735 }
5736 }
5737
5738 impl ::fbthrift::ResultInfo for GetUserRolesExn {
5739 fn result_type(&self) -> ::fbthrift::ResultType {
5740 match self {
5741 Self::Success(_) => ::fbthrift::ResultType::Return,
5742 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
5743 }
5744 }
5745 }
5746
5747 impl ::fbthrift::GetTType for GetUserRolesExn {
5748 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
5749 }
5750
5751 impl<P> ::fbthrift::Serialize<P> for GetUserRolesExn
5752 where
5753 P: ::fbthrift::ProtocolWriter,
5754 {
5755 fn write(&self, p: &mut P) {
5756 if let Self::ApplicationException(aexn) = self {
5757 return aexn.write(p);
5758 }
5759 p.write_struct_begin("GetUserRoles");
5760 match self {
5761 Self::Success(inner) => {
5762 p.write_field_begin(
5763 "Success",
5764 ::fbthrift::TType::Struct,
5765 0i16,
5766 );
5767 inner.write(p);
5768 p.write_field_end();
5769 }
5770 Self::ApplicationException(_aexn) => unreachable!(),
5771 }
5772 p.write_field_stop();
5773 p.write_struct_end();
5774 }
5775 }
5776
5777 impl<P> ::fbthrift::Deserialize<P> for GetUserRolesExn
5778 where
5779 P: ::fbthrift::ProtocolReader,
5780 {
5781 fn read(p: &mut P) -> ::anyhow::Result<Self> {
5782 static RETURNS: &[::fbthrift::Field] = &[
5783 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
5784 ];
5785 let _ = p.read_struct_begin(|_| ())?;
5786 let mut once = false;
5787 let mut alt = ::std::option::Option::None;
5788 loop {
5789 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
5790 match ((fty, fid as ::std::primitive::i32), once) {
5791 ((::fbthrift::TType::Stop, _), _) => {
5792 p.read_field_end()?;
5793 break;
5794 }
5795 ((::fbthrift::TType::Struct, 0i32), false) => {
5796 once = true;
5797 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
5798 }
5799 ((ty, _id), false) => p.skip(ty)?,
5800 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
5801 ::fbthrift::ApplicationException::new(
5802 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
5803 format!(
5804 "unwanted extra union {} field ty {:?} id {}",
5805 "GetUserRolesExn",
5806 badty,
5807 badid,
5808 ),
5809 )
5810 )),
5811 }
5812 p.read_field_end()?;
5813 }
5814 p.read_struct_end()?;
5815 alt.ok_or_else(||
5816 ::fbthrift::ApplicationException::new(
5817 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5818 format!("Empty union {}", "GetUserRolesExn"),
5819 )
5820 .into(),
5821 )
5822 }
5823 }
5824
5825 #[derive(Clone, Debug)]
5826 pub enum ChangePasswordExn {
5827 #[doc(hidden)]
5828 Success(crate::types::ExecResp),
5829 ApplicationException(::fbthrift::ApplicationException),
5830 }
5831
5832 impl ::std::convert::From<crate::errors::meta_service::ChangePasswordError> for ChangePasswordExn {
5833 fn from(err: crate::errors::meta_service::ChangePasswordError) -> Self {
5834 match err {
5835 crate::errors::meta_service::ChangePasswordError::ApplicationException(aexn) => ChangePasswordExn::ApplicationException(aexn),
5836 crate::errors::meta_service::ChangePasswordError::ThriftError(err) => ChangePasswordExn::ApplicationException(::fbthrift::ApplicationException {
5837 message: err.to_string(),
5838 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5839 }),
5840 }
5841 }
5842 }
5843
5844 impl ::std::convert::From<::fbthrift::ApplicationException> for ChangePasswordExn {
5845 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5846 Self::ApplicationException(exn)
5847 }
5848 }
5849
5850 impl ::fbthrift::ExceptionInfo for ChangePasswordExn {
5851 fn exn_name(&self) -> &'static str {
5852 match self {
5853 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5854 Self::ApplicationException(aexn) => aexn.exn_name(),
5855 }
5856 }
5857
5858 fn exn_value(&self) -> String {
5859 match self {
5860 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5861 Self::ApplicationException(aexn) => aexn.exn_value(),
5862 }
5863 }
5864
5865 fn exn_is_declared(&self) -> bool {
5866 match self {
5867 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
5868 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
5869 }
5870 }
5871 }
5872
5873 impl ::fbthrift::ResultInfo for ChangePasswordExn {
5874 fn result_type(&self) -> ::fbthrift::ResultType {
5875 match self {
5876 Self::Success(_) => ::fbthrift::ResultType::Return,
5877 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
5878 }
5879 }
5880 }
5881
5882 impl ::fbthrift::GetTType for ChangePasswordExn {
5883 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
5884 }
5885
5886 impl<P> ::fbthrift::Serialize<P> for ChangePasswordExn
5887 where
5888 P: ::fbthrift::ProtocolWriter,
5889 {
5890 fn write(&self, p: &mut P) {
5891 if let Self::ApplicationException(aexn) = self {
5892 return aexn.write(p);
5893 }
5894 p.write_struct_begin("ChangePassword");
5895 match self {
5896 Self::Success(inner) => {
5897 p.write_field_begin(
5898 "Success",
5899 ::fbthrift::TType::Struct,
5900 0i16,
5901 );
5902 inner.write(p);
5903 p.write_field_end();
5904 }
5905 Self::ApplicationException(_aexn) => unreachable!(),
5906 }
5907 p.write_field_stop();
5908 p.write_struct_end();
5909 }
5910 }
5911
5912 impl<P> ::fbthrift::Deserialize<P> for ChangePasswordExn
5913 where
5914 P: ::fbthrift::ProtocolReader,
5915 {
5916 fn read(p: &mut P) -> ::anyhow::Result<Self> {
5917 static RETURNS: &[::fbthrift::Field] = &[
5918 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
5919 ];
5920 let _ = p.read_struct_begin(|_| ())?;
5921 let mut once = false;
5922 let mut alt = ::std::option::Option::None;
5923 loop {
5924 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
5925 match ((fty, fid as ::std::primitive::i32), once) {
5926 ((::fbthrift::TType::Stop, _), _) => {
5927 p.read_field_end()?;
5928 break;
5929 }
5930 ((::fbthrift::TType::Struct, 0i32), false) => {
5931 once = true;
5932 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
5933 }
5934 ((ty, _id), false) => p.skip(ty)?,
5935 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
5936 ::fbthrift::ApplicationException::new(
5937 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
5938 format!(
5939 "unwanted extra union {} field ty {:?} id {}",
5940 "ChangePasswordExn",
5941 badty,
5942 badid,
5943 ),
5944 )
5945 )),
5946 }
5947 p.read_field_end()?;
5948 }
5949 p.read_struct_end()?;
5950 alt.ok_or_else(||
5951 ::fbthrift::ApplicationException::new(
5952 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
5953 format!("Empty union {}", "ChangePasswordExn"),
5954 )
5955 .into(),
5956 )
5957 }
5958 }
5959
5960 #[derive(Clone, Debug)]
5961 pub enum HeartBeatExn {
5962 #[doc(hidden)]
5963 Success(crate::types::HBResp),
5964 ApplicationException(::fbthrift::ApplicationException),
5965 }
5966
5967 impl ::std::convert::From<crate::errors::meta_service::HeartBeatError> for HeartBeatExn {
5968 fn from(err: crate::errors::meta_service::HeartBeatError) -> Self {
5969 match err {
5970 crate::errors::meta_service::HeartBeatError::ApplicationException(aexn) => HeartBeatExn::ApplicationException(aexn),
5971 crate::errors::meta_service::HeartBeatError::ThriftError(err) => HeartBeatExn::ApplicationException(::fbthrift::ApplicationException {
5972 message: err.to_string(),
5973 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
5974 }),
5975 }
5976 }
5977 }
5978
5979 impl ::std::convert::From<::fbthrift::ApplicationException> for HeartBeatExn {
5980 fn from(exn: ::fbthrift::ApplicationException) -> Self {
5981 Self::ApplicationException(exn)
5982 }
5983 }
5984
5985 impl ::fbthrift::ExceptionInfo for HeartBeatExn {
5986 fn exn_name(&self) -> &'static str {
5987 match self {
5988 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
5989 Self::ApplicationException(aexn) => aexn.exn_name(),
5990 }
5991 }
5992
5993 fn exn_value(&self) -> String {
5994 match self {
5995 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
5996 Self::ApplicationException(aexn) => aexn.exn_value(),
5997 }
5998 }
5999
6000 fn exn_is_declared(&self) -> bool {
6001 match self {
6002 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6003 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6004 }
6005 }
6006 }
6007
6008 impl ::fbthrift::ResultInfo for HeartBeatExn {
6009 fn result_type(&self) -> ::fbthrift::ResultType {
6010 match self {
6011 Self::Success(_) => ::fbthrift::ResultType::Return,
6012 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6013 }
6014 }
6015 }
6016
6017 impl ::fbthrift::GetTType for HeartBeatExn {
6018 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6019 }
6020
6021 impl<P> ::fbthrift::Serialize<P> for HeartBeatExn
6022 where
6023 P: ::fbthrift::ProtocolWriter,
6024 {
6025 fn write(&self, p: &mut P) {
6026 if let Self::ApplicationException(aexn) = self {
6027 return aexn.write(p);
6028 }
6029 p.write_struct_begin("HeartBeat");
6030 match self {
6031 Self::Success(inner) => {
6032 p.write_field_begin(
6033 "Success",
6034 ::fbthrift::TType::Struct,
6035 0i16,
6036 );
6037 inner.write(p);
6038 p.write_field_end();
6039 }
6040 Self::ApplicationException(_aexn) => unreachable!(),
6041 }
6042 p.write_field_stop();
6043 p.write_struct_end();
6044 }
6045 }
6046
6047 impl<P> ::fbthrift::Deserialize<P> for HeartBeatExn
6048 where
6049 P: ::fbthrift::ProtocolReader,
6050 {
6051 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6052 static RETURNS: &[::fbthrift::Field] = &[
6053 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6054 ];
6055 let _ = p.read_struct_begin(|_| ())?;
6056 let mut once = false;
6057 let mut alt = ::std::option::Option::None;
6058 loop {
6059 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
6060 match ((fty, fid as ::std::primitive::i32), once) {
6061 ((::fbthrift::TType::Stop, _), _) => {
6062 p.read_field_end()?;
6063 break;
6064 }
6065 ((::fbthrift::TType::Struct, 0i32), false) => {
6066 once = true;
6067 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
6068 }
6069 ((ty, _id), false) => p.skip(ty)?,
6070 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
6071 ::fbthrift::ApplicationException::new(
6072 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
6073 format!(
6074 "unwanted extra union {} field ty {:?} id {}",
6075 "HeartBeatExn",
6076 badty,
6077 badid,
6078 ),
6079 )
6080 )),
6081 }
6082 p.read_field_end()?;
6083 }
6084 p.read_struct_end()?;
6085 alt.ok_or_else(||
6086 ::fbthrift::ApplicationException::new(
6087 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
6088 format!("Empty union {}", "HeartBeatExn"),
6089 )
6090 .into(),
6091 )
6092 }
6093 }
6094
6095 #[derive(Clone, Debug)]
6096 pub enum BalanceExn {
6097 #[doc(hidden)]
6098 Success(crate::types::BalanceResp),
6099 ApplicationException(::fbthrift::ApplicationException),
6100 }
6101
6102 impl ::std::convert::From<crate::errors::meta_service::BalanceError> for BalanceExn {
6103 fn from(err: crate::errors::meta_service::BalanceError) -> Self {
6104 match err {
6105 crate::errors::meta_service::BalanceError::ApplicationException(aexn) => BalanceExn::ApplicationException(aexn),
6106 crate::errors::meta_service::BalanceError::ThriftError(err) => BalanceExn::ApplicationException(::fbthrift::ApplicationException {
6107 message: err.to_string(),
6108 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
6109 }),
6110 }
6111 }
6112 }
6113
6114 impl ::std::convert::From<::fbthrift::ApplicationException> for BalanceExn {
6115 fn from(exn: ::fbthrift::ApplicationException) -> Self {
6116 Self::ApplicationException(exn)
6117 }
6118 }
6119
6120 impl ::fbthrift::ExceptionInfo for BalanceExn {
6121 fn exn_name(&self) -> &'static str {
6122 match self {
6123 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
6124 Self::ApplicationException(aexn) => aexn.exn_name(),
6125 }
6126 }
6127
6128 fn exn_value(&self) -> String {
6129 match self {
6130 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
6131 Self::ApplicationException(aexn) => aexn.exn_value(),
6132 }
6133 }
6134
6135 fn exn_is_declared(&self) -> bool {
6136 match self {
6137 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6138 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6139 }
6140 }
6141 }
6142
6143 impl ::fbthrift::ResultInfo for BalanceExn {
6144 fn result_type(&self) -> ::fbthrift::ResultType {
6145 match self {
6146 Self::Success(_) => ::fbthrift::ResultType::Return,
6147 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6148 }
6149 }
6150 }
6151
6152 impl ::fbthrift::GetTType for BalanceExn {
6153 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6154 }
6155
6156 impl<P> ::fbthrift::Serialize<P> for BalanceExn
6157 where
6158 P: ::fbthrift::ProtocolWriter,
6159 {
6160 fn write(&self, p: &mut P) {
6161 if let Self::ApplicationException(aexn) = self {
6162 return aexn.write(p);
6163 }
6164 p.write_struct_begin("Balance");
6165 match self {
6166 Self::Success(inner) => {
6167 p.write_field_begin(
6168 "Success",
6169 ::fbthrift::TType::Struct,
6170 0i16,
6171 );
6172 inner.write(p);
6173 p.write_field_end();
6174 }
6175 Self::ApplicationException(_aexn) => unreachable!(),
6176 }
6177 p.write_field_stop();
6178 p.write_struct_end();
6179 }
6180 }
6181
6182 impl<P> ::fbthrift::Deserialize<P> for BalanceExn
6183 where
6184 P: ::fbthrift::ProtocolReader,
6185 {
6186 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6187 static RETURNS: &[::fbthrift::Field] = &[
6188 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6189 ];
6190 let _ = p.read_struct_begin(|_| ())?;
6191 let mut once = false;
6192 let mut alt = ::std::option::Option::None;
6193 loop {
6194 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
6195 match ((fty, fid as ::std::primitive::i32), once) {
6196 ((::fbthrift::TType::Stop, _), _) => {
6197 p.read_field_end()?;
6198 break;
6199 }
6200 ((::fbthrift::TType::Struct, 0i32), false) => {
6201 once = true;
6202 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
6203 }
6204 ((ty, _id), false) => p.skip(ty)?,
6205 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
6206 ::fbthrift::ApplicationException::new(
6207 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
6208 format!(
6209 "unwanted extra union {} field ty {:?} id {}",
6210 "BalanceExn",
6211 badty,
6212 badid,
6213 ),
6214 )
6215 )),
6216 }
6217 p.read_field_end()?;
6218 }
6219 p.read_struct_end()?;
6220 alt.ok_or_else(||
6221 ::fbthrift::ApplicationException::new(
6222 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
6223 format!("Empty union {}", "BalanceExn"),
6224 )
6225 .into(),
6226 )
6227 }
6228 }
6229
6230 #[derive(Clone, Debug)]
6231 pub enum LeaderBalanceExn {
6232 #[doc(hidden)]
6233 Success(crate::types::ExecResp),
6234 ApplicationException(::fbthrift::ApplicationException),
6235 }
6236
6237 impl ::std::convert::From<crate::errors::meta_service::LeaderBalanceError> for LeaderBalanceExn {
6238 fn from(err: crate::errors::meta_service::LeaderBalanceError) -> Self {
6239 match err {
6240 crate::errors::meta_service::LeaderBalanceError::ApplicationException(aexn) => LeaderBalanceExn::ApplicationException(aexn),
6241 crate::errors::meta_service::LeaderBalanceError::ThriftError(err) => LeaderBalanceExn::ApplicationException(::fbthrift::ApplicationException {
6242 message: err.to_string(),
6243 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
6244 }),
6245 }
6246 }
6247 }
6248
6249 impl ::std::convert::From<::fbthrift::ApplicationException> for LeaderBalanceExn {
6250 fn from(exn: ::fbthrift::ApplicationException) -> Self {
6251 Self::ApplicationException(exn)
6252 }
6253 }
6254
6255 impl ::fbthrift::ExceptionInfo for LeaderBalanceExn {
6256 fn exn_name(&self) -> &'static str {
6257 match self {
6258 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
6259 Self::ApplicationException(aexn) => aexn.exn_name(),
6260 }
6261 }
6262
6263 fn exn_value(&self) -> String {
6264 match self {
6265 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
6266 Self::ApplicationException(aexn) => aexn.exn_value(),
6267 }
6268 }
6269
6270 fn exn_is_declared(&self) -> bool {
6271 match self {
6272 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6273 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6274 }
6275 }
6276 }
6277
6278 impl ::fbthrift::ResultInfo for LeaderBalanceExn {
6279 fn result_type(&self) -> ::fbthrift::ResultType {
6280 match self {
6281 Self::Success(_) => ::fbthrift::ResultType::Return,
6282 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6283 }
6284 }
6285 }
6286
6287 impl ::fbthrift::GetTType for LeaderBalanceExn {
6288 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6289 }
6290
6291 impl<P> ::fbthrift::Serialize<P> for LeaderBalanceExn
6292 where
6293 P: ::fbthrift::ProtocolWriter,
6294 {
6295 fn write(&self, p: &mut P) {
6296 if let Self::ApplicationException(aexn) = self {
6297 return aexn.write(p);
6298 }
6299 p.write_struct_begin("LeaderBalance");
6300 match self {
6301 Self::Success(inner) => {
6302 p.write_field_begin(
6303 "Success",
6304 ::fbthrift::TType::Struct,
6305 0i16,
6306 );
6307 inner.write(p);
6308 p.write_field_end();
6309 }
6310 Self::ApplicationException(_aexn) => unreachable!(),
6311 }
6312 p.write_field_stop();
6313 p.write_struct_end();
6314 }
6315 }
6316
6317 impl<P> ::fbthrift::Deserialize<P> for LeaderBalanceExn
6318 where
6319 P: ::fbthrift::ProtocolReader,
6320 {
6321 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6322 static RETURNS: &[::fbthrift::Field] = &[
6323 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6324 ];
6325 let _ = p.read_struct_begin(|_| ())?;
6326 let mut once = false;
6327 let mut alt = ::std::option::Option::None;
6328 loop {
6329 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
6330 match ((fty, fid as ::std::primitive::i32), once) {
6331 ((::fbthrift::TType::Stop, _), _) => {
6332 p.read_field_end()?;
6333 break;
6334 }
6335 ((::fbthrift::TType::Struct, 0i32), false) => {
6336 once = true;
6337 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
6338 }
6339 ((ty, _id), false) => p.skip(ty)?,
6340 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
6341 ::fbthrift::ApplicationException::new(
6342 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
6343 format!(
6344 "unwanted extra union {} field ty {:?} id {}",
6345 "LeaderBalanceExn",
6346 badty,
6347 badid,
6348 ),
6349 )
6350 )),
6351 }
6352 p.read_field_end()?;
6353 }
6354 p.read_struct_end()?;
6355 alt.ok_or_else(||
6356 ::fbthrift::ApplicationException::new(
6357 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
6358 format!("Empty union {}", "LeaderBalanceExn"),
6359 )
6360 .into(),
6361 )
6362 }
6363 }
6364
6365 #[derive(Clone, Debug)]
6366 pub enum RegConfigExn {
6367 #[doc(hidden)]
6368 Success(crate::types::ExecResp),
6369 ApplicationException(::fbthrift::ApplicationException),
6370 }
6371
6372 impl ::std::convert::From<crate::errors::meta_service::RegConfigError> for RegConfigExn {
6373 fn from(err: crate::errors::meta_service::RegConfigError) -> Self {
6374 match err {
6375 crate::errors::meta_service::RegConfigError::ApplicationException(aexn) => RegConfigExn::ApplicationException(aexn),
6376 crate::errors::meta_service::RegConfigError::ThriftError(err) => RegConfigExn::ApplicationException(::fbthrift::ApplicationException {
6377 message: err.to_string(),
6378 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
6379 }),
6380 }
6381 }
6382 }
6383
6384 impl ::std::convert::From<::fbthrift::ApplicationException> for RegConfigExn {
6385 fn from(exn: ::fbthrift::ApplicationException) -> Self {
6386 Self::ApplicationException(exn)
6387 }
6388 }
6389
6390 impl ::fbthrift::ExceptionInfo for RegConfigExn {
6391 fn exn_name(&self) -> &'static str {
6392 match self {
6393 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
6394 Self::ApplicationException(aexn) => aexn.exn_name(),
6395 }
6396 }
6397
6398 fn exn_value(&self) -> String {
6399 match self {
6400 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
6401 Self::ApplicationException(aexn) => aexn.exn_value(),
6402 }
6403 }
6404
6405 fn exn_is_declared(&self) -> bool {
6406 match self {
6407 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6408 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6409 }
6410 }
6411 }
6412
6413 impl ::fbthrift::ResultInfo for RegConfigExn {
6414 fn result_type(&self) -> ::fbthrift::ResultType {
6415 match self {
6416 Self::Success(_) => ::fbthrift::ResultType::Return,
6417 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6418 }
6419 }
6420 }
6421
6422 impl ::fbthrift::GetTType for RegConfigExn {
6423 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6424 }
6425
6426 impl<P> ::fbthrift::Serialize<P> for RegConfigExn
6427 where
6428 P: ::fbthrift::ProtocolWriter,
6429 {
6430 fn write(&self, p: &mut P) {
6431 if let Self::ApplicationException(aexn) = self {
6432 return aexn.write(p);
6433 }
6434 p.write_struct_begin("RegConfig");
6435 match self {
6436 Self::Success(inner) => {
6437 p.write_field_begin(
6438 "Success",
6439 ::fbthrift::TType::Struct,
6440 0i16,
6441 );
6442 inner.write(p);
6443 p.write_field_end();
6444 }
6445 Self::ApplicationException(_aexn) => unreachable!(),
6446 }
6447 p.write_field_stop();
6448 p.write_struct_end();
6449 }
6450 }
6451
6452 impl<P> ::fbthrift::Deserialize<P> for RegConfigExn
6453 where
6454 P: ::fbthrift::ProtocolReader,
6455 {
6456 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6457 static RETURNS: &[::fbthrift::Field] = &[
6458 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6459 ];
6460 let _ = p.read_struct_begin(|_| ())?;
6461 let mut once = false;
6462 let mut alt = ::std::option::Option::None;
6463 loop {
6464 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
6465 match ((fty, fid as ::std::primitive::i32), once) {
6466 ((::fbthrift::TType::Stop, _), _) => {
6467 p.read_field_end()?;
6468 break;
6469 }
6470 ((::fbthrift::TType::Struct, 0i32), false) => {
6471 once = true;
6472 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
6473 }
6474 ((ty, _id), false) => p.skip(ty)?,
6475 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
6476 ::fbthrift::ApplicationException::new(
6477 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
6478 format!(
6479 "unwanted extra union {} field ty {:?} id {}",
6480 "RegConfigExn",
6481 badty,
6482 badid,
6483 ),
6484 )
6485 )),
6486 }
6487 p.read_field_end()?;
6488 }
6489 p.read_struct_end()?;
6490 alt.ok_or_else(||
6491 ::fbthrift::ApplicationException::new(
6492 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
6493 format!("Empty union {}", "RegConfigExn"),
6494 )
6495 .into(),
6496 )
6497 }
6498 }
6499
6500 #[derive(Clone, Debug)]
6501 pub enum GetConfigExn {
6502 #[doc(hidden)]
6503 Success(crate::types::GetConfigResp),
6504 ApplicationException(::fbthrift::ApplicationException),
6505 }
6506
6507 impl ::std::convert::From<crate::errors::meta_service::GetConfigError> for GetConfigExn {
6508 fn from(err: crate::errors::meta_service::GetConfigError) -> Self {
6509 match err {
6510 crate::errors::meta_service::GetConfigError::ApplicationException(aexn) => GetConfigExn::ApplicationException(aexn),
6511 crate::errors::meta_service::GetConfigError::ThriftError(err) => GetConfigExn::ApplicationException(::fbthrift::ApplicationException {
6512 message: err.to_string(),
6513 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
6514 }),
6515 }
6516 }
6517 }
6518
6519 impl ::std::convert::From<::fbthrift::ApplicationException> for GetConfigExn {
6520 fn from(exn: ::fbthrift::ApplicationException) -> Self {
6521 Self::ApplicationException(exn)
6522 }
6523 }
6524
6525 impl ::fbthrift::ExceptionInfo for GetConfigExn {
6526 fn exn_name(&self) -> &'static str {
6527 match self {
6528 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
6529 Self::ApplicationException(aexn) => aexn.exn_name(),
6530 }
6531 }
6532
6533 fn exn_value(&self) -> String {
6534 match self {
6535 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
6536 Self::ApplicationException(aexn) => aexn.exn_value(),
6537 }
6538 }
6539
6540 fn exn_is_declared(&self) -> bool {
6541 match self {
6542 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6543 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6544 }
6545 }
6546 }
6547
6548 impl ::fbthrift::ResultInfo for GetConfigExn {
6549 fn result_type(&self) -> ::fbthrift::ResultType {
6550 match self {
6551 Self::Success(_) => ::fbthrift::ResultType::Return,
6552 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6553 }
6554 }
6555 }
6556
6557 impl ::fbthrift::GetTType for GetConfigExn {
6558 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6559 }
6560
6561 impl<P> ::fbthrift::Serialize<P> for GetConfigExn
6562 where
6563 P: ::fbthrift::ProtocolWriter,
6564 {
6565 fn write(&self, p: &mut P) {
6566 if let Self::ApplicationException(aexn) = self {
6567 return aexn.write(p);
6568 }
6569 p.write_struct_begin("GetConfig");
6570 match self {
6571 Self::Success(inner) => {
6572 p.write_field_begin(
6573 "Success",
6574 ::fbthrift::TType::Struct,
6575 0i16,
6576 );
6577 inner.write(p);
6578 p.write_field_end();
6579 }
6580 Self::ApplicationException(_aexn) => unreachable!(),
6581 }
6582 p.write_field_stop();
6583 p.write_struct_end();
6584 }
6585 }
6586
6587 impl<P> ::fbthrift::Deserialize<P> for GetConfigExn
6588 where
6589 P: ::fbthrift::ProtocolReader,
6590 {
6591 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6592 static RETURNS: &[::fbthrift::Field] = &[
6593 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6594 ];
6595 let _ = p.read_struct_begin(|_| ())?;
6596 let mut once = false;
6597 let mut alt = ::std::option::Option::None;
6598 loop {
6599 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
6600 match ((fty, fid as ::std::primitive::i32), once) {
6601 ((::fbthrift::TType::Stop, _), _) => {
6602 p.read_field_end()?;
6603 break;
6604 }
6605 ((::fbthrift::TType::Struct, 0i32), false) => {
6606 once = true;
6607 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
6608 }
6609 ((ty, _id), false) => p.skip(ty)?,
6610 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
6611 ::fbthrift::ApplicationException::new(
6612 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
6613 format!(
6614 "unwanted extra union {} field ty {:?} id {}",
6615 "GetConfigExn",
6616 badty,
6617 badid,
6618 ),
6619 )
6620 )),
6621 }
6622 p.read_field_end()?;
6623 }
6624 p.read_struct_end()?;
6625 alt.ok_or_else(||
6626 ::fbthrift::ApplicationException::new(
6627 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
6628 format!("Empty union {}", "GetConfigExn"),
6629 )
6630 .into(),
6631 )
6632 }
6633 }
6634
6635 #[derive(Clone, Debug)]
6636 pub enum SetConfigExn {
6637 #[doc(hidden)]
6638 Success(crate::types::ExecResp),
6639 ApplicationException(::fbthrift::ApplicationException),
6640 }
6641
6642 impl ::std::convert::From<crate::errors::meta_service::SetConfigError> for SetConfigExn {
6643 fn from(err: crate::errors::meta_service::SetConfigError) -> Self {
6644 match err {
6645 crate::errors::meta_service::SetConfigError::ApplicationException(aexn) => SetConfigExn::ApplicationException(aexn),
6646 crate::errors::meta_service::SetConfigError::ThriftError(err) => SetConfigExn::ApplicationException(::fbthrift::ApplicationException {
6647 message: err.to_string(),
6648 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
6649 }),
6650 }
6651 }
6652 }
6653
6654 impl ::std::convert::From<::fbthrift::ApplicationException> for SetConfigExn {
6655 fn from(exn: ::fbthrift::ApplicationException) -> Self {
6656 Self::ApplicationException(exn)
6657 }
6658 }
6659
6660 impl ::fbthrift::ExceptionInfo for SetConfigExn {
6661 fn exn_name(&self) -> &'static str {
6662 match self {
6663 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
6664 Self::ApplicationException(aexn) => aexn.exn_name(),
6665 }
6666 }
6667
6668 fn exn_value(&self) -> String {
6669 match self {
6670 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
6671 Self::ApplicationException(aexn) => aexn.exn_value(),
6672 }
6673 }
6674
6675 fn exn_is_declared(&self) -> bool {
6676 match self {
6677 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6678 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6679 }
6680 }
6681 }
6682
6683 impl ::fbthrift::ResultInfo for SetConfigExn {
6684 fn result_type(&self) -> ::fbthrift::ResultType {
6685 match self {
6686 Self::Success(_) => ::fbthrift::ResultType::Return,
6687 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6688 }
6689 }
6690 }
6691
6692 impl ::fbthrift::GetTType for SetConfigExn {
6693 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6694 }
6695
6696 impl<P> ::fbthrift::Serialize<P> for SetConfigExn
6697 where
6698 P: ::fbthrift::ProtocolWriter,
6699 {
6700 fn write(&self, p: &mut P) {
6701 if let Self::ApplicationException(aexn) = self {
6702 return aexn.write(p);
6703 }
6704 p.write_struct_begin("SetConfig");
6705 match self {
6706 Self::Success(inner) => {
6707 p.write_field_begin(
6708 "Success",
6709 ::fbthrift::TType::Struct,
6710 0i16,
6711 );
6712 inner.write(p);
6713 p.write_field_end();
6714 }
6715 Self::ApplicationException(_aexn) => unreachable!(),
6716 }
6717 p.write_field_stop();
6718 p.write_struct_end();
6719 }
6720 }
6721
6722 impl<P> ::fbthrift::Deserialize<P> for SetConfigExn
6723 where
6724 P: ::fbthrift::ProtocolReader,
6725 {
6726 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6727 static RETURNS: &[::fbthrift::Field] = &[
6728 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6729 ];
6730 let _ = p.read_struct_begin(|_| ())?;
6731 let mut once = false;
6732 let mut alt = ::std::option::Option::None;
6733 loop {
6734 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
6735 match ((fty, fid as ::std::primitive::i32), once) {
6736 ((::fbthrift::TType::Stop, _), _) => {
6737 p.read_field_end()?;
6738 break;
6739 }
6740 ((::fbthrift::TType::Struct, 0i32), false) => {
6741 once = true;
6742 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
6743 }
6744 ((ty, _id), false) => p.skip(ty)?,
6745 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
6746 ::fbthrift::ApplicationException::new(
6747 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
6748 format!(
6749 "unwanted extra union {} field ty {:?} id {}",
6750 "SetConfigExn",
6751 badty,
6752 badid,
6753 ),
6754 )
6755 )),
6756 }
6757 p.read_field_end()?;
6758 }
6759 p.read_struct_end()?;
6760 alt.ok_or_else(||
6761 ::fbthrift::ApplicationException::new(
6762 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
6763 format!("Empty union {}", "SetConfigExn"),
6764 )
6765 .into(),
6766 )
6767 }
6768 }
6769
6770 #[derive(Clone, Debug)]
6771 pub enum ListConfigsExn {
6772 #[doc(hidden)]
6773 Success(crate::types::ListConfigsResp),
6774 ApplicationException(::fbthrift::ApplicationException),
6775 }
6776
6777 impl ::std::convert::From<crate::errors::meta_service::ListConfigsError> for ListConfigsExn {
6778 fn from(err: crate::errors::meta_service::ListConfigsError) -> Self {
6779 match err {
6780 crate::errors::meta_service::ListConfigsError::ApplicationException(aexn) => ListConfigsExn::ApplicationException(aexn),
6781 crate::errors::meta_service::ListConfigsError::ThriftError(err) => ListConfigsExn::ApplicationException(::fbthrift::ApplicationException {
6782 message: err.to_string(),
6783 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
6784 }),
6785 }
6786 }
6787 }
6788
6789 impl ::std::convert::From<::fbthrift::ApplicationException> for ListConfigsExn {
6790 fn from(exn: ::fbthrift::ApplicationException) -> Self {
6791 Self::ApplicationException(exn)
6792 }
6793 }
6794
6795 impl ::fbthrift::ExceptionInfo for ListConfigsExn {
6796 fn exn_name(&self) -> &'static str {
6797 match self {
6798 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
6799 Self::ApplicationException(aexn) => aexn.exn_name(),
6800 }
6801 }
6802
6803 fn exn_value(&self) -> String {
6804 match self {
6805 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
6806 Self::ApplicationException(aexn) => aexn.exn_value(),
6807 }
6808 }
6809
6810 fn exn_is_declared(&self) -> bool {
6811 match self {
6812 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6813 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6814 }
6815 }
6816 }
6817
6818 impl ::fbthrift::ResultInfo for ListConfigsExn {
6819 fn result_type(&self) -> ::fbthrift::ResultType {
6820 match self {
6821 Self::Success(_) => ::fbthrift::ResultType::Return,
6822 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6823 }
6824 }
6825 }
6826
6827 impl ::fbthrift::GetTType for ListConfigsExn {
6828 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6829 }
6830
6831 impl<P> ::fbthrift::Serialize<P> for ListConfigsExn
6832 where
6833 P: ::fbthrift::ProtocolWriter,
6834 {
6835 fn write(&self, p: &mut P) {
6836 if let Self::ApplicationException(aexn) = self {
6837 return aexn.write(p);
6838 }
6839 p.write_struct_begin("ListConfigs");
6840 match self {
6841 Self::Success(inner) => {
6842 p.write_field_begin(
6843 "Success",
6844 ::fbthrift::TType::Struct,
6845 0i16,
6846 );
6847 inner.write(p);
6848 p.write_field_end();
6849 }
6850 Self::ApplicationException(_aexn) => unreachable!(),
6851 }
6852 p.write_field_stop();
6853 p.write_struct_end();
6854 }
6855 }
6856
6857 impl<P> ::fbthrift::Deserialize<P> for ListConfigsExn
6858 where
6859 P: ::fbthrift::ProtocolReader,
6860 {
6861 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6862 static RETURNS: &[::fbthrift::Field] = &[
6863 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6864 ];
6865 let _ = p.read_struct_begin(|_| ())?;
6866 let mut once = false;
6867 let mut alt = ::std::option::Option::None;
6868 loop {
6869 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
6870 match ((fty, fid as ::std::primitive::i32), once) {
6871 ((::fbthrift::TType::Stop, _), _) => {
6872 p.read_field_end()?;
6873 break;
6874 }
6875 ((::fbthrift::TType::Struct, 0i32), false) => {
6876 once = true;
6877 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
6878 }
6879 ((ty, _id), false) => p.skip(ty)?,
6880 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
6881 ::fbthrift::ApplicationException::new(
6882 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
6883 format!(
6884 "unwanted extra union {} field ty {:?} id {}",
6885 "ListConfigsExn",
6886 badty,
6887 badid,
6888 ),
6889 )
6890 )),
6891 }
6892 p.read_field_end()?;
6893 }
6894 p.read_struct_end()?;
6895 alt.ok_or_else(||
6896 ::fbthrift::ApplicationException::new(
6897 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
6898 format!("Empty union {}", "ListConfigsExn"),
6899 )
6900 .into(),
6901 )
6902 }
6903 }
6904
6905 #[derive(Clone, Debug)]
6906 pub enum CreateSnapshotExn {
6907 #[doc(hidden)]
6908 Success(crate::types::ExecResp),
6909 ApplicationException(::fbthrift::ApplicationException),
6910 }
6911
6912 impl ::std::convert::From<crate::errors::meta_service::CreateSnapshotError> for CreateSnapshotExn {
6913 fn from(err: crate::errors::meta_service::CreateSnapshotError) -> Self {
6914 match err {
6915 crate::errors::meta_service::CreateSnapshotError::ApplicationException(aexn) => CreateSnapshotExn::ApplicationException(aexn),
6916 crate::errors::meta_service::CreateSnapshotError::ThriftError(err) => CreateSnapshotExn::ApplicationException(::fbthrift::ApplicationException {
6917 message: err.to_string(),
6918 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
6919 }),
6920 }
6921 }
6922 }
6923
6924 impl ::std::convert::From<::fbthrift::ApplicationException> for CreateSnapshotExn {
6925 fn from(exn: ::fbthrift::ApplicationException) -> Self {
6926 Self::ApplicationException(exn)
6927 }
6928 }
6929
6930 impl ::fbthrift::ExceptionInfo for CreateSnapshotExn {
6931 fn exn_name(&self) -> &'static str {
6932 match self {
6933 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
6934 Self::ApplicationException(aexn) => aexn.exn_name(),
6935 }
6936 }
6937
6938 fn exn_value(&self) -> String {
6939 match self {
6940 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
6941 Self::ApplicationException(aexn) => aexn.exn_value(),
6942 }
6943 }
6944
6945 fn exn_is_declared(&self) -> bool {
6946 match self {
6947 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
6948 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
6949 }
6950 }
6951 }
6952
6953 impl ::fbthrift::ResultInfo for CreateSnapshotExn {
6954 fn result_type(&self) -> ::fbthrift::ResultType {
6955 match self {
6956 Self::Success(_) => ::fbthrift::ResultType::Return,
6957 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
6958 }
6959 }
6960 }
6961
6962 impl ::fbthrift::GetTType for CreateSnapshotExn {
6963 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
6964 }
6965
6966 impl<P> ::fbthrift::Serialize<P> for CreateSnapshotExn
6967 where
6968 P: ::fbthrift::ProtocolWriter,
6969 {
6970 fn write(&self, p: &mut P) {
6971 if let Self::ApplicationException(aexn) = self {
6972 return aexn.write(p);
6973 }
6974 p.write_struct_begin("CreateSnapshot");
6975 match self {
6976 Self::Success(inner) => {
6977 p.write_field_begin(
6978 "Success",
6979 ::fbthrift::TType::Struct,
6980 0i16,
6981 );
6982 inner.write(p);
6983 p.write_field_end();
6984 }
6985 Self::ApplicationException(_aexn) => unreachable!(),
6986 }
6987 p.write_field_stop();
6988 p.write_struct_end();
6989 }
6990 }
6991
6992 impl<P> ::fbthrift::Deserialize<P> for CreateSnapshotExn
6993 where
6994 P: ::fbthrift::ProtocolReader,
6995 {
6996 fn read(p: &mut P) -> ::anyhow::Result<Self> {
6997 static RETURNS: &[::fbthrift::Field] = &[
6998 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
6999 ];
7000 let _ = p.read_struct_begin(|_| ())?;
7001 let mut once = false;
7002 let mut alt = ::std::option::Option::None;
7003 loop {
7004 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
7005 match ((fty, fid as ::std::primitive::i32), once) {
7006 ((::fbthrift::TType::Stop, _), _) => {
7007 p.read_field_end()?;
7008 break;
7009 }
7010 ((::fbthrift::TType::Struct, 0i32), false) => {
7011 once = true;
7012 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
7013 }
7014 ((ty, _id), false) => p.skip(ty)?,
7015 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
7016 ::fbthrift::ApplicationException::new(
7017 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
7018 format!(
7019 "unwanted extra union {} field ty {:?} id {}",
7020 "CreateSnapshotExn",
7021 badty,
7022 badid,
7023 ),
7024 )
7025 )),
7026 }
7027 p.read_field_end()?;
7028 }
7029 p.read_struct_end()?;
7030 alt.ok_or_else(||
7031 ::fbthrift::ApplicationException::new(
7032 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
7033 format!("Empty union {}", "CreateSnapshotExn"),
7034 )
7035 .into(),
7036 )
7037 }
7038 }
7039
7040 #[derive(Clone, Debug)]
7041 pub enum DropSnapshotExn {
7042 #[doc(hidden)]
7043 Success(crate::types::ExecResp),
7044 ApplicationException(::fbthrift::ApplicationException),
7045 }
7046
7047 impl ::std::convert::From<crate::errors::meta_service::DropSnapshotError> for DropSnapshotExn {
7048 fn from(err: crate::errors::meta_service::DropSnapshotError) -> Self {
7049 match err {
7050 crate::errors::meta_service::DropSnapshotError::ApplicationException(aexn) => DropSnapshotExn::ApplicationException(aexn),
7051 crate::errors::meta_service::DropSnapshotError::ThriftError(err) => DropSnapshotExn::ApplicationException(::fbthrift::ApplicationException {
7052 message: err.to_string(),
7053 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
7054 }),
7055 }
7056 }
7057 }
7058
7059 impl ::std::convert::From<::fbthrift::ApplicationException> for DropSnapshotExn {
7060 fn from(exn: ::fbthrift::ApplicationException) -> Self {
7061 Self::ApplicationException(exn)
7062 }
7063 }
7064
7065 impl ::fbthrift::ExceptionInfo for DropSnapshotExn {
7066 fn exn_name(&self) -> &'static str {
7067 match self {
7068 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
7069 Self::ApplicationException(aexn) => aexn.exn_name(),
7070 }
7071 }
7072
7073 fn exn_value(&self) -> String {
7074 match self {
7075 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
7076 Self::ApplicationException(aexn) => aexn.exn_value(),
7077 }
7078 }
7079
7080 fn exn_is_declared(&self) -> bool {
7081 match self {
7082 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
7083 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
7084 }
7085 }
7086 }
7087
7088 impl ::fbthrift::ResultInfo for DropSnapshotExn {
7089 fn result_type(&self) -> ::fbthrift::ResultType {
7090 match self {
7091 Self::Success(_) => ::fbthrift::ResultType::Return,
7092 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
7093 }
7094 }
7095 }
7096
7097 impl ::fbthrift::GetTType for DropSnapshotExn {
7098 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
7099 }
7100
7101 impl<P> ::fbthrift::Serialize<P> for DropSnapshotExn
7102 where
7103 P: ::fbthrift::ProtocolWriter,
7104 {
7105 fn write(&self, p: &mut P) {
7106 if let Self::ApplicationException(aexn) = self {
7107 return aexn.write(p);
7108 }
7109 p.write_struct_begin("DropSnapshot");
7110 match self {
7111 Self::Success(inner) => {
7112 p.write_field_begin(
7113 "Success",
7114 ::fbthrift::TType::Struct,
7115 0i16,
7116 );
7117 inner.write(p);
7118 p.write_field_end();
7119 }
7120 Self::ApplicationException(_aexn) => unreachable!(),
7121 }
7122 p.write_field_stop();
7123 p.write_struct_end();
7124 }
7125 }
7126
7127 impl<P> ::fbthrift::Deserialize<P> for DropSnapshotExn
7128 where
7129 P: ::fbthrift::ProtocolReader,
7130 {
7131 fn read(p: &mut P) -> ::anyhow::Result<Self> {
7132 static RETURNS: &[::fbthrift::Field] = &[
7133 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
7134 ];
7135 let _ = p.read_struct_begin(|_| ())?;
7136 let mut once = false;
7137 let mut alt = ::std::option::Option::None;
7138 loop {
7139 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
7140 match ((fty, fid as ::std::primitive::i32), once) {
7141 ((::fbthrift::TType::Stop, _), _) => {
7142 p.read_field_end()?;
7143 break;
7144 }
7145 ((::fbthrift::TType::Struct, 0i32), false) => {
7146 once = true;
7147 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
7148 }
7149 ((ty, _id), false) => p.skip(ty)?,
7150 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
7151 ::fbthrift::ApplicationException::new(
7152 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
7153 format!(
7154 "unwanted extra union {} field ty {:?} id {}",
7155 "DropSnapshotExn",
7156 badty,
7157 badid,
7158 ),
7159 )
7160 )),
7161 }
7162 p.read_field_end()?;
7163 }
7164 p.read_struct_end()?;
7165 alt.ok_or_else(||
7166 ::fbthrift::ApplicationException::new(
7167 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
7168 format!("Empty union {}", "DropSnapshotExn"),
7169 )
7170 .into(),
7171 )
7172 }
7173 }
7174
7175 #[derive(Clone, Debug)]
7176 pub enum ListSnapshotsExn {
7177 #[doc(hidden)]
7178 Success(crate::types::ListSnapshotsResp),
7179 ApplicationException(::fbthrift::ApplicationException),
7180 }
7181
7182 impl ::std::convert::From<crate::errors::meta_service::ListSnapshotsError> for ListSnapshotsExn {
7183 fn from(err: crate::errors::meta_service::ListSnapshotsError) -> Self {
7184 match err {
7185 crate::errors::meta_service::ListSnapshotsError::ApplicationException(aexn) => ListSnapshotsExn::ApplicationException(aexn),
7186 crate::errors::meta_service::ListSnapshotsError::ThriftError(err) => ListSnapshotsExn::ApplicationException(::fbthrift::ApplicationException {
7187 message: err.to_string(),
7188 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
7189 }),
7190 }
7191 }
7192 }
7193
7194 impl ::std::convert::From<::fbthrift::ApplicationException> for ListSnapshotsExn {
7195 fn from(exn: ::fbthrift::ApplicationException) -> Self {
7196 Self::ApplicationException(exn)
7197 }
7198 }
7199
7200 impl ::fbthrift::ExceptionInfo for ListSnapshotsExn {
7201 fn exn_name(&self) -> &'static str {
7202 match self {
7203 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
7204 Self::ApplicationException(aexn) => aexn.exn_name(),
7205 }
7206 }
7207
7208 fn exn_value(&self) -> String {
7209 match self {
7210 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
7211 Self::ApplicationException(aexn) => aexn.exn_value(),
7212 }
7213 }
7214
7215 fn exn_is_declared(&self) -> bool {
7216 match self {
7217 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
7218 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
7219 }
7220 }
7221 }
7222
7223 impl ::fbthrift::ResultInfo for ListSnapshotsExn {
7224 fn result_type(&self) -> ::fbthrift::ResultType {
7225 match self {
7226 Self::Success(_) => ::fbthrift::ResultType::Return,
7227 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
7228 }
7229 }
7230 }
7231
7232 impl ::fbthrift::GetTType for ListSnapshotsExn {
7233 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
7234 }
7235
7236 impl<P> ::fbthrift::Serialize<P> for ListSnapshotsExn
7237 where
7238 P: ::fbthrift::ProtocolWriter,
7239 {
7240 fn write(&self, p: &mut P) {
7241 if let Self::ApplicationException(aexn) = self {
7242 return aexn.write(p);
7243 }
7244 p.write_struct_begin("ListSnapshots");
7245 match self {
7246 Self::Success(inner) => {
7247 p.write_field_begin(
7248 "Success",
7249 ::fbthrift::TType::Struct,
7250 0i16,
7251 );
7252 inner.write(p);
7253 p.write_field_end();
7254 }
7255 Self::ApplicationException(_aexn) => unreachable!(),
7256 }
7257 p.write_field_stop();
7258 p.write_struct_end();
7259 }
7260 }
7261
7262 impl<P> ::fbthrift::Deserialize<P> for ListSnapshotsExn
7263 where
7264 P: ::fbthrift::ProtocolReader,
7265 {
7266 fn read(p: &mut P) -> ::anyhow::Result<Self> {
7267 static RETURNS: &[::fbthrift::Field] = &[
7268 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
7269 ];
7270 let _ = p.read_struct_begin(|_| ())?;
7271 let mut once = false;
7272 let mut alt = ::std::option::Option::None;
7273 loop {
7274 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
7275 match ((fty, fid as ::std::primitive::i32), once) {
7276 ((::fbthrift::TType::Stop, _), _) => {
7277 p.read_field_end()?;
7278 break;
7279 }
7280 ((::fbthrift::TType::Struct, 0i32), false) => {
7281 once = true;
7282 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
7283 }
7284 ((ty, _id), false) => p.skip(ty)?,
7285 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
7286 ::fbthrift::ApplicationException::new(
7287 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
7288 format!(
7289 "unwanted extra union {} field ty {:?} id {}",
7290 "ListSnapshotsExn",
7291 badty,
7292 badid,
7293 ),
7294 )
7295 )),
7296 }
7297 p.read_field_end()?;
7298 }
7299 p.read_struct_end()?;
7300 alt.ok_or_else(||
7301 ::fbthrift::ApplicationException::new(
7302 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
7303 format!("Empty union {}", "ListSnapshotsExn"),
7304 )
7305 .into(),
7306 )
7307 }
7308 }
7309
7310 #[derive(Clone, Debug)]
7311 pub enum RunAdminJobExn {
7312 #[doc(hidden)]
7313 Success(crate::types::AdminJobResp),
7314 ApplicationException(::fbthrift::ApplicationException),
7315 }
7316
7317 impl ::std::convert::From<crate::errors::meta_service::RunAdminJobError> for RunAdminJobExn {
7318 fn from(err: crate::errors::meta_service::RunAdminJobError) -> Self {
7319 match err {
7320 crate::errors::meta_service::RunAdminJobError::ApplicationException(aexn) => RunAdminJobExn::ApplicationException(aexn),
7321 crate::errors::meta_service::RunAdminJobError::ThriftError(err) => RunAdminJobExn::ApplicationException(::fbthrift::ApplicationException {
7322 message: err.to_string(),
7323 type_: ::fbthrift::ApplicationExceptionErrorCode::InternalError,
7324 }),
7325 }
7326 }
7327 }
7328
7329 impl ::std::convert::From<::fbthrift::ApplicationException> for RunAdminJobExn {
7330 fn from(exn: ::fbthrift::ApplicationException) -> Self {
7331 Self::ApplicationException(exn)
7332 }
7333 }
7334
7335 impl ::fbthrift::ExceptionInfo for RunAdminJobExn {
7336 fn exn_name(&self) -> &'static str {
7337 match self {
7338 Self::Success(_) => panic!("ExceptionInfo::exn_name called on Success"),
7339 Self::ApplicationException(aexn) => aexn.exn_name(),
7340 }
7341 }
7342
7343 fn exn_value(&self) -> String {
7344 match self {
7345 Self::Success(_) => panic!("ExceptionInfo::exn_value called on Success"),
7346 Self::ApplicationException(aexn) => aexn.exn_value(),
7347 }
7348 }
7349
7350 fn exn_is_declared(&self) -> bool {
7351 match self {
7352 Self::Success(_) => panic!("ExceptionInfo::exn_is_declared called on Success"),
7353 Self::ApplicationException(aexn) => aexn.exn_is_declared(),
7354 }
7355 }
7356 }
7357
7358 impl ::fbthrift::ResultInfo for RunAdminJobExn {
7359 fn result_type(&self) -> ::fbthrift::ResultType {
7360 match self {
7361 Self::Success(_) => ::fbthrift::ResultType::Return,
7362 Self::ApplicationException(_aexn) => ::fbthrift::ResultType::Exception,
7363 }
7364 }
7365 }
7366
7367 impl ::fbthrift::GetTType for RunAdminJobExn {
7368 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
7369 }
7370
7371 impl<P> ::fbthrift::Serialize<P> for RunAdminJobExn
7372 where
7373 P: ::fbthrift::ProtocolWriter,
7374 {
7375 fn write(&self, p: &mut P) {
7376 if let Self::ApplicationException(aexn) = self {
7377 return aexn.write(p);
7378 }
7379 p.write_struct_begin("RunAdminJob");
7380 match self {
7381 Self::Success(inner) => {
7382 p.write_field_begin(
7383 "Success",
7384 ::fbthrift::TType::Struct,
7385 0i16,
7386 );
7387 inner.write(p);
7388 p.write_field_end();
7389 }
7390 Self::ApplicationException(_aexn) => unreachable!(),
7391 }
7392 p.write_field_stop();
7393 p.write_struct_end();
7394 }
7395 }
7396
7397 impl<P> ::fbthrift::Deserialize<P> for RunAdminJobExn
7398 where
7399 P: ::fbthrift::ProtocolReader,
7400 {
7401 fn read(p: &mut P) -> ::anyhow::Result<Self> {
7402 static RETURNS: &[::fbthrift::Field] = &[
7403 ::fbthrift::Field::new("Success", ::fbthrift::TType::Struct, 0),
7404 ];
7405 let _ = p.read_struct_begin(|_| ())?;
7406 let mut once = false;
7407 let mut alt = ::std::option::Option::None;
7408 loop {
7409 let (_, fty, fid) = p.read_field_begin(|_| (), RETURNS)?;
7410 match ((fty, fid as ::std::primitive::i32), once) {
7411 ((::fbthrift::TType::Stop, _), _) => {
7412 p.read_field_end()?;
7413 break;
7414 }
7415 ((::fbthrift::TType::Struct, 0i32), false) => {
7416 once = true;
7417 alt = ::std::option::Option::Some(Self::Success(::fbthrift::Deserialize::read(p)?));
7418 }
7419 ((ty, _id), false) => p.skip(ty)?,
7420 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
7421 ::fbthrift::ApplicationException::new(
7422 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
7423 format!(
7424 "unwanted extra union {} field ty {:?} id {}",
7425 "RunAdminJobExn",
7426 badty,
7427 badid,
7428 ),
7429 )
7430 )),
7431 }
7432 p.read_field_end()?;
7433 }
7434 p.read_struct_end()?;
7435 alt.ok_or_else(||
7436 ::fbthrift::ApplicationException::new(
7437 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
7438 format!("Empty union {}", "RunAdminJobExn"),
7439 )
7440 .into(),
7441 )
7442 }
7443 }
7444 }
7445}
7446
7447pub mod client {
7449
7450 pub struct MetaServiceImpl<P, T, S = ::fbthrift::NoopSpawner> {
7451 transport: T,
7452 _phantom: ::std::marker::PhantomData<fn() -> (P, S)>,
7453 }
7454
7455 impl<P, T, S> MetaServiceImpl<P, T, S>
7456 where
7457 P: ::fbthrift::Protocol,
7458 T: ::fbthrift::Transport,
7459 P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
7460 ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
7461 P::Deserializer: ::std::marker::Send,
7462 S: ::fbthrift::help::Spawner,
7463 {
7464 pub fn new(
7465 transport: T,
7466 ) -> Self {
7467 Self {
7468 transport,
7469 _phantom: ::std::marker::PhantomData,
7470 }
7471 }
7472
7473 pub fn transport(&self) -> &T {
7474 &self.transport
7475 }
7476
7477
7478 fn _createSpace_impl(
7479 &self,
7480 arg_req: &crate::types::CreateSpaceReq,
7481 rpc_options: T::RpcOptions,
7482 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>> {
7483 use ::const_cstr::const_cstr;
7484 use ::tracing::Instrument as _;
7485 use ::futures::FutureExt as _;
7486
7487 const_cstr! {
7488 SERVICE_NAME = "MetaService";
7489 METHOD_NAME = "MetaService.createSpace";
7490 }
7491 let args = self::Args_MetaService_createSpace {
7492 req: arg_req,
7493 _phantom: ::std::marker::PhantomData,
7494 };
7495
7496 let transport = self.transport();
7497
7498 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("createSpace", &args) {
7500 ::std::result::Result::Ok(res) => res,
7501 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7502 };
7503
7504 let call = transport
7505 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7506 .instrument(::tracing::trace_span!("call", function = "MetaService.createSpace"));
7507
7508 async move {
7509 let reply_env = call.await?;
7510
7511 let de = P::deserializer(reply_env);
7512 let (res, _de): (::std::result::Result<crate::services::meta_service::CreateSpaceExn, _>, _) =
7513 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7514
7515 let res = match res {
7516 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7517 ::std::result::Result::Err(aexn) =>
7518 ::std::result::Result::Err(crate::errors::meta_service::CreateSpaceError::ApplicationException(aexn))
7519 };
7520 res
7521 }
7522 .instrument(::tracing::info_span!("MetaService.createSpace"))
7523 .boxed()
7524 }
7525
7526 fn _dropSpace_impl(
7527 &self,
7528 arg_req: &crate::types::DropSpaceReq,
7529 rpc_options: T::RpcOptions,
7530 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>> {
7531 use ::const_cstr::const_cstr;
7532 use ::tracing::Instrument as _;
7533 use ::futures::FutureExt as _;
7534
7535 const_cstr! {
7536 SERVICE_NAME = "MetaService";
7537 METHOD_NAME = "MetaService.dropSpace";
7538 }
7539 let args = self::Args_MetaService_dropSpace {
7540 req: arg_req,
7541 _phantom: ::std::marker::PhantomData,
7542 };
7543
7544 let transport = self.transport();
7545
7546 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("dropSpace", &args) {
7548 ::std::result::Result::Ok(res) => res,
7549 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7550 };
7551
7552 let call = transport
7553 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7554 .instrument(::tracing::trace_span!("call", function = "MetaService.dropSpace"));
7555
7556 async move {
7557 let reply_env = call.await?;
7558
7559 let de = P::deserializer(reply_env);
7560 let (res, _de): (::std::result::Result<crate::services::meta_service::DropSpaceExn, _>, _) =
7561 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7562
7563 let res = match res {
7564 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7565 ::std::result::Result::Err(aexn) =>
7566 ::std::result::Result::Err(crate::errors::meta_service::DropSpaceError::ApplicationException(aexn))
7567 };
7568 res
7569 }
7570 .instrument(::tracing::info_span!("MetaService.dropSpace"))
7571 .boxed()
7572 }
7573
7574 fn _getSpace_impl(
7575 &self,
7576 arg_req: &crate::types::GetSpaceReq,
7577 rpc_options: T::RpcOptions,
7578 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>> {
7579 use ::const_cstr::const_cstr;
7580 use ::tracing::Instrument as _;
7581 use ::futures::FutureExt as _;
7582
7583 const_cstr! {
7584 SERVICE_NAME = "MetaService";
7585 METHOD_NAME = "MetaService.getSpace";
7586 }
7587 let args = self::Args_MetaService_getSpace {
7588 req: arg_req,
7589 _phantom: ::std::marker::PhantomData,
7590 };
7591
7592 let transport = self.transport();
7593
7594 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getSpace", &args) {
7596 ::std::result::Result::Ok(res) => res,
7597 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7598 };
7599
7600 let call = transport
7601 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7602 .instrument(::tracing::trace_span!("call", function = "MetaService.getSpace"));
7603
7604 async move {
7605 let reply_env = call.await?;
7606
7607 let de = P::deserializer(reply_env);
7608 let (res, _de): (::std::result::Result<crate::services::meta_service::GetSpaceExn, _>, _) =
7609 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7610
7611 let res = match res {
7612 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7613 ::std::result::Result::Err(aexn) =>
7614 ::std::result::Result::Err(crate::errors::meta_service::GetSpaceError::ApplicationException(aexn))
7615 };
7616 res
7617 }
7618 .instrument(::tracing::info_span!("MetaService.getSpace"))
7619 .boxed()
7620 }
7621
7622 fn _listSpaces_impl(
7623 &self,
7624 arg_req: &crate::types::ListSpacesReq,
7625 rpc_options: T::RpcOptions,
7626 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>> {
7627 use ::const_cstr::const_cstr;
7628 use ::tracing::Instrument as _;
7629 use ::futures::FutureExt as _;
7630
7631 const_cstr! {
7632 SERVICE_NAME = "MetaService";
7633 METHOD_NAME = "MetaService.listSpaces";
7634 }
7635 let args = self::Args_MetaService_listSpaces {
7636 req: arg_req,
7637 _phantom: ::std::marker::PhantomData,
7638 };
7639
7640 let transport = self.transport();
7641
7642 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listSpaces", &args) {
7644 ::std::result::Result::Ok(res) => res,
7645 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7646 };
7647
7648 let call = transport
7649 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7650 .instrument(::tracing::trace_span!("call", function = "MetaService.listSpaces"));
7651
7652 async move {
7653 let reply_env = call.await?;
7654
7655 let de = P::deserializer(reply_env);
7656 let (res, _de): (::std::result::Result<crate::services::meta_service::ListSpacesExn, _>, _) =
7657 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7658
7659 let res = match res {
7660 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7661 ::std::result::Result::Err(aexn) =>
7662 ::std::result::Result::Err(crate::errors::meta_service::ListSpacesError::ApplicationException(aexn))
7663 };
7664 res
7665 }
7666 .instrument(::tracing::info_span!("MetaService.listSpaces"))
7667 .boxed()
7668 }
7669
7670 fn _createTag_impl(
7671 &self,
7672 arg_req: &crate::types::CreateTagReq,
7673 rpc_options: T::RpcOptions,
7674 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>> {
7675 use ::const_cstr::const_cstr;
7676 use ::tracing::Instrument as _;
7677 use ::futures::FutureExt as _;
7678
7679 const_cstr! {
7680 SERVICE_NAME = "MetaService";
7681 METHOD_NAME = "MetaService.createTag";
7682 }
7683 let args = self::Args_MetaService_createTag {
7684 req: arg_req,
7685 _phantom: ::std::marker::PhantomData,
7686 };
7687
7688 let transport = self.transport();
7689
7690 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("createTag", &args) {
7692 ::std::result::Result::Ok(res) => res,
7693 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7694 };
7695
7696 let call = transport
7697 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7698 .instrument(::tracing::trace_span!("call", function = "MetaService.createTag"));
7699
7700 async move {
7701 let reply_env = call.await?;
7702
7703 let de = P::deserializer(reply_env);
7704 let (res, _de): (::std::result::Result<crate::services::meta_service::CreateTagExn, _>, _) =
7705 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7706
7707 let res = match res {
7708 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7709 ::std::result::Result::Err(aexn) =>
7710 ::std::result::Result::Err(crate::errors::meta_service::CreateTagError::ApplicationException(aexn))
7711 };
7712 res
7713 }
7714 .instrument(::tracing::info_span!("MetaService.createTag"))
7715 .boxed()
7716 }
7717
7718 fn _alterTag_impl(
7719 &self,
7720 arg_req: &crate::types::AlterTagReq,
7721 rpc_options: T::RpcOptions,
7722 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>> {
7723 use ::const_cstr::const_cstr;
7724 use ::tracing::Instrument as _;
7725 use ::futures::FutureExt as _;
7726
7727 const_cstr! {
7728 SERVICE_NAME = "MetaService";
7729 METHOD_NAME = "MetaService.alterTag";
7730 }
7731 let args = self::Args_MetaService_alterTag {
7732 req: arg_req,
7733 _phantom: ::std::marker::PhantomData,
7734 };
7735
7736 let transport = self.transport();
7737
7738 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("alterTag", &args) {
7740 ::std::result::Result::Ok(res) => res,
7741 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7742 };
7743
7744 let call = transport
7745 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7746 .instrument(::tracing::trace_span!("call", function = "MetaService.alterTag"));
7747
7748 async move {
7749 let reply_env = call.await?;
7750
7751 let de = P::deserializer(reply_env);
7752 let (res, _de): (::std::result::Result<crate::services::meta_service::AlterTagExn, _>, _) =
7753 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7754
7755 let res = match res {
7756 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7757 ::std::result::Result::Err(aexn) =>
7758 ::std::result::Result::Err(crate::errors::meta_service::AlterTagError::ApplicationException(aexn))
7759 };
7760 res
7761 }
7762 .instrument(::tracing::info_span!("MetaService.alterTag"))
7763 .boxed()
7764 }
7765
7766 fn _dropTag_impl(
7767 &self,
7768 arg_req: &crate::types::DropTagReq,
7769 rpc_options: T::RpcOptions,
7770 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>> {
7771 use ::const_cstr::const_cstr;
7772 use ::tracing::Instrument as _;
7773 use ::futures::FutureExt as _;
7774
7775 const_cstr! {
7776 SERVICE_NAME = "MetaService";
7777 METHOD_NAME = "MetaService.dropTag";
7778 }
7779 let args = self::Args_MetaService_dropTag {
7780 req: arg_req,
7781 _phantom: ::std::marker::PhantomData,
7782 };
7783
7784 let transport = self.transport();
7785
7786 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("dropTag", &args) {
7788 ::std::result::Result::Ok(res) => res,
7789 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7790 };
7791
7792 let call = transport
7793 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7794 .instrument(::tracing::trace_span!("call", function = "MetaService.dropTag"));
7795
7796 async move {
7797 let reply_env = call.await?;
7798
7799 let de = P::deserializer(reply_env);
7800 let (res, _de): (::std::result::Result<crate::services::meta_service::DropTagExn, _>, _) =
7801 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7802
7803 let res = match res {
7804 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7805 ::std::result::Result::Err(aexn) =>
7806 ::std::result::Result::Err(crate::errors::meta_service::DropTagError::ApplicationException(aexn))
7807 };
7808 res
7809 }
7810 .instrument(::tracing::info_span!("MetaService.dropTag"))
7811 .boxed()
7812 }
7813
7814 fn _getTag_impl(
7815 &self,
7816 arg_req: &crate::types::GetTagReq,
7817 rpc_options: T::RpcOptions,
7818 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>> {
7819 use ::const_cstr::const_cstr;
7820 use ::tracing::Instrument as _;
7821 use ::futures::FutureExt as _;
7822
7823 const_cstr! {
7824 SERVICE_NAME = "MetaService";
7825 METHOD_NAME = "MetaService.getTag";
7826 }
7827 let args = self::Args_MetaService_getTag {
7828 req: arg_req,
7829 _phantom: ::std::marker::PhantomData,
7830 };
7831
7832 let transport = self.transport();
7833
7834 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getTag", &args) {
7836 ::std::result::Result::Ok(res) => res,
7837 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7838 };
7839
7840 let call = transport
7841 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7842 .instrument(::tracing::trace_span!("call", function = "MetaService.getTag"));
7843
7844 async move {
7845 let reply_env = call.await?;
7846
7847 let de = P::deserializer(reply_env);
7848 let (res, _de): (::std::result::Result<crate::services::meta_service::GetTagExn, _>, _) =
7849 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7850
7851 let res = match res {
7852 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7853 ::std::result::Result::Err(aexn) =>
7854 ::std::result::Result::Err(crate::errors::meta_service::GetTagError::ApplicationException(aexn))
7855 };
7856 res
7857 }
7858 .instrument(::tracing::info_span!("MetaService.getTag"))
7859 .boxed()
7860 }
7861
7862 fn _listTags_impl(
7863 &self,
7864 arg_req: &crate::types::ListTagsReq,
7865 rpc_options: T::RpcOptions,
7866 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>> {
7867 use ::const_cstr::const_cstr;
7868 use ::tracing::Instrument as _;
7869 use ::futures::FutureExt as _;
7870
7871 const_cstr! {
7872 SERVICE_NAME = "MetaService";
7873 METHOD_NAME = "MetaService.listTags";
7874 }
7875 let args = self::Args_MetaService_listTags {
7876 req: arg_req,
7877 _phantom: ::std::marker::PhantomData,
7878 };
7879
7880 let transport = self.transport();
7881
7882 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listTags", &args) {
7884 ::std::result::Result::Ok(res) => res,
7885 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7886 };
7887
7888 let call = transport
7889 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7890 .instrument(::tracing::trace_span!("call", function = "MetaService.listTags"));
7891
7892 async move {
7893 let reply_env = call.await?;
7894
7895 let de = P::deserializer(reply_env);
7896 let (res, _de): (::std::result::Result<crate::services::meta_service::ListTagsExn, _>, _) =
7897 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7898
7899 let res = match res {
7900 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7901 ::std::result::Result::Err(aexn) =>
7902 ::std::result::Result::Err(crate::errors::meta_service::ListTagsError::ApplicationException(aexn))
7903 };
7904 res
7905 }
7906 .instrument(::tracing::info_span!("MetaService.listTags"))
7907 .boxed()
7908 }
7909
7910 fn _createEdge_impl(
7911 &self,
7912 arg_req: &crate::types::CreateEdgeReq,
7913 rpc_options: T::RpcOptions,
7914 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>> {
7915 use ::const_cstr::const_cstr;
7916 use ::tracing::Instrument as _;
7917 use ::futures::FutureExt as _;
7918
7919 const_cstr! {
7920 SERVICE_NAME = "MetaService";
7921 METHOD_NAME = "MetaService.createEdge";
7922 }
7923 let args = self::Args_MetaService_createEdge {
7924 req: arg_req,
7925 _phantom: ::std::marker::PhantomData,
7926 };
7927
7928 let transport = self.transport();
7929
7930 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("createEdge", &args) {
7932 ::std::result::Result::Ok(res) => res,
7933 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7934 };
7935
7936 let call = transport
7937 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7938 .instrument(::tracing::trace_span!("call", function = "MetaService.createEdge"));
7939
7940 async move {
7941 let reply_env = call.await?;
7942
7943 let de = P::deserializer(reply_env);
7944 let (res, _de): (::std::result::Result<crate::services::meta_service::CreateEdgeExn, _>, _) =
7945 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7946
7947 let res = match res {
7948 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7949 ::std::result::Result::Err(aexn) =>
7950 ::std::result::Result::Err(crate::errors::meta_service::CreateEdgeError::ApplicationException(aexn))
7951 };
7952 res
7953 }
7954 .instrument(::tracing::info_span!("MetaService.createEdge"))
7955 .boxed()
7956 }
7957
7958 fn _alterEdge_impl(
7959 &self,
7960 arg_req: &crate::types::AlterEdgeReq,
7961 rpc_options: T::RpcOptions,
7962 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>> {
7963 use ::const_cstr::const_cstr;
7964 use ::tracing::Instrument as _;
7965 use ::futures::FutureExt as _;
7966
7967 const_cstr! {
7968 SERVICE_NAME = "MetaService";
7969 METHOD_NAME = "MetaService.alterEdge";
7970 }
7971 let args = self::Args_MetaService_alterEdge {
7972 req: arg_req,
7973 _phantom: ::std::marker::PhantomData,
7974 };
7975
7976 let transport = self.transport();
7977
7978 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("alterEdge", &args) {
7980 ::std::result::Result::Ok(res) => res,
7981 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
7982 };
7983
7984 let call = transport
7985 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
7986 .instrument(::tracing::trace_span!("call", function = "MetaService.alterEdge"));
7987
7988 async move {
7989 let reply_env = call.await?;
7990
7991 let de = P::deserializer(reply_env);
7992 let (res, _de): (::std::result::Result<crate::services::meta_service::AlterEdgeExn, _>, _) =
7993 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
7994
7995 let res = match res {
7996 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
7997 ::std::result::Result::Err(aexn) =>
7998 ::std::result::Result::Err(crate::errors::meta_service::AlterEdgeError::ApplicationException(aexn))
7999 };
8000 res
8001 }
8002 .instrument(::tracing::info_span!("MetaService.alterEdge"))
8003 .boxed()
8004 }
8005
8006 fn _dropEdge_impl(
8007 &self,
8008 arg_req: &crate::types::DropEdgeReq,
8009 rpc_options: T::RpcOptions,
8010 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>> {
8011 use ::const_cstr::const_cstr;
8012 use ::tracing::Instrument as _;
8013 use ::futures::FutureExt as _;
8014
8015 const_cstr! {
8016 SERVICE_NAME = "MetaService";
8017 METHOD_NAME = "MetaService.dropEdge";
8018 }
8019 let args = self::Args_MetaService_dropEdge {
8020 req: arg_req,
8021 _phantom: ::std::marker::PhantomData,
8022 };
8023
8024 let transport = self.transport();
8025
8026 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("dropEdge", &args) {
8028 ::std::result::Result::Ok(res) => res,
8029 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8030 };
8031
8032 let call = transport
8033 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8034 .instrument(::tracing::trace_span!("call", function = "MetaService.dropEdge"));
8035
8036 async move {
8037 let reply_env = call.await?;
8038
8039 let de = P::deserializer(reply_env);
8040 let (res, _de): (::std::result::Result<crate::services::meta_service::DropEdgeExn, _>, _) =
8041 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8042
8043 let res = match res {
8044 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8045 ::std::result::Result::Err(aexn) =>
8046 ::std::result::Result::Err(crate::errors::meta_service::DropEdgeError::ApplicationException(aexn))
8047 };
8048 res
8049 }
8050 .instrument(::tracing::info_span!("MetaService.dropEdge"))
8051 .boxed()
8052 }
8053
8054 fn _getEdge_impl(
8055 &self,
8056 arg_req: &crate::types::GetEdgeReq,
8057 rpc_options: T::RpcOptions,
8058 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>> {
8059 use ::const_cstr::const_cstr;
8060 use ::tracing::Instrument as _;
8061 use ::futures::FutureExt as _;
8062
8063 const_cstr! {
8064 SERVICE_NAME = "MetaService";
8065 METHOD_NAME = "MetaService.getEdge";
8066 }
8067 let args = self::Args_MetaService_getEdge {
8068 req: arg_req,
8069 _phantom: ::std::marker::PhantomData,
8070 };
8071
8072 let transport = self.transport();
8073
8074 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getEdge", &args) {
8076 ::std::result::Result::Ok(res) => res,
8077 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8078 };
8079
8080 let call = transport
8081 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8082 .instrument(::tracing::trace_span!("call", function = "MetaService.getEdge"));
8083
8084 async move {
8085 let reply_env = call.await?;
8086
8087 let de = P::deserializer(reply_env);
8088 let (res, _de): (::std::result::Result<crate::services::meta_service::GetEdgeExn, _>, _) =
8089 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8090
8091 let res = match res {
8092 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8093 ::std::result::Result::Err(aexn) =>
8094 ::std::result::Result::Err(crate::errors::meta_service::GetEdgeError::ApplicationException(aexn))
8095 };
8096 res
8097 }
8098 .instrument(::tracing::info_span!("MetaService.getEdge"))
8099 .boxed()
8100 }
8101
8102 fn _listEdges_impl(
8103 &self,
8104 arg_req: &crate::types::ListEdgesReq,
8105 rpc_options: T::RpcOptions,
8106 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>> {
8107 use ::const_cstr::const_cstr;
8108 use ::tracing::Instrument as _;
8109 use ::futures::FutureExt as _;
8110
8111 const_cstr! {
8112 SERVICE_NAME = "MetaService";
8113 METHOD_NAME = "MetaService.listEdges";
8114 }
8115 let args = self::Args_MetaService_listEdges {
8116 req: arg_req,
8117 _phantom: ::std::marker::PhantomData,
8118 };
8119
8120 let transport = self.transport();
8121
8122 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listEdges", &args) {
8124 ::std::result::Result::Ok(res) => res,
8125 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8126 };
8127
8128 let call = transport
8129 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8130 .instrument(::tracing::trace_span!("call", function = "MetaService.listEdges"));
8131
8132 async move {
8133 let reply_env = call.await?;
8134
8135 let de = P::deserializer(reply_env);
8136 let (res, _de): (::std::result::Result<crate::services::meta_service::ListEdgesExn, _>, _) =
8137 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8138
8139 let res = match res {
8140 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8141 ::std::result::Result::Err(aexn) =>
8142 ::std::result::Result::Err(crate::errors::meta_service::ListEdgesError::ApplicationException(aexn))
8143 };
8144 res
8145 }
8146 .instrument(::tracing::info_span!("MetaService.listEdges"))
8147 .boxed()
8148 }
8149
8150 fn _listHosts_impl(
8151 &self,
8152 arg_req: &crate::types::ListHostsReq,
8153 rpc_options: T::RpcOptions,
8154 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>> {
8155 use ::const_cstr::const_cstr;
8156 use ::tracing::Instrument as _;
8157 use ::futures::FutureExt as _;
8158
8159 const_cstr! {
8160 SERVICE_NAME = "MetaService";
8161 METHOD_NAME = "MetaService.listHosts";
8162 }
8163 let args = self::Args_MetaService_listHosts {
8164 req: arg_req,
8165 _phantom: ::std::marker::PhantomData,
8166 };
8167
8168 let transport = self.transport();
8169
8170 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listHosts", &args) {
8172 ::std::result::Result::Ok(res) => res,
8173 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8174 };
8175
8176 let call = transport
8177 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8178 .instrument(::tracing::trace_span!("call", function = "MetaService.listHosts"));
8179
8180 async move {
8181 let reply_env = call.await?;
8182
8183 let de = P::deserializer(reply_env);
8184 let (res, _de): (::std::result::Result<crate::services::meta_service::ListHostsExn, _>, _) =
8185 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8186
8187 let res = match res {
8188 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8189 ::std::result::Result::Err(aexn) =>
8190 ::std::result::Result::Err(crate::errors::meta_service::ListHostsError::ApplicationException(aexn))
8191 };
8192 res
8193 }
8194 .instrument(::tracing::info_span!("MetaService.listHosts"))
8195 .boxed()
8196 }
8197
8198 fn _getPartsAlloc_impl(
8199 &self,
8200 arg_req: &crate::types::GetPartsAllocReq,
8201 rpc_options: T::RpcOptions,
8202 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>> {
8203 use ::const_cstr::const_cstr;
8204 use ::tracing::Instrument as _;
8205 use ::futures::FutureExt as _;
8206
8207 const_cstr! {
8208 SERVICE_NAME = "MetaService";
8209 METHOD_NAME = "MetaService.getPartsAlloc";
8210 }
8211 let args = self::Args_MetaService_getPartsAlloc {
8212 req: arg_req,
8213 _phantom: ::std::marker::PhantomData,
8214 };
8215
8216 let transport = self.transport();
8217
8218 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getPartsAlloc", &args) {
8220 ::std::result::Result::Ok(res) => res,
8221 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8222 };
8223
8224 let call = transport
8225 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8226 .instrument(::tracing::trace_span!("call", function = "MetaService.getPartsAlloc"));
8227
8228 async move {
8229 let reply_env = call.await?;
8230
8231 let de = P::deserializer(reply_env);
8232 let (res, _de): (::std::result::Result<crate::services::meta_service::GetPartsAllocExn, _>, _) =
8233 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8234
8235 let res = match res {
8236 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8237 ::std::result::Result::Err(aexn) =>
8238 ::std::result::Result::Err(crate::errors::meta_service::GetPartsAllocError::ApplicationException(aexn))
8239 };
8240 res
8241 }
8242 .instrument(::tracing::info_span!("MetaService.getPartsAlloc"))
8243 .boxed()
8244 }
8245
8246 fn _listParts_impl(
8247 &self,
8248 arg_req: &crate::types::ListPartsReq,
8249 rpc_options: T::RpcOptions,
8250 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>> {
8251 use ::const_cstr::const_cstr;
8252 use ::tracing::Instrument as _;
8253 use ::futures::FutureExt as _;
8254
8255 const_cstr! {
8256 SERVICE_NAME = "MetaService";
8257 METHOD_NAME = "MetaService.listParts";
8258 }
8259 let args = self::Args_MetaService_listParts {
8260 req: arg_req,
8261 _phantom: ::std::marker::PhantomData,
8262 };
8263
8264 let transport = self.transport();
8265
8266 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listParts", &args) {
8268 ::std::result::Result::Ok(res) => res,
8269 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8270 };
8271
8272 let call = transport
8273 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8274 .instrument(::tracing::trace_span!("call", function = "MetaService.listParts"));
8275
8276 async move {
8277 let reply_env = call.await?;
8278
8279 let de = P::deserializer(reply_env);
8280 let (res, _de): (::std::result::Result<crate::services::meta_service::ListPartsExn, _>, _) =
8281 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8282
8283 let res = match res {
8284 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8285 ::std::result::Result::Err(aexn) =>
8286 ::std::result::Result::Err(crate::errors::meta_service::ListPartsError::ApplicationException(aexn))
8287 };
8288 res
8289 }
8290 .instrument(::tracing::info_span!("MetaService.listParts"))
8291 .boxed()
8292 }
8293
8294 fn _multiPut_impl(
8295 &self,
8296 arg_req: &crate::types::MultiPutReq,
8297 rpc_options: T::RpcOptions,
8298 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>> {
8299 use ::const_cstr::const_cstr;
8300 use ::tracing::Instrument as _;
8301 use ::futures::FutureExt as _;
8302
8303 const_cstr! {
8304 SERVICE_NAME = "MetaService";
8305 METHOD_NAME = "MetaService.multiPut";
8306 }
8307 let args = self::Args_MetaService_multiPut {
8308 req: arg_req,
8309 _phantom: ::std::marker::PhantomData,
8310 };
8311
8312 let transport = self.transport();
8313
8314 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("multiPut", &args) {
8316 ::std::result::Result::Ok(res) => res,
8317 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8318 };
8319
8320 let call = transport
8321 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8322 .instrument(::tracing::trace_span!("call", function = "MetaService.multiPut"));
8323
8324 async move {
8325 let reply_env = call.await?;
8326
8327 let de = P::deserializer(reply_env);
8328 let (res, _de): (::std::result::Result<crate::services::meta_service::MultiPutExn, _>, _) =
8329 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8330
8331 let res = match res {
8332 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8333 ::std::result::Result::Err(aexn) =>
8334 ::std::result::Result::Err(crate::errors::meta_service::MultiPutError::ApplicationException(aexn))
8335 };
8336 res
8337 }
8338 .instrument(::tracing::info_span!("MetaService.multiPut"))
8339 .boxed()
8340 }
8341
8342 fn _get_impl(
8343 &self,
8344 arg_req: &crate::types::GetReq,
8345 rpc_options: T::RpcOptions,
8346 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>> {
8347 use ::const_cstr::const_cstr;
8348 use ::tracing::Instrument as _;
8349 use ::futures::FutureExt as _;
8350
8351 const_cstr! {
8352 SERVICE_NAME = "MetaService";
8353 METHOD_NAME = "MetaService.get";
8354 }
8355 let args = self::Args_MetaService_get {
8356 req: arg_req,
8357 _phantom: ::std::marker::PhantomData,
8358 };
8359
8360 let transport = self.transport();
8361
8362 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("get", &args) {
8364 ::std::result::Result::Ok(res) => res,
8365 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8366 };
8367
8368 let call = transport
8369 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8370 .instrument(::tracing::trace_span!("call", function = "MetaService.get"));
8371
8372 async move {
8373 let reply_env = call.await?;
8374
8375 let de = P::deserializer(reply_env);
8376 let (res, _de): (::std::result::Result<crate::services::meta_service::GetExn, _>, _) =
8377 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8378
8379 let res = match res {
8380 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8381 ::std::result::Result::Err(aexn) =>
8382 ::std::result::Result::Err(crate::errors::meta_service::GetError::ApplicationException(aexn))
8383 };
8384 res
8385 }
8386 .instrument(::tracing::info_span!("MetaService.get"))
8387 .boxed()
8388 }
8389
8390 fn _multiGet_impl(
8391 &self,
8392 arg_req: &crate::types::MultiGetReq,
8393 rpc_options: T::RpcOptions,
8394 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>> {
8395 use ::const_cstr::const_cstr;
8396 use ::tracing::Instrument as _;
8397 use ::futures::FutureExt as _;
8398
8399 const_cstr! {
8400 SERVICE_NAME = "MetaService";
8401 METHOD_NAME = "MetaService.multiGet";
8402 }
8403 let args = self::Args_MetaService_multiGet {
8404 req: arg_req,
8405 _phantom: ::std::marker::PhantomData,
8406 };
8407
8408 let transport = self.transport();
8409
8410 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("multiGet", &args) {
8412 ::std::result::Result::Ok(res) => res,
8413 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8414 };
8415
8416 let call = transport
8417 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8418 .instrument(::tracing::trace_span!("call", function = "MetaService.multiGet"));
8419
8420 async move {
8421 let reply_env = call.await?;
8422
8423 let de = P::deserializer(reply_env);
8424 let (res, _de): (::std::result::Result<crate::services::meta_service::MultiGetExn, _>, _) =
8425 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8426
8427 let res = match res {
8428 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8429 ::std::result::Result::Err(aexn) =>
8430 ::std::result::Result::Err(crate::errors::meta_service::MultiGetError::ApplicationException(aexn))
8431 };
8432 res
8433 }
8434 .instrument(::tracing::info_span!("MetaService.multiGet"))
8435 .boxed()
8436 }
8437
8438 fn _remove_impl(
8439 &self,
8440 arg_req: &crate::types::RemoveReq,
8441 rpc_options: T::RpcOptions,
8442 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>> {
8443 use ::const_cstr::const_cstr;
8444 use ::tracing::Instrument as _;
8445 use ::futures::FutureExt as _;
8446
8447 const_cstr! {
8448 SERVICE_NAME = "MetaService";
8449 METHOD_NAME = "MetaService.remove";
8450 }
8451 let args = self::Args_MetaService_remove {
8452 req: arg_req,
8453 _phantom: ::std::marker::PhantomData,
8454 };
8455
8456 let transport = self.transport();
8457
8458 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("remove", &args) {
8460 ::std::result::Result::Ok(res) => res,
8461 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8462 };
8463
8464 let call = transport
8465 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8466 .instrument(::tracing::trace_span!("call", function = "MetaService.remove"));
8467
8468 async move {
8469 let reply_env = call.await?;
8470
8471 let de = P::deserializer(reply_env);
8472 let (res, _de): (::std::result::Result<crate::services::meta_service::RemoveExn, _>, _) =
8473 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8474
8475 let res = match res {
8476 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8477 ::std::result::Result::Err(aexn) =>
8478 ::std::result::Result::Err(crate::errors::meta_service::RemoveError::ApplicationException(aexn))
8479 };
8480 res
8481 }
8482 .instrument(::tracing::info_span!("MetaService.remove"))
8483 .boxed()
8484 }
8485
8486 fn _removeRange_impl(
8487 &self,
8488 arg_req: &crate::types::RemoveRangeReq,
8489 rpc_options: T::RpcOptions,
8490 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>> {
8491 use ::const_cstr::const_cstr;
8492 use ::tracing::Instrument as _;
8493 use ::futures::FutureExt as _;
8494
8495 const_cstr! {
8496 SERVICE_NAME = "MetaService";
8497 METHOD_NAME = "MetaService.removeRange";
8498 }
8499 let args = self::Args_MetaService_removeRange {
8500 req: arg_req,
8501 _phantom: ::std::marker::PhantomData,
8502 };
8503
8504 let transport = self.transport();
8505
8506 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("removeRange", &args) {
8508 ::std::result::Result::Ok(res) => res,
8509 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8510 };
8511
8512 let call = transport
8513 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8514 .instrument(::tracing::trace_span!("call", function = "MetaService.removeRange"));
8515
8516 async move {
8517 let reply_env = call.await?;
8518
8519 let de = P::deserializer(reply_env);
8520 let (res, _de): (::std::result::Result<crate::services::meta_service::RemoveRangeExn, _>, _) =
8521 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8522
8523 let res = match res {
8524 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8525 ::std::result::Result::Err(aexn) =>
8526 ::std::result::Result::Err(crate::errors::meta_service::RemoveRangeError::ApplicationException(aexn))
8527 };
8528 res
8529 }
8530 .instrument(::tracing::info_span!("MetaService.removeRange"))
8531 .boxed()
8532 }
8533
8534 fn _scan_impl(
8535 &self,
8536 arg_req: &crate::types::ScanReq,
8537 rpc_options: T::RpcOptions,
8538 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>> {
8539 use ::const_cstr::const_cstr;
8540 use ::tracing::Instrument as _;
8541 use ::futures::FutureExt as _;
8542
8543 const_cstr! {
8544 SERVICE_NAME = "MetaService";
8545 METHOD_NAME = "MetaService.scan";
8546 }
8547 let args = self::Args_MetaService_scan {
8548 req: arg_req,
8549 _phantom: ::std::marker::PhantomData,
8550 };
8551
8552 let transport = self.transport();
8553
8554 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("scan", &args) {
8556 ::std::result::Result::Ok(res) => res,
8557 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8558 };
8559
8560 let call = transport
8561 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8562 .instrument(::tracing::trace_span!("call", function = "MetaService.scan"));
8563
8564 async move {
8565 let reply_env = call.await?;
8566
8567 let de = P::deserializer(reply_env);
8568 let (res, _de): (::std::result::Result<crate::services::meta_service::ScanExn, _>, _) =
8569 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8570
8571 let res = match res {
8572 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8573 ::std::result::Result::Err(aexn) =>
8574 ::std::result::Result::Err(crate::errors::meta_service::ScanError::ApplicationException(aexn))
8575 };
8576 res
8577 }
8578 .instrument(::tracing::info_span!("MetaService.scan"))
8579 .boxed()
8580 }
8581
8582 fn _createTagIndex_impl(
8583 &self,
8584 arg_req: &crate::types::CreateTagIndexReq,
8585 rpc_options: T::RpcOptions,
8586 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>> {
8587 use ::const_cstr::const_cstr;
8588 use ::tracing::Instrument as _;
8589 use ::futures::FutureExt as _;
8590
8591 const_cstr! {
8592 SERVICE_NAME = "MetaService";
8593 METHOD_NAME = "MetaService.createTagIndex";
8594 }
8595 let args = self::Args_MetaService_createTagIndex {
8596 req: arg_req,
8597 _phantom: ::std::marker::PhantomData,
8598 };
8599
8600 let transport = self.transport();
8601
8602 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("createTagIndex", &args) {
8604 ::std::result::Result::Ok(res) => res,
8605 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8606 };
8607
8608 let call = transport
8609 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8610 .instrument(::tracing::trace_span!("call", function = "MetaService.createTagIndex"));
8611
8612 async move {
8613 let reply_env = call.await?;
8614
8615 let de = P::deserializer(reply_env);
8616 let (res, _de): (::std::result::Result<crate::services::meta_service::CreateTagIndexExn, _>, _) =
8617 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8618
8619 let res = match res {
8620 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8621 ::std::result::Result::Err(aexn) =>
8622 ::std::result::Result::Err(crate::errors::meta_service::CreateTagIndexError::ApplicationException(aexn))
8623 };
8624 res
8625 }
8626 .instrument(::tracing::info_span!("MetaService.createTagIndex"))
8627 .boxed()
8628 }
8629
8630 fn _dropTagIndex_impl(
8631 &self,
8632 arg_req: &crate::types::DropTagIndexReq,
8633 rpc_options: T::RpcOptions,
8634 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>> {
8635 use ::const_cstr::const_cstr;
8636 use ::tracing::Instrument as _;
8637 use ::futures::FutureExt as _;
8638
8639 const_cstr! {
8640 SERVICE_NAME = "MetaService";
8641 METHOD_NAME = "MetaService.dropTagIndex";
8642 }
8643 let args = self::Args_MetaService_dropTagIndex {
8644 req: arg_req,
8645 _phantom: ::std::marker::PhantomData,
8646 };
8647
8648 let transport = self.transport();
8649
8650 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("dropTagIndex", &args) {
8652 ::std::result::Result::Ok(res) => res,
8653 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8654 };
8655
8656 let call = transport
8657 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8658 .instrument(::tracing::trace_span!("call", function = "MetaService.dropTagIndex"));
8659
8660 async move {
8661 let reply_env = call.await?;
8662
8663 let de = P::deserializer(reply_env);
8664 let (res, _de): (::std::result::Result<crate::services::meta_service::DropTagIndexExn, _>, _) =
8665 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8666
8667 let res = match res {
8668 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8669 ::std::result::Result::Err(aexn) =>
8670 ::std::result::Result::Err(crate::errors::meta_service::DropTagIndexError::ApplicationException(aexn))
8671 };
8672 res
8673 }
8674 .instrument(::tracing::info_span!("MetaService.dropTagIndex"))
8675 .boxed()
8676 }
8677
8678 fn _getTagIndex_impl(
8679 &self,
8680 arg_req: &crate::types::GetTagIndexReq,
8681 rpc_options: T::RpcOptions,
8682 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>> {
8683 use ::const_cstr::const_cstr;
8684 use ::tracing::Instrument as _;
8685 use ::futures::FutureExt as _;
8686
8687 const_cstr! {
8688 SERVICE_NAME = "MetaService";
8689 METHOD_NAME = "MetaService.getTagIndex";
8690 }
8691 let args = self::Args_MetaService_getTagIndex {
8692 req: arg_req,
8693 _phantom: ::std::marker::PhantomData,
8694 };
8695
8696 let transport = self.transport();
8697
8698 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getTagIndex", &args) {
8700 ::std::result::Result::Ok(res) => res,
8701 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8702 };
8703
8704 let call = transport
8705 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8706 .instrument(::tracing::trace_span!("call", function = "MetaService.getTagIndex"));
8707
8708 async move {
8709 let reply_env = call.await?;
8710
8711 let de = P::deserializer(reply_env);
8712 let (res, _de): (::std::result::Result<crate::services::meta_service::GetTagIndexExn, _>, _) =
8713 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8714
8715 let res = match res {
8716 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8717 ::std::result::Result::Err(aexn) =>
8718 ::std::result::Result::Err(crate::errors::meta_service::GetTagIndexError::ApplicationException(aexn))
8719 };
8720 res
8721 }
8722 .instrument(::tracing::info_span!("MetaService.getTagIndex"))
8723 .boxed()
8724 }
8725
8726 fn _listTagIndexes_impl(
8727 &self,
8728 arg_req: &crate::types::ListTagIndexesReq,
8729 rpc_options: T::RpcOptions,
8730 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>> {
8731 use ::const_cstr::const_cstr;
8732 use ::tracing::Instrument as _;
8733 use ::futures::FutureExt as _;
8734
8735 const_cstr! {
8736 SERVICE_NAME = "MetaService";
8737 METHOD_NAME = "MetaService.listTagIndexes";
8738 }
8739 let args = self::Args_MetaService_listTagIndexes {
8740 req: arg_req,
8741 _phantom: ::std::marker::PhantomData,
8742 };
8743
8744 let transport = self.transport();
8745
8746 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listTagIndexes", &args) {
8748 ::std::result::Result::Ok(res) => res,
8749 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8750 };
8751
8752 let call = transport
8753 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8754 .instrument(::tracing::trace_span!("call", function = "MetaService.listTagIndexes"));
8755
8756 async move {
8757 let reply_env = call.await?;
8758
8759 let de = P::deserializer(reply_env);
8760 let (res, _de): (::std::result::Result<crate::services::meta_service::ListTagIndexesExn, _>, _) =
8761 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8762
8763 let res = match res {
8764 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8765 ::std::result::Result::Err(aexn) =>
8766 ::std::result::Result::Err(crate::errors::meta_service::ListTagIndexesError::ApplicationException(aexn))
8767 };
8768 res
8769 }
8770 .instrument(::tracing::info_span!("MetaService.listTagIndexes"))
8771 .boxed()
8772 }
8773
8774 fn _rebuildTagIndex_impl(
8775 &self,
8776 arg_req: &crate::types::RebuildIndexReq,
8777 rpc_options: T::RpcOptions,
8778 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>> {
8779 use ::const_cstr::const_cstr;
8780 use ::tracing::Instrument as _;
8781 use ::futures::FutureExt as _;
8782
8783 const_cstr! {
8784 SERVICE_NAME = "MetaService";
8785 METHOD_NAME = "MetaService.rebuildTagIndex";
8786 }
8787 let args = self::Args_MetaService_rebuildTagIndex {
8788 req: arg_req,
8789 _phantom: ::std::marker::PhantomData,
8790 };
8791
8792 let transport = self.transport();
8793
8794 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("rebuildTagIndex", &args) {
8796 ::std::result::Result::Ok(res) => res,
8797 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8798 };
8799
8800 let call = transport
8801 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8802 .instrument(::tracing::trace_span!("call", function = "MetaService.rebuildTagIndex"));
8803
8804 async move {
8805 let reply_env = call.await?;
8806
8807 let de = P::deserializer(reply_env);
8808 let (res, _de): (::std::result::Result<crate::services::meta_service::RebuildTagIndexExn, _>, _) =
8809 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8810
8811 let res = match res {
8812 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8813 ::std::result::Result::Err(aexn) =>
8814 ::std::result::Result::Err(crate::errors::meta_service::RebuildTagIndexError::ApplicationException(aexn))
8815 };
8816 res
8817 }
8818 .instrument(::tracing::info_span!("MetaService.rebuildTagIndex"))
8819 .boxed()
8820 }
8821
8822 fn _listTagIndexStatus_impl(
8823 &self,
8824 arg_req: &crate::types::ListIndexStatusReq,
8825 rpc_options: T::RpcOptions,
8826 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>> {
8827 use ::const_cstr::const_cstr;
8828 use ::tracing::Instrument as _;
8829 use ::futures::FutureExt as _;
8830
8831 const_cstr! {
8832 SERVICE_NAME = "MetaService";
8833 METHOD_NAME = "MetaService.listTagIndexStatus";
8834 }
8835 let args = self::Args_MetaService_listTagIndexStatus {
8836 req: arg_req,
8837 _phantom: ::std::marker::PhantomData,
8838 };
8839
8840 let transport = self.transport();
8841
8842 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listTagIndexStatus", &args) {
8844 ::std::result::Result::Ok(res) => res,
8845 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8846 };
8847
8848 let call = transport
8849 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8850 .instrument(::tracing::trace_span!("call", function = "MetaService.listTagIndexStatus"));
8851
8852 async move {
8853 let reply_env = call.await?;
8854
8855 let de = P::deserializer(reply_env);
8856 let (res, _de): (::std::result::Result<crate::services::meta_service::ListTagIndexStatusExn, _>, _) =
8857 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8858
8859 let res = match res {
8860 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8861 ::std::result::Result::Err(aexn) =>
8862 ::std::result::Result::Err(crate::errors::meta_service::ListTagIndexStatusError::ApplicationException(aexn))
8863 };
8864 res
8865 }
8866 .instrument(::tracing::info_span!("MetaService.listTagIndexStatus"))
8867 .boxed()
8868 }
8869
8870 fn _createEdgeIndex_impl(
8871 &self,
8872 arg_req: &crate::types::CreateEdgeIndexReq,
8873 rpc_options: T::RpcOptions,
8874 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>> {
8875 use ::const_cstr::const_cstr;
8876 use ::tracing::Instrument as _;
8877 use ::futures::FutureExt as _;
8878
8879 const_cstr! {
8880 SERVICE_NAME = "MetaService";
8881 METHOD_NAME = "MetaService.createEdgeIndex";
8882 }
8883 let args = self::Args_MetaService_createEdgeIndex {
8884 req: arg_req,
8885 _phantom: ::std::marker::PhantomData,
8886 };
8887
8888 let transport = self.transport();
8889
8890 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("createEdgeIndex", &args) {
8892 ::std::result::Result::Ok(res) => res,
8893 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8894 };
8895
8896 let call = transport
8897 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8898 .instrument(::tracing::trace_span!("call", function = "MetaService.createEdgeIndex"));
8899
8900 async move {
8901 let reply_env = call.await?;
8902
8903 let de = P::deserializer(reply_env);
8904 let (res, _de): (::std::result::Result<crate::services::meta_service::CreateEdgeIndexExn, _>, _) =
8905 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8906
8907 let res = match res {
8908 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8909 ::std::result::Result::Err(aexn) =>
8910 ::std::result::Result::Err(crate::errors::meta_service::CreateEdgeIndexError::ApplicationException(aexn))
8911 };
8912 res
8913 }
8914 .instrument(::tracing::info_span!("MetaService.createEdgeIndex"))
8915 .boxed()
8916 }
8917
8918 fn _dropEdgeIndex_impl(
8919 &self,
8920 arg_req: &crate::types::DropEdgeIndexReq,
8921 rpc_options: T::RpcOptions,
8922 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>> {
8923 use ::const_cstr::const_cstr;
8924 use ::tracing::Instrument as _;
8925 use ::futures::FutureExt as _;
8926
8927 const_cstr! {
8928 SERVICE_NAME = "MetaService";
8929 METHOD_NAME = "MetaService.dropEdgeIndex";
8930 }
8931 let args = self::Args_MetaService_dropEdgeIndex {
8932 req: arg_req,
8933 _phantom: ::std::marker::PhantomData,
8934 };
8935
8936 let transport = self.transport();
8937
8938 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("dropEdgeIndex", &args) {
8940 ::std::result::Result::Ok(res) => res,
8941 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8942 };
8943
8944 let call = transport
8945 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8946 .instrument(::tracing::trace_span!("call", function = "MetaService.dropEdgeIndex"));
8947
8948 async move {
8949 let reply_env = call.await?;
8950
8951 let de = P::deserializer(reply_env);
8952 let (res, _de): (::std::result::Result<crate::services::meta_service::DropEdgeIndexExn, _>, _) =
8953 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
8954
8955 let res = match res {
8956 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
8957 ::std::result::Result::Err(aexn) =>
8958 ::std::result::Result::Err(crate::errors::meta_service::DropEdgeIndexError::ApplicationException(aexn))
8959 };
8960 res
8961 }
8962 .instrument(::tracing::info_span!("MetaService.dropEdgeIndex"))
8963 .boxed()
8964 }
8965
8966 fn _getEdgeIndex_impl(
8967 &self,
8968 arg_req: &crate::types::GetEdgeIndexReq,
8969 rpc_options: T::RpcOptions,
8970 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>> {
8971 use ::const_cstr::const_cstr;
8972 use ::tracing::Instrument as _;
8973 use ::futures::FutureExt as _;
8974
8975 const_cstr! {
8976 SERVICE_NAME = "MetaService";
8977 METHOD_NAME = "MetaService.getEdgeIndex";
8978 }
8979 let args = self::Args_MetaService_getEdgeIndex {
8980 req: arg_req,
8981 _phantom: ::std::marker::PhantomData,
8982 };
8983
8984 let transport = self.transport();
8985
8986 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getEdgeIndex", &args) {
8988 ::std::result::Result::Ok(res) => res,
8989 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
8990 };
8991
8992 let call = transport
8993 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
8994 .instrument(::tracing::trace_span!("call", function = "MetaService.getEdgeIndex"));
8995
8996 async move {
8997 let reply_env = call.await?;
8998
8999 let de = P::deserializer(reply_env);
9000 let (res, _de): (::std::result::Result<crate::services::meta_service::GetEdgeIndexExn, _>, _) =
9001 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9002
9003 let res = match res {
9004 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9005 ::std::result::Result::Err(aexn) =>
9006 ::std::result::Result::Err(crate::errors::meta_service::GetEdgeIndexError::ApplicationException(aexn))
9007 };
9008 res
9009 }
9010 .instrument(::tracing::info_span!("MetaService.getEdgeIndex"))
9011 .boxed()
9012 }
9013
9014 fn _listEdgeIndexes_impl(
9015 &self,
9016 arg_req: &crate::types::ListEdgeIndexesReq,
9017 rpc_options: T::RpcOptions,
9018 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>> {
9019 use ::const_cstr::const_cstr;
9020 use ::tracing::Instrument as _;
9021 use ::futures::FutureExt as _;
9022
9023 const_cstr! {
9024 SERVICE_NAME = "MetaService";
9025 METHOD_NAME = "MetaService.listEdgeIndexes";
9026 }
9027 let args = self::Args_MetaService_listEdgeIndexes {
9028 req: arg_req,
9029 _phantom: ::std::marker::PhantomData,
9030 };
9031
9032 let transport = self.transport();
9033
9034 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listEdgeIndexes", &args) {
9036 ::std::result::Result::Ok(res) => res,
9037 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9038 };
9039
9040 let call = transport
9041 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9042 .instrument(::tracing::trace_span!("call", function = "MetaService.listEdgeIndexes"));
9043
9044 async move {
9045 let reply_env = call.await?;
9046
9047 let de = P::deserializer(reply_env);
9048 let (res, _de): (::std::result::Result<crate::services::meta_service::ListEdgeIndexesExn, _>, _) =
9049 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9050
9051 let res = match res {
9052 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9053 ::std::result::Result::Err(aexn) =>
9054 ::std::result::Result::Err(crate::errors::meta_service::ListEdgeIndexesError::ApplicationException(aexn))
9055 };
9056 res
9057 }
9058 .instrument(::tracing::info_span!("MetaService.listEdgeIndexes"))
9059 .boxed()
9060 }
9061
9062 fn _rebuildEdgeIndex_impl(
9063 &self,
9064 arg_req: &crate::types::RebuildIndexReq,
9065 rpc_options: T::RpcOptions,
9066 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>> {
9067 use ::const_cstr::const_cstr;
9068 use ::tracing::Instrument as _;
9069 use ::futures::FutureExt as _;
9070
9071 const_cstr! {
9072 SERVICE_NAME = "MetaService";
9073 METHOD_NAME = "MetaService.rebuildEdgeIndex";
9074 }
9075 let args = self::Args_MetaService_rebuildEdgeIndex {
9076 req: arg_req,
9077 _phantom: ::std::marker::PhantomData,
9078 };
9079
9080 let transport = self.transport();
9081
9082 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("rebuildEdgeIndex", &args) {
9084 ::std::result::Result::Ok(res) => res,
9085 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9086 };
9087
9088 let call = transport
9089 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9090 .instrument(::tracing::trace_span!("call", function = "MetaService.rebuildEdgeIndex"));
9091
9092 async move {
9093 let reply_env = call.await?;
9094
9095 let de = P::deserializer(reply_env);
9096 let (res, _de): (::std::result::Result<crate::services::meta_service::RebuildEdgeIndexExn, _>, _) =
9097 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9098
9099 let res = match res {
9100 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9101 ::std::result::Result::Err(aexn) =>
9102 ::std::result::Result::Err(crate::errors::meta_service::RebuildEdgeIndexError::ApplicationException(aexn))
9103 };
9104 res
9105 }
9106 .instrument(::tracing::info_span!("MetaService.rebuildEdgeIndex"))
9107 .boxed()
9108 }
9109
9110 fn _listEdgeIndexStatus_impl(
9111 &self,
9112 arg_req: &crate::types::ListIndexStatusReq,
9113 rpc_options: T::RpcOptions,
9114 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>> {
9115 use ::const_cstr::const_cstr;
9116 use ::tracing::Instrument as _;
9117 use ::futures::FutureExt as _;
9118
9119 const_cstr! {
9120 SERVICE_NAME = "MetaService";
9121 METHOD_NAME = "MetaService.listEdgeIndexStatus";
9122 }
9123 let args = self::Args_MetaService_listEdgeIndexStatus {
9124 req: arg_req,
9125 _phantom: ::std::marker::PhantomData,
9126 };
9127
9128 let transport = self.transport();
9129
9130 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listEdgeIndexStatus", &args) {
9132 ::std::result::Result::Ok(res) => res,
9133 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9134 };
9135
9136 let call = transport
9137 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9138 .instrument(::tracing::trace_span!("call", function = "MetaService.listEdgeIndexStatus"));
9139
9140 async move {
9141 let reply_env = call.await?;
9142
9143 let de = P::deserializer(reply_env);
9144 let (res, _de): (::std::result::Result<crate::services::meta_service::ListEdgeIndexStatusExn, _>, _) =
9145 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9146
9147 let res = match res {
9148 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9149 ::std::result::Result::Err(aexn) =>
9150 ::std::result::Result::Err(crate::errors::meta_service::ListEdgeIndexStatusError::ApplicationException(aexn))
9151 };
9152 res
9153 }
9154 .instrument(::tracing::info_span!("MetaService.listEdgeIndexStatus"))
9155 .boxed()
9156 }
9157
9158 fn _createUser_impl(
9159 &self,
9160 arg_req: &crate::types::CreateUserReq,
9161 rpc_options: T::RpcOptions,
9162 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>> {
9163 use ::const_cstr::const_cstr;
9164 use ::tracing::Instrument as _;
9165 use ::futures::FutureExt as _;
9166
9167 const_cstr! {
9168 SERVICE_NAME = "MetaService";
9169 METHOD_NAME = "MetaService.createUser";
9170 }
9171 let args = self::Args_MetaService_createUser {
9172 req: arg_req,
9173 _phantom: ::std::marker::PhantomData,
9174 };
9175
9176 let transport = self.transport();
9177
9178 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("createUser", &args) {
9180 ::std::result::Result::Ok(res) => res,
9181 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9182 };
9183
9184 let call = transport
9185 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9186 .instrument(::tracing::trace_span!("call", function = "MetaService.createUser"));
9187
9188 async move {
9189 let reply_env = call.await?;
9190
9191 let de = P::deserializer(reply_env);
9192 let (res, _de): (::std::result::Result<crate::services::meta_service::CreateUserExn, _>, _) =
9193 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9194
9195 let res = match res {
9196 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9197 ::std::result::Result::Err(aexn) =>
9198 ::std::result::Result::Err(crate::errors::meta_service::CreateUserError::ApplicationException(aexn))
9199 };
9200 res
9201 }
9202 .instrument(::tracing::info_span!("MetaService.createUser"))
9203 .boxed()
9204 }
9205
9206 fn _dropUser_impl(
9207 &self,
9208 arg_req: &crate::types::DropUserReq,
9209 rpc_options: T::RpcOptions,
9210 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>> {
9211 use ::const_cstr::const_cstr;
9212 use ::tracing::Instrument as _;
9213 use ::futures::FutureExt as _;
9214
9215 const_cstr! {
9216 SERVICE_NAME = "MetaService";
9217 METHOD_NAME = "MetaService.dropUser";
9218 }
9219 let args = self::Args_MetaService_dropUser {
9220 req: arg_req,
9221 _phantom: ::std::marker::PhantomData,
9222 };
9223
9224 let transport = self.transport();
9225
9226 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("dropUser", &args) {
9228 ::std::result::Result::Ok(res) => res,
9229 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9230 };
9231
9232 let call = transport
9233 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9234 .instrument(::tracing::trace_span!("call", function = "MetaService.dropUser"));
9235
9236 async move {
9237 let reply_env = call.await?;
9238
9239 let de = P::deserializer(reply_env);
9240 let (res, _de): (::std::result::Result<crate::services::meta_service::DropUserExn, _>, _) =
9241 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9242
9243 let res = match res {
9244 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9245 ::std::result::Result::Err(aexn) =>
9246 ::std::result::Result::Err(crate::errors::meta_service::DropUserError::ApplicationException(aexn))
9247 };
9248 res
9249 }
9250 .instrument(::tracing::info_span!("MetaService.dropUser"))
9251 .boxed()
9252 }
9253
9254 fn _alterUser_impl(
9255 &self,
9256 arg_req: &crate::types::AlterUserReq,
9257 rpc_options: T::RpcOptions,
9258 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>> {
9259 use ::const_cstr::const_cstr;
9260 use ::tracing::Instrument as _;
9261 use ::futures::FutureExt as _;
9262
9263 const_cstr! {
9264 SERVICE_NAME = "MetaService";
9265 METHOD_NAME = "MetaService.alterUser";
9266 }
9267 let args = self::Args_MetaService_alterUser {
9268 req: arg_req,
9269 _phantom: ::std::marker::PhantomData,
9270 };
9271
9272 let transport = self.transport();
9273
9274 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("alterUser", &args) {
9276 ::std::result::Result::Ok(res) => res,
9277 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9278 };
9279
9280 let call = transport
9281 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9282 .instrument(::tracing::trace_span!("call", function = "MetaService.alterUser"));
9283
9284 async move {
9285 let reply_env = call.await?;
9286
9287 let de = P::deserializer(reply_env);
9288 let (res, _de): (::std::result::Result<crate::services::meta_service::AlterUserExn, _>, _) =
9289 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9290
9291 let res = match res {
9292 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9293 ::std::result::Result::Err(aexn) =>
9294 ::std::result::Result::Err(crate::errors::meta_service::AlterUserError::ApplicationException(aexn))
9295 };
9296 res
9297 }
9298 .instrument(::tracing::info_span!("MetaService.alterUser"))
9299 .boxed()
9300 }
9301
9302 fn _grantRole_impl(
9303 &self,
9304 arg_req: &crate::types::GrantRoleReq,
9305 rpc_options: T::RpcOptions,
9306 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>> {
9307 use ::const_cstr::const_cstr;
9308 use ::tracing::Instrument as _;
9309 use ::futures::FutureExt as _;
9310
9311 const_cstr! {
9312 SERVICE_NAME = "MetaService";
9313 METHOD_NAME = "MetaService.grantRole";
9314 }
9315 let args = self::Args_MetaService_grantRole {
9316 req: arg_req,
9317 _phantom: ::std::marker::PhantomData,
9318 };
9319
9320 let transport = self.transport();
9321
9322 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("grantRole", &args) {
9324 ::std::result::Result::Ok(res) => res,
9325 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9326 };
9327
9328 let call = transport
9329 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9330 .instrument(::tracing::trace_span!("call", function = "MetaService.grantRole"));
9331
9332 async move {
9333 let reply_env = call.await?;
9334
9335 let de = P::deserializer(reply_env);
9336 let (res, _de): (::std::result::Result<crate::services::meta_service::GrantRoleExn, _>, _) =
9337 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9338
9339 let res = match res {
9340 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9341 ::std::result::Result::Err(aexn) =>
9342 ::std::result::Result::Err(crate::errors::meta_service::GrantRoleError::ApplicationException(aexn))
9343 };
9344 res
9345 }
9346 .instrument(::tracing::info_span!("MetaService.grantRole"))
9347 .boxed()
9348 }
9349
9350 fn _revokeRole_impl(
9351 &self,
9352 arg_req: &crate::types::RevokeRoleReq,
9353 rpc_options: T::RpcOptions,
9354 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>> {
9355 use ::const_cstr::const_cstr;
9356 use ::tracing::Instrument as _;
9357 use ::futures::FutureExt as _;
9358
9359 const_cstr! {
9360 SERVICE_NAME = "MetaService";
9361 METHOD_NAME = "MetaService.revokeRole";
9362 }
9363 let args = self::Args_MetaService_revokeRole {
9364 req: arg_req,
9365 _phantom: ::std::marker::PhantomData,
9366 };
9367
9368 let transport = self.transport();
9369
9370 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("revokeRole", &args) {
9372 ::std::result::Result::Ok(res) => res,
9373 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9374 };
9375
9376 let call = transport
9377 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9378 .instrument(::tracing::trace_span!("call", function = "MetaService.revokeRole"));
9379
9380 async move {
9381 let reply_env = call.await?;
9382
9383 let de = P::deserializer(reply_env);
9384 let (res, _de): (::std::result::Result<crate::services::meta_service::RevokeRoleExn, _>, _) =
9385 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9386
9387 let res = match res {
9388 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9389 ::std::result::Result::Err(aexn) =>
9390 ::std::result::Result::Err(crate::errors::meta_service::RevokeRoleError::ApplicationException(aexn))
9391 };
9392 res
9393 }
9394 .instrument(::tracing::info_span!("MetaService.revokeRole"))
9395 .boxed()
9396 }
9397
9398 fn _listUsers_impl(
9399 &self,
9400 arg_req: &crate::types::ListUsersReq,
9401 rpc_options: T::RpcOptions,
9402 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>> {
9403 use ::const_cstr::const_cstr;
9404 use ::tracing::Instrument as _;
9405 use ::futures::FutureExt as _;
9406
9407 const_cstr! {
9408 SERVICE_NAME = "MetaService";
9409 METHOD_NAME = "MetaService.listUsers";
9410 }
9411 let args = self::Args_MetaService_listUsers {
9412 req: arg_req,
9413 _phantom: ::std::marker::PhantomData,
9414 };
9415
9416 let transport = self.transport();
9417
9418 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listUsers", &args) {
9420 ::std::result::Result::Ok(res) => res,
9421 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9422 };
9423
9424 let call = transport
9425 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9426 .instrument(::tracing::trace_span!("call", function = "MetaService.listUsers"));
9427
9428 async move {
9429 let reply_env = call.await?;
9430
9431 let de = P::deserializer(reply_env);
9432 let (res, _de): (::std::result::Result<crate::services::meta_service::ListUsersExn, _>, _) =
9433 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9434
9435 let res = match res {
9436 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9437 ::std::result::Result::Err(aexn) =>
9438 ::std::result::Result::Err(crate::errors::meta_service::ListUsersError::ApplicationException(aexn))
9439 };
9440 res
9441 }
9442 .instrument(::tracing::info_span!("MetaService.listUsers"))
9443 .boxed()
9444 }
9445
9446 fn _listRoles_impl(
9447 &self,
9448 arg_req: &crate::types::ListRolesReq,
9449 rpc_options: T::RpcOptions,
9450 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>> {
9451 use ::const_cstr::const_cstr;
9452 use ::tracing::Instrument as _;
9453 use ::futures::FutureExt as _;
9454
9455 const_cstr! {
9456 SERVICE_NAME = "MetaService";
9457 METHOD_NAME = "MetaService.listRoles";
9458 }
9459 let args = self::Args_MetaService_listRoles {
9460 req: arg_req,
9461 _phantom: ::std::marker::PhantomData,
9462 };
9463
9464 let transport = self.transport();
9465
9466 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listRoles", &args) {
9468 ::std::result::Result::Ok(res) => res,
9469 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9470 };
9471
9472 let call = transport
9473 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9474 .instrument(::tracing::trace_span!("call", function = "MetaService.listRoles"));
9475
9476 async move {
9477 let reply_env = call.await?;
9478
9479 let de = P::deserializer(reply_env);
9480 let (res, _de): (::std::result::Result<crate::services::meta_service::ListRolesExn, _>, _) =
9481 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9482
9483 let res = match res {
9484 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9485 ::std::result::Result::Err(aexn) =>
9486 ::std::result::Result::Err(crate::errors::meta_service::ListRolesError::ApplicationException(aexn))
9487 };
9488 res
9489 }
9490 .instrument(::tracing::info_span!("MetaService.listRoles"))
9491 .boxed()
9492 }
9493
9494 fn _getUserRoles_impl(
9495 &self,
9496 arg_req: &crate::types::GetUserRolesReq,
9497 rpc_options: T::RpcOptions,
9498 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>> {
9499 use ::const_cstr::const_cstr;
9500 use ::tracing::Instrument as _;
9501 use ::futures::FutureExt as _;
9502
9503 const_cstr! {
9504 SERVICE_NAME = "MetaService";
9505 METHOD_NAME = "MetaService.getUserRoles";
9506 }
9507 let args = self::Args_MetaService_getUserRoles {
9508 req: arg_req,
9509 _phantom: ::std::marker::PhantomData,
9510 };
9511
9512 let transport = self.transport();
9513
9514 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getUserRoles", &args) {
9516 ::std::result::Result::Ok(res) => res,
9517 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9518 };
9519
9520 let call = transport
9521 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9522 .instrument(::tracing::trace_span!("call", function = "MetaService.getUserRoles"));
9523
9524 async move {
9525 let reply_env = call.await?;
9526
9527 let de = P::deserializer(reply_env);
9528 let (res, _de): (::std::result::Result<crate::services::meta_service::GetUserRolesExn, _>, _) =
9529 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9530
9531 let res = match res {
9532 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9533 ::std::result::Result::Err(aexn) =>
9534 ::std::result::Result::Err(crate::errors::meta_service::GetUserRolesError::ApplicationException(aexn))
9535 };
9536 res
9537 }
9538 .instrument(::tracing::info_span!("MetaService.getUserRoles"))
9539 .boxed()
9540 }
9541
9542 fn _changePassword_impl(
9543 &self,
9544 arg_req: &crate::types::ChangePasswordReq,
9545 rpc_options: T::RpcOptions,
9546 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>> {
9547 use ::const_cstr::const_cstr;
9548 use ::tracing::Instrument as _;
9549 use ::futures::FutureExt as _;
9550
9551 const_cstr! {
9552 SERVICE_NAME = "MetaService";
9553 METHOD_NAME = "MetaService.changePassword";
9554 }
9555 let args = self::Args_MetaService_changePassword {
9556 req: arg_req,
9557 _phantom: ::std::marker::PhantomData,
9558 };
9559
9560 let transport = self.transport();
9561
9562 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("changePassword", &args) {
9564 ::std::result::Result::Ok(res) => res,
9565 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9566 };
9567
9568 let call = transport
9569 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9570 .instrument(::tracing::trace_span!("call", function = "MetaService.changePassword"));
9571
9572 async move {
9573 let reply_env = call.await?;
9574
9575 let de = P::deserializer(reply_env);
9576 let (res, _de): (::std::result::Result<crate::services::meta_service::ChangePasswordExn, _>, _) =
9577 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9578
9579 let res = match res {
9580 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9581 ::std::result::Result::Err(aexn) =>
9582 ::std::result::Result::Err(crate::errors::meta_service::ChangePasswordError::ApplicationException(aexn))
9583 };
9584 res
9585 }
9586 .instrument(::tracing::info_span!("MetaService.changePassword"))
9587 .boxed()
9588 }
9589
9590 fn _heartBeat_impl(
9591 &self,
9592 arg_req: &crate::types::HBReq,
9593 rpc_options: T::RpcOptions,
9594 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>> {
9595 use ::const_cstr::const_cstr;
9596 use ::tracing::Instrument as _;
9597 use ::futures::FutureExt as _;
9598
9599 const_cstr! {
9600 SERVICE_NAME = "MetaService";
9601 METHOD_NAME = "MetaService.heartBeat";
9602 }
9603 let args = self::Args_MetaService_heartBeat {
9604 req: arg_req,
9605 _phantom: ::std::marker::PhantomData,
9606 };
9607
9608 let transport = self.transport();
9609
9610 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("heartBeat", &args) {
9612 ::std::result::Result::Ok(res) => res,
9613 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9614 };
9615
9616 let call = transport
9617 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9618 .instrument(::tracing::trace_span!("call", function = "MetaService.heartBeat"));
9619
9620 async move {
9621 let reply_env = call.await?;
9622
9623 let de = P::deserializer(reply_env);
9624 let (res, _de): (::std::result::Result<crate::services::meta_service::HeartBeatExn, _>, _) =
9625 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9626
9627 let res = match res {
9628 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9629 ::std::result::Result::Err(aexn) =>
9630 ::std::result::Result::Err(crate::errors::meta_service::HeartBeatError::ApplicationException(aexn))
9631 };
9632 res
9633 }
9634 .instrument(::tracing::info_span!("MetaService.heartBeat"))
9635 .boxed()
9636 }
9637
9638 fn _balance_impl(
9639 &self,
9640 arg_req: &crate::types::BalanceReq,
9641 rpc_options: T::RpcOptions,
9642 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>> {
9643 use ::const_cstr::const_cstr;
9644 use ::tracing::Instrument as _;
9645 use ::futures::FutureExt as _;
9646
9647 const_cstr! {
9648 SERVICE_NAME = "MetaService";
9649 METHOD_NAME = "MetaService.balance";
9650 }
9651 let args = self::Args_MetaService_balance {
9652 req: arg_req,
9653 _phantom: ::std::marker::PhantomData,
9654 };
9655
9656 let transport = self.transport();
9657
9658 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("balance", &args) {
9660 ::std::result::Result::Ok(res) => res,
9661 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9662 };
9663
9664 let call = transport
9665 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9666 .instrument(::tracing::trace_span!("call", function = "MetaService.balance"));
9667
9668 async move {
9669 let reply_env = call.await?;
9670
9671 let de = P::deserializer(reply_env);
9672 let (res, _de): (::std::result::Result<crate::services::meta_service::BalanceExn, _>, _) =
9673 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9674
9675 let res = match res {
9676 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9677 ::std::result::Result::Err(aexn) =>
9678 ::std::result::Result::Err(crate::errors::meta_service::BalanceError::ApplicationException(aexn))
9679 };
9680 res
9681 }
9682 .instrument(::tracing::info_span!("MetaService.balance"))
9683 .boxed()
9684 }
9685
9686 fn _leaderBalance_impl(
9687 &self,
9688 arg_req: &crate::types::LeaderBalanceReq,
9689 rpc_options: T::RpcOptions,
9690 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>> {
9691 use ::const_cstr::const_cstr;
9692 use ::tracing::Instrument as _;
9693 use ::futures::FutureExt as _;
9694
9695 const_cstr! {
9696 SERVICE_NAME = "MetaService";
9697 METHOD_NAME = "MetaService.leaderBalance";
9698 }
9699 let args = self::Args_MetaService_leaderBalance {
9700 req: arg_req,
9701 _phantom: ::std::marker::PhantomData,
9702 };
9703
9704 let transport = self.transport();
9705
9706 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("leaderBalance", &args) {
9708 ::std::result::Result::Ok(res) => res,
9709 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9710 };
9711
9712 let call = transport
9713 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9714 .instrument(::tracing::trace_span!("call", function = "MetaService.leaderBalance"));
9715
9716 async move {
9717 let reply_env = call.await?;
9718
9719 let de = P::deserializer(reply_env);
9720 let (res, _de): (::std::result::Result<crate::services::meta_service::LeaderBalanceExn, _>, _) =
9721 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9722
9723 let res = match res {
9724 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9725 ::std::result::Result::Err(aexn) =>
9726 ::std::result::Result::Err(crate::errors::meta_service::LeaderBalanceError::ApplicationException(aexn))
9727 };
9728 res
9729 }
9730 .instrument(::tracing::info_span!("MetaService.leaderBalance"))
9731 .boxed()
9732 }
9733
9734 fn _regConfig_impl(
9735 &self,
9736 arg_req: &crate::types::RegConfigReq,
9737 rpc_options: T::RpcOptions,
9738 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>> {
9739 use ::const_cstr::const_cstr;
9740 use ::tracing::Instrument as _;
9741 use ::futures::FutureExt as _;
9742
9743 const_cstr! {
9744 SERVICE_NAME = "MetaService";
9745 METHOD_NAME = "MetaService.regConfig";
9746 }
9747 let args = self::Args_MetaService_regConfig {
9748 req: arg_req,
9749 _phantom: ::std::marker::PhantomData,
9750 };
9751
9752 let transport = self.transport();
9753
9754 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("regConfig", &args) {
9756 ::std::result::Result::Ok(res) => res,
9757 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9758 };
9759
9760 let call = transport
9761 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9762 .instrument(::tracing::trace_span!("call", function = "MetaService.regConfig"));
9763
9764 async move {
9765 let reply_env = call.await?;
9766
9767 let de = P::deserializer(reply_env);
9768 let (res, _de): (::std::result::Result<crate::services::meta_service::RegConfigExn, _>, _) =
9769 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9770
9771 let res = match res {
9772 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9773 ::std::result::Result::Err(aexn) =>
9774 ::std::result::Result::Err(crate::errors::meta_service::RegConfigError::ApplicationException(aexn))
9775 };
9776 res
9777 }
9778 .instrument(::tracing::info_span!("MetaService.regConfig"))
9779 .boxed()
9780 }
9781
9782 fn _getConfig_impl(
9783 &self,
9784 arg_req: &crate::types::GetConfigReq,
9785 rpc_options: T::RpcOptions,
9786 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>> {
9787 use ::const_cstr::const_cstr;
9788 use ::tracing::Instrument as _;
9789 use ::futures::FutureExt as _;
9790
9791 const_cstr! {
9792 SERVICE_NAME = "MetaService";
9793 METHOD_NAME = "MetaService.getConfig";
9794 }
9795 let args = self::Args_MetaService_getConfig {
9796 req: arg_req,
9797 _phantom: ::std::marker::PhantomData,
9798 };
9799
9800 let transport = self.transport();
9801
9802 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("getConfig", &args) {
9804 ::std::result::Result::Ok(res) => res,
9805 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9806 };
9807
9808 let call = transport
9809 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9810 .instrument(::tracing::trace_span!("call", function = "MetaService.getConfig"));
9811
9812 async move {
9813 let reply_env = call.await?;
9814
9815 let de = P::deserializer(reply_env);
9816 let (res, _de): (::std::result::Result<crate::services::meta_service::GetConfigExn, _>, _) =
9817 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9818
9819 let res = match res {
9820 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9821 ::std::result::Result::Err(aexn) =>
9822 ::std::result::Result::Err(crate::errors::meta_service::GetConfigError::ApplicationException(aexn))
9823 };
9824 res
9825 }
9826 .instrument(::tracing::info_span!("MetaService.getConfig"))
9827 .boxed()
9828 }
9829
9830 fn _setConfig_impl(
9831 &self,
9832 arg_req: &crate::types::SetConfigReq,
9833 rpc_options: T::RpcOptions,
9834 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>> {
9835 use ::const_cstr::const_cstr;
9836 use ::tracing::Instrument as _;
9837 use ::futures::FutureExt as _;
9838
9839 const_cstr! {
9840 SERVICE_NAME = "MetaService";
9841 METHOD_NAME = "MetaService.setConfig";
9842 }
9843 let args = self::Args_MetaService_setConfig {
9844 req: arg_req,
9845 _phantom: ::std::marker::PhantomData,
9846 };
9847
9848 let transport = self.transport();
9849
9850 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("setConfig", &args) {
9852 ::std::result::Result::Ok(res) => res,
9853 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9854 };
9855
9856 let call = transport
9857 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9858 .instrument(::tracing::trace_span!("call", function = "MetaService.setConfig"));
9859
9860 async move {
9861 let reply_env = call.await?;
9862
9863 let de = P::deserializer(reply_env);
9864 let (res, _de): (::std::result::Result<crate::services::meta_service::SetConfigExn, _>, _) =
9865 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9866
9867 let res = match res {
9868 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9869 ::std::result::Result::Err(aexn) =>
9870 ::std::result::Result::Err(crate::errors::meta_service::SetConfigError::ApplicationException(aexn))
9871 };
9872 res
9873 }
9874 .instrument(::tracing::info_span!("MetaService.setConfig"))
9875 .boxed()
9876 }
9877
9878 fn _listConfigs_impl(
9879 &self,
9880 arg_req: &crate::types::ListConfigsReq,
9881 rpc_options: T::RpcOptions,
9882 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>> {
9883 use ::const_cstr::const_cstr;
9884 use ::tracing::Instrument as _;
9885 use ::futures::FutureExt as _;
9886
9887 const_cstr! {
9888 SERVICE_NAME = "MetaService";
9889 METHOD_NAME = "MetaService.listConfigs";
9890 }
9891 let args = self::Args_MetaService_listConfigs {
9892 req: arg_req,
9893 _phantom: ::std::marker::PhantomData,
9894 };
9895
9896 let transport = self.transport();
9897
9898 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listConfigs", &args) {
9900 ::std::result::Result::Ok(res) => res,
9901 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9902 };
9903
9904 let call = transport
9905 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9906 .instrument(::tracing::trace_span!("call", function = "MetaService.listConfigs"));
9907
9908 async move {
9909 let reply_env = call.await?;
9910
9911 let de = P::deserializer(reply_env);
9912 let (res, _de): (::std::result::Result<crate::services::meta_service::ListConfigsExn, _>, _) =
9913 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9914
9915 let res = match res {
9916 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9917 ::std::result::Result::Err(aexn) =>
9918 ::std::result::Result::Err(crate::errors::meta_service::ListConfigsError::ApplicationException(aexn))
9919 };
9920 res
9921 }
9922 .instrument(::tracing::info_span!("MetaService.listConfigs"))
9923 .boxed()
9924 }
9925
9926 fn _createSnapshot_impl(
9927 &self,
9928 arg_req: &crate::types::CreateSnapshotReq,
9929 rpc_options: T::RpcOptions,
9930 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>> {
9931 use ::const_cstr::const_cstr;
9932 use ::tracing::Instrument as _;
9933 use ::futures::FutureExt as _;
9934
9935 const_cstr! {
9936 SERVICE_NAME = "MetaService";
9937 METHOD_NAME = "MetaService.createSnapshot";
9938 }
9939 let args = self::Args_MetaService_createSnapshot {
9940 req: arg_req,
9941 _phantom: ::std::marker::PhantomData,
9942 };
9943
9944 let transport = self.transport();
9945
9946 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("createSnapshot", &args) {
9948 ::std::result::Result::Ok(res) => res,
9949 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9950 };
9951
9952 let call = transport
9953 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
9954 .instrument(::tracing::trace_span!("call", function = "MetaService.createSnapshot"));
9955
9956 async move {
9957 let reply_env = call.await?;
9958
9959 let de = P::deserializer(reply_env);
9960 let (res, _de): (::std::result::Result<crate::services::meta_service::CreateSnapshotExn, _>, _) =
9961 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
9962
9963 let res = match res {
9964 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
9965 ::std::result::Result::Err(aexn) =>
9966 ::std::result::Result::Err(crate::errors::meta_service::CreateSnapshotError::ApplicationException(aexn))
9967 };
9968 res
9969 }
9970 .instrument(::tracing::info_span!("MetaService.createSnapshot"))
9971 .boxed()
9972 }
9973
9974 fn _dropSnapshot_impl(
9975 &self,
9976 arg_req: &crate::types::DropSnapshotReq,
9977 rpc_options: T::RpcOptions,
9978 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>> {
9979 use ::const_cstr::const_cstr;
9980 use ::tracing::Instrument as _;
9981 use ::futures::FutureExt as _;
9982
9983 const_cstr! {
9984 SERVICE_NAME = "MetaService";
9985 METHOD_NAME = "MetaService.dropSnapshot";
9986 }
9987 let args = self::Args_MetaService_dropSnapshot {
9988 req: arg_req,
9989 _phantom: ::std::marker::PhantomData,
9990 };
9991
9992 let transport = self.transport();
9993
9994 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("dropSnapshot", &args) {
9996 ::std::result::Result::Ok(res) => res,
9997 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
9998 };
9999
10000 let call = transport
10001 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
10002 .instrument(::tracing::trace_span!("call", function = "MetaService.dropSnapshot"));
10003
10004 async move {
10005 let reply_env = call.await?;
10006
10007 let de = P::deserializer(reply_env);
10008 let (res, _de): (::std::result::Result<crate::services::meta_service::DropSnapshotExn, _>, _) =
10009 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
10010
10011 let res = match res {
10012 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
10013 ::std::result::Result::Err(aexn) =>
10014 ::std::result::Result::Err(crate::errors::meta_service::DropSnapshotError::ApplicationException(aexn))
10015 };
10016 res
10017 }
10018 .instrument(::tracing::info_span!("MetaService.dropSnapshot"))
10019 .boxed()
10020 }
10021
10022 fn _listSnapshots_impl(
10023 &self,
10024 arg_req: &crate::types::ListSnapshotsReq,
10025 rpc_options: T::RpcOptions,
10026 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>> {
10027 use ::const_cstr::const_cstr;
10028 use ::tracing::Instrument as _;
10029 use ::futures::FutureExt as _;
10030
10031 const_cstr! {
10032 SERVICE_NAME = "MetaService";
10033 METHOD_NAME = "MetaService.listSnapshots";
10034 }
10035 let args = self::Args_MetaService_listSnapshots {
10036 req: arg_req,
10037 _phantom: ::std::marker::PhantomData,
10038 };
10039
10040 let transport = self.transport();
10041
10042 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("listSnapshots", &args) {
10044 ::std::result::Result::Ok(res) => res,
10045 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
10046 };
10047
10048 let call = transport
10049 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
10050 .instrument(::tracing::trace_span!("call", function = "MetaService.listSnapshots"));
10051
10052 async move {
10053 let reply_env = call.await?;
10054
10055 let de = P::deserializer(reply_env);
10056 let (res, _de): (::std::result::Result<crate::services::meta_service::ListSnapshotsExn, _>, _) =
10057 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
10058
10059 let res = match res {
10060 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
10061 ::std::result::Result::Err(aexn) =>
10062 ::std::result::Result::Err(crate::errors::meta_service::ListSnapshotsError::ApplicationException(aexn))
10063 };
10064 res
10065 }
10066 .instrument(::tracing::info_span!("MetaService.listSnapshots"))
10067 .boxed()
10068 }
10069
10070 fn _runAdminJob_impl(
10071 &self,
10072 arg_req: &crate::types::AdminJobReq,
10073 rpc_options: T::RpcOptions,
10074 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>> {
10075 use ::const_cstr::const_cstr;
10076 use ::tracing::Instrument as _;
10077 use ::futures::FutureExt as _;
10078
10079 const_cstr! {
10080 SERVICE_NAME = "MetaService";
10081 METHOD_NAME = "MetaService.runAdminJob";
10082 }
10083 let args = self::Args_MetaService_runAdminJob {
10084 req: arg_req,
10085 _phantom: ::std::marker::PhantomData,
10086 };
10087
10088 let transport = self.transport();
10089
10090 let request_env = match ::fbthrift::help::serialize_request_envelope::<P, _>("runAdminJob", &args) {
10092 ::std::result::Result::Ok(res) => res,
10093 ::std::result::Result::Err(err) => return ::futures::future::err(err.into()).boxed(),
10094 };
10095
10096 let call = transport
10097 .call(SERVICE_NAME.as_cstr(), METHOD_NAME.as_cstr(), request_env, rpc_options)
10098 .instrument(::tracing::trace_span!("call", function = "MetaService.runAdminJob"));
10099
10100 async move {
10101 let reply_env = call.await?;
10102
10103 let de = P::deserializer(reply_env);
10104 let (res, _de): (::std::result::Result<crate::services::meta_service::RunAdminJobExn, _>, _) =
10105 ::fbthrift::help::async_deserialize_response_envelope::<P, _, S>(de).await?;
10106
10107 let res = match res {
10108 ::std::result::Result::Ok(exn) => ::std::convert::From::from(exn),
10109 ::std::result::Result::Err(aexn) =>
10110 ::std::result::Result::Err(crate::errors::meta_service::RunAdminJobError::ApplicationException(aexn))
10111 };
10112 res
10113 }
10114 .instrument(::tracing::info_span!("MetaService.runAdminJob"))
10115 .boxed()
10116 }
10117 }
10118
10119 pub trait MetaService: ::std::marker::Send {
10120 fn createSpace(
10121 &self,
10122 arg_req: &crate::types::CreateSpaceReq,
10123 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>>;
10124
10125 fn dropSpace(
10126 &self,
10127 arg_req: &crate::types::DropSpaceReq,
10128 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>>;
10129
10130 fn getSpace(
10131 &self,
10132 arg_req: &crate::types::GetSpaceReq,
10133 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>>;
10134
10135 fn listSpaces(
10136 &self,
10137 arg_req: &crate::types::ListSpacesReq,
10138 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>>;
10139
10140 fn createTag(
10141 &self,
10142 arg_req: &crate::types::CreateTagReq,
10143 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>>;
10144
10145 fn alterTag(
10146 &self,
10147 arg_req: &crate::types::AlterTagReq,
10148 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>>;
10149
10150 fn dropTag(
10151 &self,
10152 arg_req: &crate::types::DropTagReq,
10153 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>>;
10154
10155 fn getTag(
10156 &self,
10157 arg_req: &crate::types::GetTagReq,
10158 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>>;
10159
10160 fn listTags(
10161 &self,
10162 arg_req: &crate::types::ListTagsReq,
10163 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>>;
10164
10165 fn createEdge(
10166 &self,
10167 arg_req: &crate::types::CreateEdgeReq,
10168 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>>;
10169
10170 fn alterEdge(
10171 &self,
10172 arg_req: &crate::types::AlterEdgeReq,
10173 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>>;
10174
10175 fn dropEdge(
10176 &self,
10177 arg_req: &crate::types::DropEdgeReq,
10178 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>>;
10179
10180 fn getEdge(
10181 &self,
10182 arg_req: &crate::types::GetEdgeReq,
10183 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>>;
10184
10185 fn listEdges(
10186 &self,
10187 arg_req: &crate::types::ListEdgesReq,
10188 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>>;
10189
10190 fn listHosts(
10191 &self,
10192 arg_req: &crate::types::ListHostsReq,
10193 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>>;
10194
10195 fn getPartsAlloc(
10196 &self,
10197 arg_req: &crate::types::GetPartsAllocReq,
10198 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>>;
10199
10200 fn listParts(
10201 &self,
10202 arg_req: &crate::types::ListPartsReq,
10203 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>>;
10204
10205 fn multiPut(
10206 &self,
10207 arg_req: &crate::types::MultiPutReq,
10208 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>>;
10209
10210 fn get(
10211 &self,
10212 arg_req: &crate::types::GetReq,
10213 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>>;
10214
10215 fn multiGet(
10216 &self,
10217 arg_req: &crate::types::MultiGetReq,
10218 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>>;
10219
10220 fn remove(
10221 &self,
10222 arg_req: &crate::types::RemoveReq,
10223 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>>;
10224
10225 fn removeRange(
10226 &self,
10227 arg_req: &crate::types::RemoveRangeReq,
10228 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>>;
10229
10230 fn scan(
10231 &self,
10232 arg_req: &crate::types::ScanReq,
10233 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>>;
10234
10235 fn createTagIndex(
10236 &self,
10237 arg_req: &crate::types::CreateTagIndexReq,
10238 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>>;
10239
10240 fn dropTagIndex(
10241 &self,
10242 arg_req: &crate::types::DropTagIndexReq,
10243 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>>;
10244
10245 fn getTagIndex(
10246 &self,
10247 arg_req: &crate::types::GetTagIndexReq,
10248 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>>;
10249
10250 fn listTagIndexes(
10251 &self,
10252 arg_req: &crate::types::ListTagIndexesReq,
10253 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>>;
10254
10255 fn rebuildTagIndex(
10256 &self,
10257 arg_req: &crate::types::RebuildIndexReq,
10258 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>>;
10259
10260 fn listTagIndexStatus(
10261 &self,
10262 arg_req: &crate::types::ListIndexStatusReq,
10263 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>>;
10264
10265 fn createEdgeIndex(
10266 &self,
10267 arg_req: &crate::types::CreateEdgeIndexReq,
10268 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>>;
10269
10270 fn dropEdgeIndex(
10271 &self,
10272 arg_req: &crate::types::DropEdgeIndexReq,
10273 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>>;
10274
10275 fn getEdgeIndex(
10276 &self,
10277 arg_req: &crate::types::GetEdgeIndexReq,
10278 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>>;
10279
10280 fn listEdgeIndexes(
10281 &self,
10282 arg_req: &crate::types::ListEdgeIndexesReq,
10283 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>>;
10284
10285 fn rebuildEdgeIndex(
10286 &self,
10287 arg_req: &crate::types::RebuildIndexReq,
10288 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>>;
10289
10290 fn listEdgeIndexStatus(
10291 &self,
10292 arg_req: &crate::types::ListIndexStatusReq,
10293 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>>;
10294
10295 fn createUser(
10296 &self,
10297 arg_req: &crate::types::CreateUserReq,
10298 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>>;
10299
10300 fn dropUser(
10301 &self,
10302 arg_req: &crate::types::DropUserReq,
10303 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>>;
10304
10305 fn alterUser(
10306 &self,
10307 arg_req: &crate::types::AlterUserReq,
10308 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>>;
10309
10310 fn grantRole(
10311 &self,
10312 arg_req: &crate::types::GrantRoleReq,
10313 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>>;
10314
10315 fn revokeRole(
10316 &self,
10317 arg_req: &crate::types::RevokeRoleReq,
10318 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>>;
10319
10320 fn listUsers(
10321 &self,
10322 arg_req: &crate::types::ListUsersReq,
10323 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>>;
10324
10325 fn listRoles(
10326 &self,
10327 arg_req: &crate::types::ListRolesReq,
10328 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>>;
10329
10330 fn getUserRoles(
10331 &self,
10332 arg_req: &crate::types::GetUserRolesReq,
10333 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>>;
10334
10335 fn changePassword(
10336 &self,
10337 arg_req: &crate::types::ChangePasswordReq,
10338 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>>;
10339
10340 fn heartBeat(
10341 &self,
10342 arg_req: &crate::types::HBReq,
10343 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>>;
10344
10345 fn balance(
10346 &self,
10347 arg_req: &crate::types::BalanceReq,
10348 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>>;
10349
10350 fn leaderBalance(
10351 &self,
10352 arg_req: &crate::types::LeaderBalanceReq,
10353 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>>;
10354
10355 fn regConfig(
10356 &self,
10357 arg_req: &crate::types::RegConfigReq,
10358 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>>;
10359
10360 fn getConfig(
10361 &self,
10362 arg_req: &crate::types::GetConfigReq,
10363 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>>;
10364
10365 fn setConfig(
10366 &self,
10367 arg_req: &crate::types::SetConfigReq,
10368 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>>;
10369
10370 fn listConfigs(
10371 &self,
10372 arg_req: &crate::types::ListConfigsReq,
10373 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>>;
10374
10375 fn createSnapshot(
10376 &self,
10377 arg_req: &crate::types::CreateSnapshotReq,
10378 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>>;
10379
10380 fn dropSnapshot(
10381 &self,
10382 arg_req: &crate::types::DropSnapshotReq,
10383 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>>;
10384
10385 fn listSnapshots(
10386 &self,
10387 arg_req: &crate::types::ListSnapshotsReq,
10388 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>>;
10389
10390 fn runAdminJob(
10391 &self,
10392 arg_req: &crate::types::AdminJobReq,
10393 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>>;
10394 }
10395
10396 pub trait MetaServiceExt<T>: MetaService
10397 where
10398 T: ::fbthrift::Transport,
10399 {
10400 fn createSpace_with_rpc_opts(
10401 &self,
10402 arg_req: &crate::types::CreateSpaceReq,
10403 rpc_options: T::RpcOptions,
10404 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>>;
10405 fn dropSpace_with_rpc_opts(
10406 &self,
10407 arg_req: &crate::types::DropSpaceReq,
10408 rpc_options: T::RpcOptions,
10409 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>>;
10410 fn getSpace_with_rpc_opts(
10411 &self,
10412 arg_req: &crate::types::GetSpaceReq,
10413 rpc_options: T::RpcOptions,
10414 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>>;
10415 fn listSpaces_with_rpc_opts(
10416 &self,
10417 arg_req: &crate::types::ListSpacesReq,
10418 rpc_options: T::RpcOptions,
10419 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>>;
10420 fn createTag_with_rpc_opts(
10421 &self,
10422 arg_req: &crate::types::CreateTagReq,
10423 rpc_options: T::RpcOptions,
10424 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>>;
10425 fn alterTag_with_rpc_opts(
10426 &self,
10427 arg_req: &crate::types::AlterTagReq,
10428 rpc_options: T::RpcOptions,
10429 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>>;
10430 fn dropTag_with_rpc_opts(
10431 &self,
10432 arg_req: &crate::types::DropTagReq,
10433 rpc_options: T::RpcOptions,
10434 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>>;
10435 fn getTag_with_rpc_opts(
10436 &self,
10437 arg_req: &crate::types::GetTagReq,
10438 rpc_options: T::RpcOptions,
10439 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>>;
10440 fn listTags_with_rpc_opts(
10441 &self,
10442 arg_req: &crate::types::ListTagsReq,
10443 rpc_options: T::RpcOptions,
10444 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>>;
10445 fn createEdge_with_rpc_opts(
10446 &self,
10447 arg_req: &crate::types::CreateEdgeReq,
10448 rpc_options: T::RpcOptions,
10449 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>>;
10450 fn alterEdge_with_rpc_opts(
10451 &self,
10452 arg_req: &crate::types::AlterEdgeReq,
10453 rpc_options: T::RpcOptions,
10454 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>>;
10455 fn dropEdge_with_rpc_opts(
10456 &self,
10457 arg_req: &crate::types::DropEdgeReq,
10458 rpc_options: T::RpcOptions,
10459 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>>;
10460 fn getEdge_with_rpc_opts(
10461 &self,
10462 arg_req: &crate::types::GetEdgeReq,
10463 rpc_options: T::RpcOptions,
10464 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>>;
10465 fn listEdges_with_rpc_opts(
10466 &self,
10467 arg_req: &crate::types::ListEdgesReq,
10468 rpc_options: T::RpcOptions,
10469 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>>;
10470 fn listHosts_with_rpc_opts(
10471 &self,
10472 arg_req: &crate::types::ListHostsReq,
10473 rpc_options: T::RpcOptions,
10474 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>>;
10475 fn getPartsAlloc_with_rpc_opts(
10476 &self,
10477 arg_req: &crate::types::GetPartsAllocReq,
10478 rpc_options: T::RpcOptions,
10479 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>>;
10480 fn listParts_with_rpc_opts(
10481 &self,
10482 arg_req: &crate::types::ListPartsReq,
10483 rpc_options: T::RpcOptions,
10484 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>>;
10485 fn multiPut_with_rpc_opts(
10486 &self,
10487 arg_req: &crate::types::MultiPutReq,
10488 rpc_options: T::RpcOptions,
10489 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>>;
10490 fn get_with_rpc_opts(
10491 &self,
10492 arg_req: &crate::types::GetReq,
10493 rpc_options: T::RpcOptions,
10494 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>>;
10495 fn multiGet_with_rpc_opts(
10496 &self,
10497 arg_req: &crate::types::MultiGetReq,
10498 rpc_options: T::RpcOptions,
10499 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>>;
10500 fn remove_with_rpc_opts(
10501 &self,
10502 arg_req: &crate::types::RemoveReq,
10503 rpc_options: T::RpcOptions,
10504 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>>;
10505 fn removeRange_with_rpc_opts(
10506 &self,
10507 arg_req: &crate::types::RemoveRangeReq,
10508 rpc_options: T::RpcOptions,
10509 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>>;
10510 fn scan_with_rpc_opts(
10511 &self,
10512 arg_req: &crate::types::ScanReq,
10513 rpc_options: T::RpcOptions,
10514 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>>;
10515 fn createTagIndex_with_rpc_opts(
10516 &self,
10517 arg_req: &crate::types::CreateTagIndexReq,
10518 rpc_options: T::RpcOptions,
10519 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>>;
10520 fn dropTagIndex_with_rpc_opts(
10521 &self,
10522 arg_req: &crate::types::DropTagIndexReq,
10523 rpc_options: T::RpcOptions,
10524 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>>;
10525 fn getTagIndex_with_rpc_opts(
10526 &self,
10527 arg_req: &crate::types::GetTagIndexReq,
10528 rpc_options: T::RpcOptions,
10529 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>>;
10530 fn listTagIndexes_with_rpc_opts(
10531 &self,
10532 arg_req: &crate::types::ListTagIndexesReq,
10533 rpc_options: T::RpcOptions,
10534 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>>;
10535 fn rebuildTagIndex_with_rpc_opts(
10536 &self,
10537 arg_req: &crate::types::RebuildIndexReq,
10538 rpc_options: T::RpcOptions,
10539 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>>;
10540 fn listTagIndexStatus_with_rpc_opts(
10541 &self,
10542 arg_req: &crate::types::ListIndexStatusReq,
10543 rpc_options: T::RpcOptions,
10544 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>>;
10545 fn createEdgeIndex_with_rpc_opts(
10546 &self,
10547 arg_req: &crate::types::CreateEdgeIndexReq,
10548 rpc_options: T::RpcOptions,
10549 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>>;
10550 fn dropEdgeIndex_with_rpc_opts(
10551 &self,
10552 arg_req: &crate::types::DropEdgeIndexReq,
10553 rpc_options: T::RpcOptions,
10554 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>>;
10555 fn getEdgeIndex_with_rpc_opts(
10556 &self,
10557 arg_req: &crate::types::GetEdgeIndexReq,
10558 rpc_options: T::RpcOptions,
10559 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>>;
10560 fn listEdgeIndexes_with_rpc_opts(
10561 &self,
10562 arg_req: &crate::types::ListEdgeIndexesReq,
10563 rpc_options: T::RpcOptions,
10564 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>>;
10565 fn rebuildEdgeIndex_with_rpc_opts(
10566 &self,
10567 arg_req: &crate::types::RebuildIndexReq,
10568 rpc_options: T::RpcOptions,
10569 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>>;
10570 fn listEdgeIndexStatus_with_rpc_opts(
10571 &self,
10572 arg_req: &crate::types::ListIndexStatusReq,
10573 rpc_options: T::RpcOptions,
10574 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>>;
10575 fn createUser_with_rpc_opts(
10576 &self,
10577 arg_req: &crate::types::CreateUserReq,
10578 rpc_options: T::RpcOptions,
10579 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>>;
10580 fn dropUser_with_rpc_opts(
10581 &self,
10582 arg_req: &crate::types::DropUserReq,
10583 rpc_options: T::RpcOptions,
10584 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>>;
10585 fn alterUser_with_rpc_opts(
10586 &self,
10587 arg_req: &crate::types::AlterUserReq,
10588 rpc_options: T::RpcOptions,
10589 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>>;
10590 fn grantRole_with_rpc_opts(
10591 &self,
10592 arg_req: &crate::types::GrantRoleReq,
10593 rpc_options: T::RpcOptions,
10594 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>>;
10595 fn revokeRole_with_rpc_opts(
10596 &self,
10597 arg_req: &crate::types::RevokeRoleReq,
10598 rpc_options: T::RpcOptions,
10599 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>>;
10600 fn listUsers_with_rpc_opts(
10601 &self,
10602 arg_req: &crate::types::ListUsersReq,
10603 rpc_options: T::RpcOptions,
10604 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>>;
10605 fn listRoles_with_rpc_opts(
10606 &self,
10607 arg_req: &crate::types::ListRolesReq,
10608 rpc_options: T::RpcOptions,
10609 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>>;
10610 fn getUserRoles_with_rpc_opts(
10611 &self,
10612 arg_req: &crate::types::GetUserRolesReq,
10613 rpc_options: T::RpcOptions,
10614 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>>;
10615 fn changePassword_with_rpc_opts(
10616 &self,
10617 arg_req: &crate::types::ChangePasswordReq,
10618 rpc_options: T::RpcOptions,
10619 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>>;
10620 fn heartBeat_with_rpc_opts(
10621 &self,
10622 arg_req: &crate::types::HBReq,
10623 rpc_options: T::RpcOptions,
10624 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>>;
10625 fn balance_with_rpc_opts(
10626 &self,
10627 arg_req: &crate::types::BalanceReq,
10628 rpc_options: T::RpcOptions,
10629 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>>;
10630 fn leaderBalance_with_rpc_opts(
10631 &self,
10632 arg_req: &crate::types::LeaderBalanceReq,
10633 rpc_options: T::RpcOptions,
10634 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>>;
10635 fn regConfig_with_rpc_opts(
10636 &self,
10637 arg_req: &crate::types::RegConfigReq,
10638 rpc_options: T::RpcOptions,
10639 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>>;
10640 fn getConfig_with_rpc_opts(
10641 &self,
10642 arg_req: &crate::types::GetConfigReq,
10643 rpc_options: T::RpcOptions,
10644 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>>;
10645 fn setConfig_with_rpc_opts(
10646 &self,
10647 arg_req: &crate::types::SetConfigReq,
10648 rpc_options: T::RpcOptions,
10649 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>>;
10650 fn listConfigs_with_rpc_opts(
10651 &self,
10652 arg_req: &crate::types::ListConfigsReq,
10653 rpc_options: T::RpcOptions,
10654 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>>;
10655 fn createSnapshot_with_rpc_opts(
10656 &self,
10657 arg_req: &crate::types::CreateSnapshotReq,
10658 rpc_options: T::RpcOptions,
10659 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>>;
10660 fn dropSnapshot_with_rpc_opts(
10661 &self,
10662 arg_req: &crate::types::DropSnapshotReq,
10663 rpc_options: T::RpcOptions,
10664 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>>;
10665 fn listSnapshots_with_rpc_opts(
10666 &self,
10667 arg_req: &crate::types::ListSnapshotsReq,
10668 rpc_options: T::RpcOptions,
10669 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>>;
10670 fn runAdminJob_with_rpc_opts(
10671 &self,
10672 arg_req: &crate::types::AdminJobReq,
10673 rpc_options: T::RpcOptions,
10674 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>>;
10675 }
10676
10677 struct Args_MetaService_createSpace<'a> {
10678 req: &'a crate::types::CreateSpaceReq,
10679 _phantom: ::std::marker::PhantomData<&'a ()>,
10680 }
10681
10682 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_createSpace<'a> {
10683 #[inline]
10684 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.createSpace"))]
10685 fn write(&self, p: &mut P) {
10686 p.write_struct_begin("args");
10687 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10688 ::fbthrift::Serialize::write(&self.req, p);
10689 p.write_field_end();
10690 p.write_field_stop();
10691 p.write_struct_end();
10692 }
10693 }
10694
10695 struct Args_MetaService_dropSpace<'a> {
10696 req: &'a crate::types::DropSpaceReq,
10697 _phantom: ::std::marker::PhantomData<&'a ()>,
10698 }
10699
10700 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_dropSpace<'a> {
10701 #[inline]
10702 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.dropSpace"))]
10703 fn write(&self, p: &mut P) {
10704 p.write_struct_begin("args");
10705 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10706 ::fbthrift::Serialize::write(&self.req, p);
10707 p.write_field_end();
10708 p.write_field_stop();
10709 p.write_struct_end();
10710 }
10711 }
10712
10713 struct Args_MetaService_getSpace<'a> {
10714 req: &'a crate::types::GetSpaceReq,
10715 _phantom: ::std::marker::PhantomData<&'a ()>,
10716 }
10717
10718 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getSpace<'a> {
10719 #[inline]
10720 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getSpace"))]
10721 fn write(&self, p: &mut P) {
10722 p.write_struct_begin("args");
10723 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10724 ::fbthrift::Serialize::write(&self.req, p);
10725 p.write_field_end();
10726 p.write_field_stop();
10727 p.write_struct_end();
10728 }
10729 }
10730
10731 struct Args_MetaService_listSpaces<'a> {
10732 req: &'a crate::types::ListSpacesReq,
10733 _phantom: ::std::marker::PhantomData<&'a ()>,
10734 }
10735
10736 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listSpaces<'a> {
10737 #[inline]
10738 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listSpaces"))]
10739 fn write(&self, p: &mut P) {
10740 p.write_struct_begin("args");
10741 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10742 ::fbthrift::Serialize::write(&self.req, p);
10743 p.write_field_end();
10744 p.write_field_stop();
10745 p.write_struct_end();
10746 }
10747 }
10748
10749 struct Args_MetaService_createTag<'a> {
10750 req: &'a crate::types::CreateTagReq,
10751 _phantom: ::std::marker::PhantomData<&'a ()>,
10752 }
10753
10754 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_createTag<'a> {
10755 #[inline]
10756 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.createTag"))]
10757 fn write(&self, p: &mut P) {
10758 p.write_struct_begin("args");
10759 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10760 ::fbthrift::Serialize::write(&self.req, p);
10761 p.write_field_end();
10762 p.write_field_stop();
10763 p.write_struct_end();
10764 }
10765 }
10766
10767 struct Args_MetaService_alterTag<'a> {
10768 req: &'a crate::types::AlterTagReq,
10769 _phantom: ::std::marker::PhantomData<&'a ()>,
10770 }
10771
10772 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_alterTag<'a> {
10773 #[inline]
10774 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.alterTag"))]
10775 fn write(&self, p: &mut P) {
10776 p.write_struct_begin("args");
10777 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10778 ::fbthrift::Serialize::write(&self.req, p);
10779 p.write_field_end();
10780 p.write_field_stop();
10781 p.write_struct_end();
10782 }
10783 }
10784
10785 struct Args_MetaService_dropTag<'a> {
10786 req: &'a crate::types::DropTagReq,
10787 _phantom: ::std::marker::PhantomData<&'a ()>,
10788 }
10789
10790 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_dropTag<'a> {
10791 #[inline]
10792 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.dropTag"))]
10793 fn write(&self, p: &mut P) {
10794 p.write_struct_begin("args");
10795 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10796 ::fbthrift::Serialize::write(&self.req, p);
10797 p.write_field_end();
10798 p.write_field_stop();
10799 p.write_struct_end();
10800 }
10801 }
10802
10803 struct Args_MetaService_getTag<'a> {
10804 req: &'a crate::types::GetTagReq,
10805 _phantom: ::std::marker::PhantomData<&'a ()>,
10806 }
10807
10808 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getTag<'a> {
10809 #[inline]
10810 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getTag"))]
10811 fn write(&self, p: &mut P) {
10812 p.write_struct_begin("args");
10813 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10814 ::fbthrift::Serialize::write(&self.req, p);
10815 p.write_field_end();
10816 p.write_field_stop();
10817 p.write_struct_end();
10818 }
10819 }
10820
10821 struct Args_MetaService_listTags<'a> {
10822 req: &'a crate::types::ListTagsReq,
10823 _phantom: ::std::marker::PhantomData<&'a ()>,
10824 }
10825
10826 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listTags<'a> {
10827 #[inline]
10828 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listTags"))]
10829 fn write(&self, p: &mut P) {
10830 p.write_struct_begin("args");
10831 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10832 ::fbthrift::Serialize::write(&self.req, p);
10833 p.write_field_end();
10834 p.write_field_stop();
10835 p.write_struct_end();
10836 }
10837 }
10838
10839 struct Args_MetaService_createEdge<'a> {
10840 req: &'a crate::types::CreateEdgeReq,
10841 _phantom: ::std::marker::PhantomData<&'a ()>,
10842 }
10843
10844 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_createEdge<'a> {
10845 #[inline]
10846 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.createEdge"))]
10847 fn write(&self, p: &mut P) {
10848 p.write_struct_begin("args");
10849 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10850 ::fbthrift::Serialize::write(&self.req, p);
10851 p.write_field_end();
10852 p.write_field_stop();
10853 p.write_struct_end();
10854 }
10855 }
10856
10857 struct Args_MetaService_alterEdge<'a> {
10858 req: &'a crate::types::AlterEdgeReq,
10859 _phantom: ::std::marker::PhantomData<&'a ()>,
10860 }
10861
10862 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_alterEdge<'a> {
10863 #[inline]
10864 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.alterEdge"))]
10865 fn write(&self, p: &mut P) {
10866 p.write_struct_begin("args");
10867 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10868 ::fbthrift::Serialize::write(&self.req, p);
10869 p.write_field_end();
10870 p.write_field_stop();
10871 p.write_struct_end();
10872 }
10873 }
10874
10875 struct Args_MetaService_dropEdge<'a> {
10876 req: &'a crate::types::DropEdgeReq,
10877 _phantom: ::std::marker::PhantomData<&'a ()>,
10878 }
10879
10880 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_dropEdge<'a> {
10881 #[inline]
10882 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.dropEdge"))]
10883 fn write(&self, p: &mut P) {
10884 p.write_struct_begin("args");
10885 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10886 ::fbthrift::Serialize::write(&self.req, p);
10887 p.write_field_end();
10888 p.write_field_stop();
10889 p.write_struct_end();
10890 }
10891 }
10892
10893 struct Args_MetaService_getEdge<'a> {
10894 req: &'a crate::types::GetEdgeReq,
10895 _phantom: ::std::marker::PhantomData<&'a ()>,
10896 }
10897
10898 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getEdge<'a> {
10899 #[inline]
10900 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getEdge"))]
10901 fn write(&self, p: &mut P) {
10902 p.write_struct_begin("args");
10903 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10904 ::fbthrift::Serialize::write(&self.req, p);
10905 p.write_field_end();
10906 p.write_field_stop();
10907 p.write_struct_end();
10908 }
10909 }
10910
10911 struct Args_MetaService_listEdges<'a> {
10912 req: &'a crate::types::ListEdgesReq,
10913 _phantom: ::std::marker::PhantomData<&'a ()>,
10914 }
10915
10916 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listEdges<'a> {
10917 #[inline]
10918 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listEdges"))]
10919 fn write(&self, p: &mut P) {
10920 p.write_struct_begin("args");
10921 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10922 ::fbthrift::Serialize::write(&self.req, p);
10923 p.write_field_end();
10924 p.write_field_stop();
10925 p.write_struct_end();
10926 }
10927 }
10928
10929 struct Args_MetaService_listHosts<'a> {
10930 req: &'a crate::types::ListHostsReq,
10931 _phantom: ::std::marker::PhantomData<&'a ()>,
10932 }
10933
10934 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listHosts<'a> {
10935 #[inline]
10936 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listHosts"))]
10937 fn write(&self, p: &mut P) {
10938 p.write_struct_begin("args");
10939 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10940 ::fbthrift::Serialize::write(&self.req, p);
10941 p.write_field_end();
10942 p.write_field_stop();
10943 p.write_struct_end();
10944 }
10945 }
10946
10947 struct Args_MetaService_getPartsAlloc<'a> {
10948 req: &'a crate::types::GetPartsAllocReq,
10949 _phantom: ::std::marker::PhantomData<&'a ()>,
10950 }
10951
10952 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getPartsAlloc<'a> {
10953 #[inline]
10954 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getPartsAlloc"))]
10955 fn write(&self, p: &mut P) {
10956 p.write_struct_begin("args");
10957 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10958 ::fbthrift::Serialize::write(&self.req, p);
10959 p.write_field_end();
10960 p.write_field_stop();
10961 p.write_struct_end();
10962 }
10963 }
10964
10965 struct Args_MetaService_listParts<'a> {
10966 req: &'a crate::types::ListPartsReq,
10967 _phantom: ::std::marker::PhantomData<&'a ()>,
10968 }
10969
10970 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listParts<'a> {
10971 #[inline]
10972 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listParts"))]
10973 fn write(&self, p: &mut P) {
10974 p.write_struct_begin("args");
10975 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10976 ::fbthrift::Serialize::write(&self.req, p);
10977 p.write_field_end();
10978 p.write_field_stop();
10979 p.write_struct_end();
10980 }
10981 }
10982
10983 struct Args_MetaService_multiPut<'a> {
10984 req: &'a crate::types::MultiPutReq,
10985 _phantom: ::std::marker::PhantomData<&'a ()>,
10986 }
10987
10988 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_multiPut<'a> {
10989 #[inline]
10990 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.multiPut"))]
10991 fn write(&self, p: &mut P) {
10992 p.write_struct_begin("args");
10993 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
10994 ::fbthrift::Serialize::write(&self.req, p);
10995 p.write_field_end();
10996 p.write_field_stop();
10997 p.write_struct_end();
10998 }
10999 }
11000
11001 struct Args_MetaService_get<'a> {
11002 req: &'a crate::types::GetReq,
11003 _phantom: ::std::marker::PhantomData<&'a ()>,
11004 }
11005
11006 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_get<'a> {
11007 #[inline]
11008 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.get"))]
11009 fn write(&self, p: &mut P) {
11010 p.write_struct_begin("args");
11011 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11012 ::fbthrift::Serialize::write(&self.req, p);
11013 p.write_field_end();
11014 p.write_field_stop();
11015 p.write_struct_end();
11016 }
11017 }
11018
11019 struct Args_MetaService_multiGet<'a> {
11020 req: &'a crate::types::MultiGetReq,
11021 _phantom: ::std::marker::PhantomData<&'a ()>,
11022 }
11023
11024 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_multiGet<'a> {
11025 #[inline]
11026 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.multiGet"))]
11027 fn write(&self, p: &mut P) {
11028 p.write_struct_begin("args");
11029 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11030 ::fbthrift::Serialize::write(&self.req, p);
11031 p.write_field_end();
11032 p.write_field_stop();
11033 p.write_struct_end();
11034 }
11035 }
11036
11037 struct Args_MetaService_remove<'a> {
11038 req: &'a crate::types::RemoveReq,
11039 _phantom: ::std::marker::PhantomData<&'a ()>,
11040 }
11041
11042 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_remove<'a> {
11043 #[inline]
11044 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.remove"))]
11045 fn write(&self, p: &mut P) {
11046 p.write_struct_begin("args");
11047 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11048 ::fbthrift::Serialize::write(&self.req, p);
11049 p.write_field_end();
11050 p.write_field_stop();
11051 p.write_struct_end();
11052 }
11053 }
11054
11055 struct Args_MetaService_removeRange<'a> {
11056 req: &'a crate::types::RemoveRangeReq,
11057 _phantom: ::std::marker::PhantomData<&'a ()>,
11058 }
11059
11060 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_removeRange<'a> {
11061 #[inline]
11062 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.removeRange"))]
11063 fn write(&self, p: &mut P) {
11064 p.write_struct_begin("args");
11065 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11066 ::fbthrift::Serialize::write(&self.req, p);
11067 p.write_field_end();
11068 p.write_field_stop();
11069 p.write_struct_end();
11070 }
11071 }
11072
11073 struct Args_MetaService_scan<'a> {
11074 req: &'a crate::types::ScanReq,
11075 _phantom: ::std::marker::PhantomData<&'a ()>,
11076 }
11077
11078 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_scan<'a> {
11079 #[inline]
11080 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.scan"))]
11081 fn write(&self, p: &mut P) {
11082 p.write_struct_begin("args");
11083 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11084 ::fbthrift::Serialize::write(&self.req, p);
11085 p.write_field_end();
11086 p.write_field_stop();
11087 p.write_struct_end();
11088 }
11089 }
11090
11091 struct Args_MetaService_createTagIndex<'a> {
11092 req: &'a crate::types::CreateTagIndexReq,
11093 _phantom: ::std::marker::PhantomData<&'a ()>,
11094 }
11095
11096 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_createTagIndex<'a> {
11097 #[inline]
11098 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.createTagIndex"))]
11099 fn write(&self, p: &mut P) {
11100 p.write_struct_begin("args");
11101 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11102 ::fbthrift::Serialize::write(&self.req, p);
11103 p.write_field_end();
11104 p.write_field_stop();
11105 p.write_struct_end();
11106 }
11107 }
11108
11109 struct Args_MetaService_dropTagIndex<'a> {
11110 req: &'a crate::types::DropTagIndexReq,
11111 _phantom: ::std::marker::PhantomData<&'a ()>,
11112 }
11113
11114 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_dropTagIndex<'a> {
11115 #[inline]
11116 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.dropTagIndex"))]
11117 fn write(&self, p: &mut P) {
11118 p.write_struct_begin("args");
11119 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11120 ::fbthrift::Serialize::write(&self.req, p);
11121 p.write_field_end();
11122 p.write_field_stop();
11123 p.write_struct_end();
11124 }
11125 }
11126
11127 struct Args_MetaService_getTagIndex<'a> {
11128 req: &'a crate::types::GetTagIndexReq,
11129 _phantom: ::std::marker::PhantomData<&'a ()>,
11130 }
11131
11132 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getTagIndex<'a> {
11133 #[inline]
11134 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getTagIndex"))]
11135 fn write(&self, p: &mut P) {
11136 p.write_struct_begin("args");
11137 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11138 ::fbthrift::Serialize::write(&self.req, p);
11139 p.write_field_end();
11140 p.write_field_stop();
11141 p.write_struct_end();
11142 }
11143 }
11144
11145 struct Args_MetaService_listTagIndexes<'a> {
11146 req: &'a crate::types::ListTagIndexesReq,
11147 _phantom: ::std::marker::PhantomData<&'a ()>,
11148 }
11149
11150 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listTagIndexes<'a> {
11151 #[inline]
11152 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listTagIndexes"))]
11153 fn write(&self, p: &mut P) {
11154 p.write_struct_begin("args");
11155 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11156 ::fbthrift::Serialize::write(&self.req, p);
11157 p.write_field_end();
11158 p.write_field_stop();
11159 p.write_struct_end();
11160 }
11161 }
11162
11163 struct Args_MetaService_rebuildTagIndex<'a> {
11164 req: &'a crate::types::RebuildIndexReq,
11165 _phantom: ::std::marker::PhantomData<&'a ()>,
11166 }
11167
11168 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_rebuildTagIndex<'a> {
11169 #[inline]
11170 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.rebuildTagIndex"))]
11171 fn write(&self, p: &mut P) {
11172 p.write_struct_begin("args");
11173 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11174 ::fbthrift::Serialize::write(&self.req, p);
11175 p.write_field_end();
11176 p.write_field_stop();
11177 p.write_struct_end();
11178 }
11179 }
11180
11181 struct Args_MetaService_listTagIndexStatus<'a> {
11182 req: &'a crate::types::ListIndexStatusReq,
11183 _phantom: ::std::marker::PhantomData<&'a ()>,
11184 }
11185
11186 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listTagIndexStatus<'a> {
11187 #[inline]
11188 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listTagIndexStatus"))]
11189 fn write(&self, p: &mut P) {
11190 p.write_struct_begin("args");
11191 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11192 ::fbthrift::Serialize::write(&self.req, p);
11193 p.write_field_end();
11194 p.write_field_stop();
11195 p.write_struct_end();
11196 }
11197 }
11198
11199 struct Args_MetaService_createEdgeIndex<'a> {
11200 req: &'a crate::types::CreateEdgeIndexReq,
11201 _phantom: ::std::marker::PhantomData<&'a ()>,
11202 }
11203
11204 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_createEdgeIndex<'a> {
11205 #[inline]
11206 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.createEdgeIndex"))]
11207 fn write(&self, p: &mut P) {
11208 p.write_struct_begin("args");
11209 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11210 ::fbthrift::Serialize::write(&self.req, p);
11211 p.write_field_end();
11212 p.write_field_stop();
11213 p.write_struct_end();
11214 }
11215 }
11216
11217 struct Args_MetaService_dropEdgeIndex<'a> {
11218 req: &'a crate::types::DropEdgeIndexReq,
11219 _phantom: ::std::marker::PhantomData<&'a ()>,
11220 }
11221
11222 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_dropEdgeIndex<'a> {
11223 #[inline]
11224 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.dropEdgeIndex"))]
11225 fn write(&self, p: &mut P) {
11226 p.write_struct_begin("args");
11227 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11228 ::fbthrift::Serialize::write(&self.req, p);
11229 p.write_field_end();
11230 p.write_field_stop();
11231 p.write_struct_end();
11232 }
11233 }
11234
11235 struct Args_MetaService_getEdgeIndex<'a> {
11236 req: &'a crate::types::GetEdgeIndexReq,
11237 _phantom: ::std::marker::PhantomData<&'a ()>,
11238 }
11239
11240 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getEdgeIndex<'a> {
11241 #[inline]
11242 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getEdgeIndex"))]
11243 fn write(&self, p: &mut P) {
11244 p.write_struct_begin("args");
11245 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11246 ::fbthrift::Serialize::write(&self.req, p);
11247 p.write_field_end();
11248 p.write_field_stop();
11249 p.write_struct_end();
11250 }
11251 }
11252
11253 struct Args_MetaService_listEdgeIndexes<'a> {
11254 req: &'a crate::types::ListEdgeIndexesReq,
11255 _phantom: ::std::marker::PhantomData<&'a ()>,
11256 }
11257
11258 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listEdgeIndexes<'a> {
11259 #[inline]
11260 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listEdgeIndexes"))]
11261 fn write(&self, p: &mut P) {
11262 p.write_struct_begin("args");
11263 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11264 ::fbthrift::Serialize::write(&self.req, p);
11265 p.write_field_end();
11266 p.write_field_stop();
11267 p.write_struct_end();
11268 }
11269 }
11270
11271 struct Args_MetaService_rebuildEdgeIndex<'a> {
11272 req: &'a crate::types::RebuildIndexReq,
11273 _phantom: ::std::marker::PhantomData<&'a ()>,
11274 }
11275
11276 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_rebuildEdgeIndex<'a> {
11277 #[inline]
11278 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.rebuildEdgeIndex"))]
11279 fn write(&self, p: &mut P) {
11280 p.write_struct_begin("args");
11281 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11282 ::fbthrift::Serialize::write(&self.req, p);
11283 p.write_field_end();
11284 p.write_field_stop();
11285 p.write_struct_end();
11286 }
11287 }
11288
11289 struct Args_MetaService_listEdgeIndexStatus<'a> {
11290 req: &'a crate::types::ListIndexStatusReq,
11291 _phantom: ::std::marker::PhantomData<&'a ()>,
11292 }
11293
11294 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listEdgeIndexStatus<'a> {
11295 #[inline]
11296 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listEdgeIndexStatus"))]
11297 fn write(&self, p: &mut P) {
11298 p.write_struct_begin("args");
11299 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11300 ::fbthrift::Serialize::write(&self.req, p);
11301 p.write_field_end();
11302 p.write_field_stop();
11303 p.write_struct_end();
11304 }
11305 }
11306
11307 struct Args_MetaService_createUser<'a> {
11308 req: &'a crate::types::CreateUserReq,
11309 _phantom: ::std::marker::PhantomData<&'a ()>,
11310 }
11311
11312 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_createUser<'a> {
11313 #[inline]
11314 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.createUser"))]
11315 fn write(&self, p: &mut P) {
11316 p.write_struct_begin("args");
11317 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11318 ::fbthrift::Serialize::write(&self.req, p);
11319 p.write_field_end();
11320 p.write_field_stop();
11321 p.write_struct_end();
11322 }
11323 }
11324
11325 struct Args_MetaService_dropUser<'a> {
11326 req: &'a crate::types::DropUserReq,
11327 _phantom: ::std::marker::PhantomData<&'a ()>,
11328 }
11329
11330 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_dropUser<'a> {
11331 #[inline]
11332 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.dropUser"))]
11333 fn write(&self, p: &mut P) {
11334 p.write_struct_begin("args");
11335 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11336 ::fbthrift::Serialize::write(&self.req, p);
11337 p.write_field_end();
11338 p.write_field_stop();
11339 p.write_struct_end();
11340 }
11341 }
11342
11343 struct Args_MetaService_alterUser<'a> {
11344 req: &'a crate::types::AlterUserReq,
11345 _phantom: ::std::marker::PhantomData<&'a ()>,
11346 }
11347
11348 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_alterUser<'a> {
11349 #[inline]
11350 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.alterUser"))]
11351 fn write(&self, p: &mut P) {
11352 p.write_struct_begin("args");
11353 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11354 ::fbthrift::Serialize::write(&self.req, p);
11355 p.write_field_end();
11356 p.write_field_stop();
11357 p.write_struct_end();
11358 }
11359 }
11360
11361 struct Args_MetaService_grantRole<'a> {
11362 req: &'a crate::types::GrantRoleReq,
11363 _phantom: ::std::marker::PhantomData<&'a ()>,
11364 }
11365
11366 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_grantRole<'a> {
11367 #[inline]
11368 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.grantRole"))]
11369 fn write(&self, p: &mut P) {
11370 p.write_struct_begin("args");
11371 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11372 ::fbthrift::Serialize::write(&self.req, p);
11373 p.write_field_end();
11374 p.write_field_stop();
11375 p.write_struct_end();
11376 }
11377 }
11378
11379 struct Args_MetaService_revokeRole<'a> {
11380 req: &'a crate::types::RevokeRoleReq,
11381 _phantom: ::std::marker::PhantomData<&'a ()>,
11382 }
11383
11384 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_revokeRole<'a> {
11385 #[inline]
11386 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.revokeRole"))]
11387 fn write(&self, p: &mut P) {
11388 p.write_struct_begin("args");
11389 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11390 ::fbthrift::Serialize::write(&self.req, p);
11391 p.write_field_end();
11392 p.write_field_stop();
11393 p.write_struct_end();
11394 }
11395 }
11396
11397 struct Args_MetaService_listUsers<'a> {
11398 req: &'a crate::types::ListUsersReq,
11399 _phantom: ::std::marker::PhantomData<&'a ()>,
11400 }
11401
11402 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listUsers<'a> {
11403 #[inline]
11404 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listUsers"))]
11405 fn write(&self, p: &mut P) {
11406 p.write_struct_begin("args");
11407 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11408 ::fbthrift::Serialize::write(&self.req, p);
11409 p.write_field_end();
11410 p.write_field_stop();
11411 p.write_struct_end();
11412 }
11413 }
11414
11415 struct Args_MetaService_listRoles<'a> {
11416 req: &'a crate::types::ListRolesReq,
11417 _phantom: ::std::marker::PhantomData<&'a ()>,
11418 }
11419
11420 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listRoles<'a> {
11421 #[inline]
11422 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listRoles"))]
11423 fn write(&self, p: &mut P) {
11424 p.write_struct_begin("args");
11425 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11426 ::fbthrift::Serialize::write(&self.req, p);
11427 p.write_field_end();
11428 p.write_field_stop();
11429 p.write_struct_end();
11430 }
11431 }
11432
11433 struct Args_MetaService_getUserRoles<'a> {
11434 req: &'a crate::types::GetUserRolesReq,
11435 _phantom: ::std::marker::PhantomData<&'a ()>,
11436 }
11437
11438 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getUserRoles<'a> {
11439 #[inline]
11440 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getUserRoles"))]
11441 fn write(&self, p: &mut P) {
11442 p.write_struct_begin("args");
11443 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11444 ::fbthrift::Serialize::write(&self.req, p);
11445 p.write_field_end();
11446 p.write_field_stop();
11447 p.write_struct_end();
11448 }
11449 }
11450
11451 struct Args_MetaService_changePassword<'a> {
11452 req: &'a crate::types::ChangePasswordReq,
11453 _phantom: ::std::marker::PhantomData<&'a ()>,
11454 }
11455
11456 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_changePassword<'a> {
11457 #[inline]
11458 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.changePassword"))]
11459 fn write(&self, p: &mut P) {
11460 p.write_struct_begin("args");
11461 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11462 ::fbthrift::Serialize::write(&self.req, p);
11463 p.write_field_end();
11464 p.write_field_stop();
11465 p.write_struct_end();
11466 }
11467 }
11468
11469 struct Args_MetaService_heartBeat<'a> {
11470 req: &'a crate::types::HBReq,
11471 _phantom: ::std::marker::PhantomData<&'a ()>,
11472 }
11473
11474 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_heartBeat<'a> {
11475 #[inline]
11476 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.heartBeat"))]
11477 fn write(&self, p: &mut P) {
11478 p.write_struct_begin("args");
11479 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11480 ::fbthrift::Serialize::write(&self.req, p);
11481 p.write_field_end();
11482 p.write_field_stop();
11483 p.write_struct_end();
11484 }
11485 }
11486
11487 struct Args_MetaService_balance<'a> {
11488 req: &'a crate::types::BalanceReq,
11489 _phantom: ::std::marker::PhantomData<&'a ()>,
11490 }
11491
11492 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_balance<'a> {
11493 #[inline]
11494 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.balance"))]
11495 fn write(&self, p: &mut P) {
11496 p.write_struct_begin("args");
11497 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11498 ::fbthrift::Serialize::write(&self.req, p);
11499 p.write_field_end();
11500 p.write_field_stop();
11501 p.write_struct_end();
11502 }
11503 }
11504
11505 struct Args_MetaService_leaderBalance<'a> {
11506 req: &'a crate::types::LeaderBalanceReq,
11507 _phantom: ::std::marker::PhantomData<&'a ()>,
11508 }
11509
11510 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_leaderBalance<'a> {
11511 #[inline]
11512 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.leaderBalance"))]
11513 fn write(&self, p: &mut P) {
11514 p.write_struct_begin("args");
11515 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11516 ::fbthrift::Serialize::write(&self.req, p);
11517 p.write_field_end();
11518 p.write_field_stop();
11519 p.write_struct_end();
11520 }
11521 }
11522
11523 struct Args_MetaService_regConfig<'a> {
11524 req: &'a crate::types::RegConfigReq,
11525 _phantom: ::std::marker::PhantomData<&'a ()>,
11526 }
11527
11528 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_regConfig<'a> {
11529 #[inline]
11530 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.regConfig"))]
11531 fn write(&self, p: &mut P) {
11532 p.write_struct_begin("args");
11533 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11534 ::fbthrift::Serialize::write(&self.req, p);
11535 p.write_field_end();
11536 p.write_field_stop();
11537 p.write_struct_end();
11538 }
11539 }
11540
11541 struct Args_MetaService_getConfig<'a> {
11542 req: &'a crate::types::GetConfigReq,
11543 _phantom: ::std::marker::PhantomData<&'a ()>,
11544 }
11545
11546 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_getConfig<'a> {
11547 #[inline]
11548 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.getConfig"))]
11549 fn write(&self, p: &mut P) {
11550 p.write_struct_begin("args");
11551 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11552 ::fbthrift::Serialize::write(&self.req, p);
11553 p.write_field_end();
11554 p.write_field_stop();
11555 p.write_struct_end();
11556 }
11557 }
11558
11559 struct Args_MetaService_setConfig<'a> {
11560 req: &'a crate::types::SetConfigReq,
11561 _phantom: ::std::marker::PhantomData<&'a ()>,
11562 }
11563
11564 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_setConfig<'a> {
11565 #[inline]
11566 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.setConfig"))]
11567 fn write(&self, p: &mut P) {
11568 p.write_struct_begin("args");
11569 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11570 ::fbthrift::Serialize::write(&self.req, p);
11571 p.write_field_end();
11572 p.write_field_stop();
11573 p.write_struct_end();
11574 }
11575 }
11576
11577 struct Args_MetaService_listConfigs<'a> {
11578 req: &'a crate::types::ListConfigsReq,
11579 _phantom: ::std::marker::PhantomData<&'a ()>,
11580 }
11581
11582 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listConfigs<'a> {
11583 #[inline]
11584 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listConfigs"))]
11585 fn write(&self, p: &mut P) {
11586 p.write_struct_begin("args");
11587 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11588 ::fbthrift::Serialize::write(&self.req, p);
11589 p.write_field_end();
11590 p.write_field_stop();
11591 p.write_struct_end();
11592 }
11593 }
11594
11595 struct Args_MetaService_createSnapshot<'a> {
11596 req: &'a crate::types::CreateSnapshotReq,
11597 _phantom: ::std::marker::PhantomData<&'a ()>,
11598 }
11599
11600 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_createSnapshot<'a> {
11601 #[inline]
11602 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.createSnapshot"))]
11603 fn write(&self, p: &mut P) {
11604 p.write_struct_begin("args");
11605 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11606 ::fbthrift::Serialize::write(&self.req, p);
11607 p.write_field_end();
11608 p.write_field_stop();
11609 p.write_struct_end();
11610 }
11611 }
11612
11613 struct Args_MetaService_dropSnapshot<'a> {
11614 req: &'a crate::types::DropSnapshotReq,
11615 _phantom: ::std::marker::PhantomData<&'a ()>,
11616 }
11617
11618 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_dropSnapshot<'a> {
11619 #[inline]
11620 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.dropSnapshot"))]
11621 fn write(&self, p: &mut P) {
11622 p.write_struct_begin("args");
11623 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11624 ::fbthrift::Serialize::write(&self.req, p);
11625 p.write_field_end();
11626 p.write_field_stop();
11627 p.write_struct_end();
11628 }
11629 }
11630
11631 struct Args_MetaService_listSnapshots<'a> {
11632 req: &'a crate::types::ListSnapshotsReq,
11633 _phantom: ::std::marker::PhantomData<&'a ()>,
11634 }
11635
11636 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_listSnapshots<'a> {
11637 #[inline]
11638 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.listSnapshots"))]
11639 fn write(&self, p: &mut P) {
11640 p.write_struct_begin("args");
11641 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11642 ::fbthrift::Serialize::write(&self.req, p);
11643 p.write_field_end();
11644 p.write_field_stop();
11645 p.write_struct_end();
11646 }
11647 }
11648
11649 struct Args_MetaService_runAdminJob<'a> {
11650 req: &'a crate::types::AdminJobReq,
11651 _phantom: ::std::marker::PhantomData<&'a ()>,
11652 }
11653
11654 impl<'a, P: ::fbthrift::ProtocolWriter> ::fbthrift::Serialize<P> for self::Args_MetaService_runAdminJob<'a> {
11655 #[inline]
11656 #[::tracing::instrument(skip_all, level = "trace", name = "serialize_args", fields(method = "MetaService.runAdminJob"))]
11657 fn write(&self, p: &mut P) {
11658 p.write_struct_begin("args");
11659 p.write_field_begin("req", ::fbthrift::TType::Struct, 1i16);
11660 ::fbthrift::Serialize::write(&self.req, p);
11661 p.write_field_end();
11662 p.write_field_stop();
11663 p.write_struct_end();
11664 }
11665 }
11666
11667 impl<P, T, S> MetaService for MetaServiceImpl<P, T, S>
11668 where
11669 P: ::fbthrift::Protocol,
11670 T: ::fbthrift::Transport,
11671 P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
11672 ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
11673 P::Deserializer: ::std::marker::Send,
11674 S: ::fbthrift::help::Spawner,
11675 {
11676 fn createSpace(
11677 &self,
11678 arg_req: &crate::types::CreateSpaceReq,
11679 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>> {
11680 let rpc_options = T::RpcOptions::default();
11681 self._createSpace_impl(
11682 arg_req,
11683 rpc_options,
11684 )
11685 }
11686 fn dropSpace(
11687 &self,
11688 arg_req: &crate::types::DropSpaceReq,
11689 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>> {
11690 let rpc_options = T::RpcOptions::default();
11691 self._dropSpace_impl(
11692 arg_req,
11693 rpc_options,
11694 )
11695 }
11696 fn getSpace(
11697 &self,
11698 arg_req: &crate::types::GetSpaceReq,
11699 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>> {
11700 let rpc_options = T::RpcOptions::default();
11701 self._getSpace_impl(
11702 arg_req,
11703 rpc_options,
11704 )
11705 }
11706 fn listSpaces(
11707 &self,
11708 arg_req: &crate::types::ListSpacesReq,
11709 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>> {
11710 let rpc_options = T::RpcOptions::default();
11711 self._listSpaces_impl(
11712 arg_req,
11713 rpc_options,
11714 )
11715 }
11716 fn createTag(
11717 &self,
11718 arg_req: &crate::types::CreateTagReq,
11719 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>> {
11720 let rpc_options = T::RpcOptions::default();
11721 self._createTag_impl(
11722 arg_req,
11723 rpc_options,
11724 )
11725 }
11726 fn alterTag(
11727 &self,
11728 arg_req: &crate::types::AlterTagReq,
11729 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>> {
11730 let rpc_options = T::RpcOptions::default();
11731 self._alterTag_impl(
11732 arg_req,
11733 rpc_options,
11734 )
11735 }
11736 fn dropTag(
11737 &self,
11738 arg_req: &crate::types::DropTagReq,
11739 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>> {
11740 let rpc_options = T::RpcOptions::default();
11741 self._dropTag_impl(
11742 arg_req,
11743 rpc_options,
11744 )
11745 }
11746 fn getTag(
11747 &self,
11748 arg_req: &crate::types::GetTagReq,
11749 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>> {
11750 let rpc_options = T::RpcOptions::default();
11751 self._getTag_impl(
11752 arg_req,
11753 rpc_options,
11754 )
11755 }
11756 fn listTags(
11757 &self,
11758 arg_req: &crate::types::ListTagsReq,
11759 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>> {
11760 let rpc_options = T::RpcOptions::default();
11761 self._listTags_impl(
11762 arg_req,
11763 rpc_options,
11764 )
11765 }
11766 fn createEdge(
11767 &self,
11768 arg_req: &crate::types::CreateEdgeReq,
11769 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>> {
11770 let rpc_options = T::RpcOptions::default();
11771 self._createEdge_impl(
11772 arg_req,
11773 rpc_options,
11774 )
11775 }
11776 fn alterEdge(
11777 &self,
11778 arg_req: &crate::types::AlterEdgeReq,
11779 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>> {
11780 let rpc_options = T::RpcOptions::default();
11781 self._alterEdge_impl(
11782 arg_req,
11783 rpc_options,
11784 )
11785 }
11786 fn dropEdge(
11787 &self,
11788 arg_req: &crate::types::DropEdgeReq,
11789 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>> {
11790 let rpc_options = T::RpcOptions::default();
11791 self._dropEdge_impl(
11792 arg_req,
11793 rpc_options,
11794 )
11795 }
11796 fn getEdge(
11797 &self,
11798 arg_req: &crate::types::GetEdgeReq,
11799 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>> {
11800 let rpc_options = T::RpcOptions::default();
11801 self._getEdge_impl(
11802 arg_req,
11803 rpc_options,
11804 )
11805 }
11806 fn listEdges(
11807 &self,
11808 arg_req: &crate::types::ListEdgesReq,
11809 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>> {
11810 let rpc_options = T::RpcOptions::default();
11811 self._listEdges_impl(
11812 arg_req,
11813 rpc_options,
11814 )
11815 }
11816 fn listHosts(
11817 &self,
11818 arg_req: &crate::types::ListHostsReq,
11819 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>> {
11820 let rpc_options = T::RpcOptions::default();
11821 self._listHosts_impl(
11822 arg_req,
11823 rpc_options,
11824 )
11825 }
11826 fn getPartsAlloc(
11827 &self,
11828 arg_req: &crate::types::GetPartsAllocReq,
11829 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>> {
11830 let rpc_options = T::RpcOptions::default();
11831 self._getPartsAlloc_impl(
11832 arg_req,
11833 rpc_options,
11834 )
11835 }
11836 fn listParts(
11837 &self,
11838 arg_req: &crate::types::ListPartsReq,
11839 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>> {
11840 let rpc_options = T::RpcOptions::default();
11841 self._listParts_impl(
11842 arg_req,
11843 rpc_options,
11844 )
11845 }
11846 fn multiPut(
11847 &self,
11848 arg_req: &crate::types::MultiPutReq,
11849 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>> {
11850 let rpc_options = T::RpcOptions::default();
11851 self._multiPut_impl(
11852 arg_req,
11853 rpc_options,
11854 )
11855 }
11856 fn get(
11857 &self,
11858 arg_req: &crate::types::GetReq,
11859 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>> {
11860 let rpc_options = T::RpcOptions::default();
11861 self._get_impl(
11862 arg_req,
11863 rpc_options,
11864 )
11865 }
11866 fn multiGet(
11867 &self,
11868 arg_req: &crate::types::MultiGetReq,
11869 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>> {
11870 let rpc_options = T::RpcOptions::default();
11871 self._multiGet_impl(
11872 arg_req,
11873 rpc_options,
11874 )
11875 }
11876 fn remove(
11877 &self,
11878 arg_req: &crate::types::RemoveReq,
11879 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>> {
11880 let rpc_options = T::RpcOptions::default();
11881 self._remove_impl(
11882 arg_req,
11883 rpc_options,
11884 )
11885 }
11886 fn removeRange(
11887 &self,
11888 arg_req: &crate::types::RemoveRangeReq,
11889 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>> {
11890 let rpc_options = T::RpcOptions::default();
11891 self._removeRange_impl(
11892 arg_req,
11893 rpc_options,
11894 )
11895 }
11896 fn scan(
11897 &self,
11898 arg_req: &crate::types::ScanReq,
11899 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>> {
11900 let rpc_options = T::RpcOptions::default();
11901 self._scan_impl(
11902 arg_req,
11903 rpc_options,
11904 )
11905 }
11906 fn createTagIndex(
11907 &self,
11908 arg_req: &crate::types::CreateTagIndexReq,
11909 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>> {
11910 let rpc_options = T::RpcOptions::default();
11911 self._createTagIndex_impl(
11912 arg_req,
11913 rpc_options,
11914 )
11915 }
11916 fn dropTagIndex(
11917 &self,
11918 arg_req: &crate::types::DropTagIndexReq,
11919 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>> {
11920 let rpc_options = T::RpcOptions::default();
11921 self._dropTagIndex_impl(
11922 arg_req,
11923 rpc_options,
11924 )
11925 }
11926 fn getTagIndex(
11927 &self,
11928 arg_req: &crate::types::GetTagIndexReq,
11929 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>> {
11930 let rpc_options = T::RpcOptions::default();
11931 self._getTagIndex_impl(
11932 arg_req,
11933 rpc_options,
11934 )
11935 }
11936 fn listTagIndexes(
11937 &self,
11938 arg_req: &crate::types::ListTagIndexesReq,
11939 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>> {
11940 let rpc_options = T::RpcOptions::default();
11941 self._listTagIndexes_impl(
11942 arg_req,
11943 rpc_options,
11944 )
11945 }
11946 fn rebuildTagIndex(
11947 &self,
11948 arg_req: &crate::types::RebuildIndexReq,
11949 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>> {
11950 let rpc_options = T::RpcOptions::default();
11951 self._rebuildTagIndex_impl(
11952 arg_req,
11953 rpc_options,
11954 )
11955 }
11956 fn listTagIndexStatus(
11957 &self,
11958 arg_req: &crate::types::ListIndexStatusReq,
11959 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>> {
11960 let rpc_options = T::RpcOptions::default();
11961 self._listTagIndexStatus_impl(
11962 arg_req,
11963 rpc_options,
11964 )
11965 }
11966 fn createEdgeIndex(
11967 &self,
11968 arg_req: &crate::types::CreateEdgeIndexReq,
11969 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>> {
11970 let rpc_options = T::RpcOptions::default();
11971 self._createEdgeIndex_impl(
11972 arg_req,
11973 rpc_options,
11974 )
11975 }
11976 fn dropEdgeIndex(
11977 &self,
11978 arg_req: &crate::types::DropEdgeIndexReq,
11979 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>> {
11980 let rpc_options = T::RpcOptions::default();
11981 self._dropEdgeIndex_impl(
11982 arg_req,
11983 rpc_options,
11984 )
11985 }
11986 fn getEdgeIndex(
11987 &self,
11988 arg_req: &crate::types::GetEdgeIndexReq,
11989 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>> {
11990 let rpc_options = T::RpcOptions::default();
11991 self._getEdgeIndex_impl(
11992 arg_req,
11993 rpc_options,
11994 )
11995 }
11996 fn listEdgeIndexes(
11997 &self,
11998 arg_req: &crate::types::ListEdgeIndexesReq,
11999 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>> {
12000 let rpc_options = T::RpcOptions::default();
12001 self._listEdgeIndexes_impl(
12002 arg_req,
12003 rpc_options,
12004 )
12005 }
12006 fn rebuildEdgeIndex(
12007 &self,
12008 arg_req: &crate::types::RebuildIndexReq,
12009 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>> {
12010 let rpc_options = T::RpcOptions::default();
12011 self._rebuildEdgeIndex_impl(
12012 arg_req,
12013 rpc_options,
12014 )
12015 }
12016 fn listEdgeIndexStatus(
12017 &self,
12018 arg_req: &crate::types::ListIndexStatusReq,
12019 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>> {
12020 let rpc_options = T::RpcOptions::default();
12021 self._listEdgeIndexStatus_impl(
12022 arg_req,
12023 rpc_options,
12024 )
12025 }
12026 fn createUser(
12027 &self,
12028 arg_req: &crate::types::CreateUserReq,
12029 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>> {
12030 let rpc_options = T::RpcOptions::default();
12031 self._createUser_impl(
12032 arg_req,
12033 rpc_options,
12034 )
12035 }
12036 fn dropUser(
12037 &self,
12038 arg_req: &crate::types::DropUserReq,
12039 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>> {
12040 let rpc_options = T::RpcOptions::default();
12041 self._dropUser_impl(
12042 arg_req,
12043 rpc_options,
12044 )
12045 }
12046 fn alterUser(
12047 &self,
12048 arg_req: &crate::types::AlterUserReq,
12049 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>> {
12050 let rpc_options = T::RpcOptions::default();
12051 self._alterUser_impl(
12052 arg_req,
12053 rpc_options,
12054 )
12055 }
12056 fn grantRole(
12057 &self,
12058 arg_req: &crate::types::GrantRoleReq,
12059 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>> {
12060 let rpc_options = T::RpcOptions::default();
12061 self._grantRole_impl(
12062 arg_req,
12063 rpc_options,
12064 )
12065 }
12066 fn revokeRole(
12067 &self,
12068 arg_req: &crate::types::RevokeRoleReq,
12069 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>> {
12070 let rpc_options = T::RpcOptions::default();
12071 self._revokeRole_impl(
12072 arg_req,
12073 rpc_options,
12074 )
12075 }
12076 fn listUsers(
12077 &self,
12078 arg_req: &crate::types::ListUsersReq,
12079 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>> {
12080 let rpc_options = T::RpcOptions::default();
12081 self._listUsers_impl(
12082 arg_req,
12083 rpc_options,
12084 )
12085 }
12086 fn listRoles(
12087 &self,
12088 arg_req: &crate::types::ListRolesReq,
12089 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>> {
12090 let rpc_options = T::RpcOptions::default();
12091 self._listRoles_impl(
12092 arg_req,
12093 rpc_options,
12094 )
12095 }
12096 fn getUserRoles(
12097 &self,
12098 arg_req: &crate::types::GetUserRolesReq,
12099 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>> {
12100 let rpc_options = T::RpcOptions::default();
12101 self._getUserRoles_impl(
12102 arg_req,
12103 rpc_options,
12104 )
12105 }
12106 fn changePassword(
12107 &self,
12108 arg_req: &crate::types::ChangePasswordReq,
12109 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>> {
12110 let rpc_options = T::RpcOptions::default();
12111 self._changePassword_impl(
12112 arg_req,
12113 rpc_options,
12114 )
12115 }
12116 fn heartBeat(
12117 &self,
12118 arg_req: &crate::types::HBReq,
12119 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>> {
12120 let rpc_options = T::RpcOptions::default();
12121 self._heartBeat_impl(
12122 arg_req,
12123 rpc_options,
12124 )
12125 }
12126 fn balance(
12127 &self,
12128 arg_req: &crate::types::BalanceReq,
12129 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>> {
12130 let rpc_options = T::RpcOptions::default();
12131 self._balance_impl(
12132 arg_req,
12133 rpc_options,
12134 )
12135 }
12136 fn leaderBalance(
12137 &self,
12138 arg_req: &crate::types::LeaderBalanceReq,
12139 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>> {
12140 let rpc_options = T::RpcOptions::default();
12141 self._leaderBalance_impl(
12142 arg_req,
12143 rpc_options,
12144 )
12145 }
12146 fn regConfig(
12147 &self,
12148 arg_req: &crate::types::RegConfigReq,
12149 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>> {
12150 let rpc_options = T::RpcOptions::default();
12151 self._regConfig_impl(
12152 arg_req,
12153 rpc_options,
12154 )
12155 }
12156 fn getConfig(
12157 &self,
12158 arg_req: &crate::types::GetConfigReq,
12159 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>> {
12160 let rpc_options = T::RpcOptions::default();
12161 self._getConfig_impl(
12162 arg_req,
12163 rpc_options,
12164 )
12165 }
12166 fn setConfig(
12167 &self,
12168 arg_req: &crate::types::SetConfigReq,
12169 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>> {
12170 let rpc_options = T::RpcOptions::default();
12171 self._setConfig_impl(
12172 arg_req,
12173 rpc_options,
12174 )
12175 }
12176 fn listConfigs(
12177 &self,
12178 arg_req: &crate::types::ListConfigsReq,
12179 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>> {
12180 let rpc_options = T::RpcOptions::default();
12181 self._listConfigs_impl(
12182 arg_req,
12183 rpc_options,
12184 )
12185 }
12186 fn createSnapshot(
12187 &self,
12188 arg_req: &crate::types::CreateSnapshotReq,
12189 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>> {
12190 let rpc_options = T::RpcOptions::default();
12191 self._createSnapshot_impl(
12192 arg_req,
12193 rpc_options,
12194 )
12195 }
12196 fn dropSnapshot(
12197 &self,
12198 arg_req: &crate::types::DropSnapshotReq,
12199 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>> {
12200 let rpc_options = T::RpcOptions::default();
12201 self._dropSnapshot_impl(
12202 arg_req,
12203 rpc_options,
12204 )
12205 }
12206 fn listSnapshots(
12207 &self,
12208 arg_req: &crate::types::ListSnapshotsReq,
12209 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>> {
12210 let rpc_options = T::RpcOptions::default();
12211 self._listSnapshots_impl(
12212 arg_req,
12213 rpc_options,
12214 )
12215 }
12216 fn runAdminJob(
12217 &self,
12218 arg_req: &crate::types::AdminJobReq,
12219 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>> {
12220 let rpc_options = T::RpcOptions::default();
12221 self._runAdminJob_impl(
12222 arg_req,
12223 rpc_options,
12224 )
12225 }
12226 }
12227
12228 impl<P, T, S> MetaServiceExt<T> for MetaServiceImpl<P, T, S>
12229 where
12230 P: ::fbthrift::Protocol,
12231 T: ::fbthrift::Transport,
12232 P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
12233 ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
12234 P::Deserializer: ::std::marker::Send,
12235 S: ::fbthrift::help::Spawner,
12236 {
12237 fn createSpace_with_rpc_opts(
12238 &self,
12239 arg_req: &crate::types::CreateSpaceReq,
12240 rpc_options: T::RpcOptions,
12241 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>> {
12242 self._createSpace_impl(
12243 arg_req,
12244 rpc_options,
12245 )
12246 }
12247 fn dropSpace_with_rpc_opts(
12248 &self,
12249 arg_req: &crate::types::DropSpaceReq,
12250 rpc_options: T::RpcOptions,
12251 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>> {
12252 self._dropSpace_impl(
12253 arg_req,
12254 rpc_options,
12255 )
12256 }
12257 fn getSpace_with_rpc_opts(
12258 &self,
12259 arg_req: &crate::types::GetSpaceReq,
12260 rpc_options: T::RpcOptions,
12261 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>> {
12262 self._getSpace_impl(
12263 arg_req,
12264 rpc_options,
12265 )
12266 }
12267 fn listSpaces_with_rpc_opts(
12268 &self,
12269 arg_req: &crate::types::ListSpacesReq,
12270 rpc_options: T::RpcOptions,
12271 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>> {
12272 self._listSpaces_impl(
12273 arg_req,
12274 rpc_options,
12275 )
12276 }
12277 fn createTag_with_rpc_opts(
12278 &self,
12279 arg_req: &crate::types::CreateTagReq,
12280 rpc_options: T::RpcOptions,
12281 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>> {
12282 self._createTag_impl(
12283 arg_req,
12284 rpc_options,
12285 )
12286 }
12287 fn alterTag_with_rpc_opts(
12288 &self,
12289 arg_req: &crate::types::AlterTagReq,
12290 rpc_options: T::RpcOptions,
12291 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>> {
12292 self._alterTag_impl(
12293 arg_req,
12294 rpc_options,
12295 )
12296 }
12297 fn dropTag_with_rpc_opts(
12298 &self,
12299 arg_req: &crate::types::DropTagReq,
12300 rpc_options: T::RpcOptions,
12301 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>> {
12302 self._dropTag_impl(
12303 arg_req,
12304 rpc_options,
12305 )
12306 }
12307 fn getTag_with_rpc_opts(
12308 &self,
12309 arg_req: &crate::types::GetTagReq,
12310 rpc_options: T::RpcOptions,
12311 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>> {
12312 self._getTag_impl(
12313 arg_req,
12314 rpc_options,
12315 )
12316 }
12317 fn listTags_with_rpc_opts(
12318 &self,
12319 arg_req: &crate::types::ListTagsReq,
12320 rpc_options: T::RpcOptions,
12321 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>> {
12322 self._listTags_impl(
12323 arg_req,
12324 rpc_options,
12325 )
12326 }
12327 fn createEdge_with_rpc_opts(
12328 &self,
12329 arg_req: &crate::types::CreateEdgeReq,
12330 rpc_options: T::RpcOptions,
12331 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>> {
12332 self._createEdge_impl(
12333 arg_req,
12334 rpc_options,
12335 )
12336 }
12337 fn alterEdge_with_rpc_opts(
12338 &self,
12339 arg_req: &crate::types::AlterEdgeReq,
12340 rpc_options: T::RpcOptions,
12341 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>> {
12342 self._alterEdge_impl(
12343 arg_req,
12344 rpc_options,
12345 )
12346 }
12347 fn dropEdge_with_rpc_opts(
12348 &self,
12349 arg_req: &crate::types::DropEdgeReq,
12350 rpc_options: T::RpcOptions,
12351 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>> {
12352 self._dropEdge_impl(
12353 arg_req,
12354 rpc_options,
12355 )
12356 }
12357 fn getEdge_with_rpc_opts(
12358 &self,
12359 arg_req: &crate::types::GetEdgeReq,
12360 rpc_options: T::RpcOptions,
12361 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>> {
12362 self._getEdge_impl(
12363 arg_req,
12364 rpc_options,
12365 )
12366 }
12367 fn listEdges_with_rpc_opts(
12368 &self,
12369 arg_req: &crate::types::ListEdgesReq,
12370 rpc_options: T::RpcOptions,
12371 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>> {
12372 self._listEdges_impl(
12373 arg_req,
12374 rpc_options,
12375 )
12376 }
12377 fn listHosts_with_rpc_opts(
12378 &self,
12379 arg_req: &crate::types::ListHostsReq,
12380 rpc_options: T::RpcOptions,
12381 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>> {
12382 self._listHosts_impl(
12383 arg_req,
12384 rpc_options,
12385 )
12386 }
12387 fn getPartsAlloc_with_rpc_opts(
12388 &self,
12389 arg_req: &crate::types::GetPartsAllocReq,
12390 rpc_options: T::RpcOptions,
12391 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>> {
12392 self._getPartsAlloc_impl(
12393 arg_req,
12394 rpc_options,
12395 )
12396 }
12397 fn listParts_with_rpc_opts(
12398 &self,
12399 arg_req: &crate::types::ListPartsReq,
12400 rpc_options: T::RpcOptions,
12401 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>> {
12402 self._listParts_impl(
12403 arg_req,
12404 rpc_options,
12405 )
12406 }
12407 fn multiPut_with_rpc_opts(
12408 &self,
12409 arg_req: &crate::types::MultiPutReq,
12410 rpc_options: T::RpcOptions,
12411 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>> {
12412 self._multiPut_impl(
12413 arg_req,
12414 rpc_options,
12415 )
12416 }
12417 fn get_with_rpc_opts(
12418 &self,
12419 arg_req: &crate::types::GetReq,
12420 rpc_options: T::RpcOptions,
12421 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>> {
12422 self._get_impl(
12423 arg_req,
12424 rpc_options,
12425 )
12426 }
12427 fn multiGet_with_rpc_opts(
12428 &self,
12429 arg_req: &crate::types::MultiGetReq,
12430 rpc_options: T::RpcOptions,
12431 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>> {
12432 self._multiGet_impl(
12433 arg_req,
12434 rpc_options,
12435 )
12436 }
12437 fn remove_with_rpc_opts(
12438 &self,
12439 arg_req: &crate::types::RemoveReq,
12440 rpc_options: T::RpcOptions,
12441 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>> {
12442 self._remove_impl(
12443 arg_req,
12444 rpc_options,
12445 )
12446 }
12447 fn removeRange_with_rpc_opts(
12448 &self,
12449 arg_req: &crate::types::RemoveRangeReq,
12450 rpc_options: T::RpcOptions,
12451 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>> {
12452 self._removeRange_impl(
12453 arg_req,
12454 rpc_options,
12455 )
12456 }
12457 fn scan_with_rpc_opts(
12458 &self,
12459 arg_req: &crate::types::ScanReq,
12460 rpc_options: T::RpcOptions,
12461 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>> {
12462 self._scan_impl(
12463 arg_req,
12464 rpc_options,
12465 )
12466 }
12467 fn createTagIndex_with_rpc_opts(
12468 &self,
12469 arg_req: &crate::types::CreateTagIndexReq,
12470 rpc_options: T::RpcOptions,
12471 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>> {
12472 self._createTagIndex_impl(
12473 arg_req,
12474 rpc_options,
12475 )
12476 }
12477 fn dropTagIndex_with_rpc_opts(
12478 &self,
12479 arg_req: &crate::types::DropTagIndexReq,
12480 rpc_options: T::RpcOptions,
12481 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>> {
12482 self._dropTagIndex_impl(
12483 arg_req,
12484 rpc_options,
12485 )
12486 }
12487 fn getTagIndex_with_rpc_opts(
12488 &self,
12489 arg_req: &crate::types::GetTagIndexReq,
12490 rpc_options: T::RpcOptions,
12491 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>> {
12492 self._getTagIndex_impl(
12493 arg_req,
12494 rpc_options,
12495 )
12496 }
12497 fn listTagIndexes_with_rpc_opts(
12498 &self,
12499 arg_req: &crate::types::ListTagIndexesReq,
12500 rpc_options: T::RpcOptions,
12501 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>> {
12502 self._listTagIndexes_impl(
12503 arg_req,
12504 rpc_options,
12505 )
12506 }
12507 fn rebuildTagIndex_with_rpc_opts(
12508 &self,
12509 arg_req: &crate::types::RebuildIndexReq,
12510 rpc_options: T::RpcOptions,
12511 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>> {
12512 self._rebuildTagIndex_impl(
12513 arg_req,
12514 rpc_options,
12515 )
12516 }
12517 fn listTagIndexStatus_with_rpc_opts(
12518 &self,
12519 arg_req: &crate::types::ListIndexStatusReq,
12520 rpc_options: T::RpcOptions,
12521 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>> {
12522 self._listTagIndexStatus_impl(
12523 arg_req,
12524 rpc_options,
12525 )
12526 }
12527 fn createEdgeIndex_with_rpc_opts(
12528 &self,
12529 arg_req: &crate::types::CreateEdgeIndexReq,
12530 rpc_options: T::RpcOptions,
12531 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>> {
12532 self._createEdgeIndex_impl(
12533 arg_req,
12534 rpc_options,
12535 )
12536 }
12537 fn dropEdgeIndex_with_rpc_opts(
12538 &self,
12539 arg_req: &crate::types::DropEdgeIndexReq,
12540 rpc_options: T::RpcOptions,
12541 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>> {
12542 self._dropEdgeIndex_impl(
12543 arg_req,
12544 rpc_options,
12545 )
12546 }
12547 fn getEdgeIndex_with_rpc_opts(
12548 &self,
12549 arg_req: &crate::types::GetEdgeIndexReq,
12550 rpc_options: T::RpcOptions,
12551 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>> {
12552 self._getEdgeIndex_impl(
12553 arg_req,
12554 rpc_options,
12555 )
12556 }
12557 fn listEdgeIndexes_with_rpc_opts(
12558 &self,
12559 arg_req: &crate::types::ListEdgeIndexesReq,
12560 rpc_options: T::RpcOptions,
12561 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>> {
12562 self._listEdgeIndexes_impl(
12563 arg_req,
12564 rpc_options,
12565 )
12566 }
12567 fn rebuildEdgeIndex_with_rpc_opts(
12568 &self,
12569 arg_req: &crate::types::RebuildIndexReq,
12570 rpc_options: T::RpcOptions,
12571 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>> {
12572 self._rebuildEdgeIndex_impl(
12573 arg_req,
12574 rpc_options,
12575 )
12576 }
12577 fn listEdgeIndexStatus_with_rpc_opts(
12578 &self,
12579 arg_req: &crate::types::ListIndexStatusReq,
12580 rpc_options: T::RpcOptions,
12581 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>> {
12582 self._listEdgeIndexStatus_impl(
12583 arg_req,
12584 rpc_options,
12585 )
12586 }
12587 fn createUser_with_rpc_opts(
12588 &self,
12589 arg_req: &crate::types::CreateUserReq,
12590 rpc_options: T::RpcOptions,
12591 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>> {
12592 self._createUser_impl(
12593 arg_req,
12594 rpc_options,
12595 )
12596 }
12597 fn dropUser_with_rpc_opts(
12598 &self,
12599 arg_req: &crate::types::DropUserReq,
12600 rpc_options: T::RpcOptions,
12601 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>> {
12602 self._dropUser_impl(
12603 arg_req,
12604 rpc_options,
12605 )
12606 }
12607 fn alterUser_with_rpc_opts(
12608 &self,
12609 arg_req: &crate::types::AlterUserReq,
12610 rpc_options: T::RpcOptions,
12611 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>> {
12612 self._alterUser_impl(
12613 arg_req,
12614 rpc_options,
12615 )
12616 }
12617 fn grantRole_with_rpc_opts(
12618 &self,
12619 arg_req: &crate::types::GrantRoleReq,
12620 rpc_options: T::RpcOptions,
12621 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>> {
12622 self._grantRole_impl(
12623 arg_req,
12624 rpc_options,
12625 )
12626 }
12627 fn revokeRole_with_rpc_opts(
12628 &self,
12629 arg_req: &crate::types::RevokeRoleReq,
12630 rpc_options: T::RpcOptions,
12631 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>> {
12632 self._revokeRole_impl(
12633 arg_req,
12634 rpc_options,
12635 )
12636 }
12637 fn listUsers_with_rpc_opts(
12638 &self,
12639 arg_req: &crate::types::ListUsersReq,
12640 rpc_options: T::RpcOptions,
12641 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>> {
12642 self._listUsers_impl(
12643 arg_req,
12644 rpc_options,
12645 )
12646 }
12647 fn listRoles_with_rpc_opts(
12648 &self,
12649 arg_req: &crate::types::ListRolesReq,
12650 rpc_options: T::RpcOptions,
12651 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>> {
12652 self._listRoles_impl(
12653 arg_req,
12654 rpc_options,
12655 )
12656 }
12657 fn getUserRoles_with_rpc_opts(
12658 &self,
12659 arg_req: &crate::types::GetUserRolesReq,
12660 rpc_options: T::RpcOptions,
12661 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>> {
12662 self._getUserRoles_impl(
12663 arg_req,
12664 rpc_options,
12665 )
12666 }
12667 fn changePassword_with_rpc_opts(
12668 &self,
12669 arg_req: &crate::types::ChangePasswordReq,
12670 rpc_options: T::RpcOptions,
12671 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>> {
12672 self._changePassword_impl(
12673 arg_req,
12674 rpc_options,
12675 )
12676 }
12677 fn heartBeat_with_rpc_opts(
12678 &self,
12679 arg_req: &crate::types::HBReq,
12680 rpc_options: T::RpcOptions,
12681 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>> {
12682 self._heartBeat_impl(
12683 arg_req,
12684 rpc_options,
12685 )
12686 }
12687 fn balance_with_rpc_opts(
12688 &self,
12689 arg_req: &crate::types::BalanceReq,
12690 rpc_options: T::RpcOptions,
12691 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>> {
12692 self._balance_impl(
12693 arg_req,
12694 rpc_options,
12695 )
12696 }
12697 fn leaderBalance_with_rpc_opts(
12698 &self,
12699 arg_req: &crate::types::LeaderBalanceReq,
12700 rpc_options: T::RpcOptions,
12701 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>> {
12702 self._leaderBalance_impl(
12703 arg_req,
12704 rpc_options,
12705 )
12706 }
12707 fn regConfig_with_rpc_opts(
12708 &self,
12709 arg_req: &crate::types::RegConfigReq,
12710 rpc_options: T::RpcOptions,
12711 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>> {
12712 self._regConfig_impl(
12713 arg_req,
12714 rpc_options,
12715 )
12716 }
12717 fn getConfig_with_rpc_opts(
12718 &self,
12719 arg_req: &crate::types::GetConfigReq,
12720 rpc_options: T::RpcOptions,
12721 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>> {
12722 self._getConfig_impl(
12723 arg_req,
12724 rpc_options,
12725 )
12726 }
12727 fn setConfig_with_rpc_opts(
12728 &self,
12729 arg_req: &crate::types::SetConfigReq,
12730 rpc_options: T::RpcOptions,
12731 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>> {
12732 self._setConfig_impl(
12733 arg_req,
12734 rpc_options,
12735 )
12736 }
12737 fn listConfigs_with_rpc_opts(
12738 &self,
12739 arg_req: &crate::types::ListConfigsReq,
12740 rpc_options: T::RpcOptions,
12741 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>> {
12742 self._listConfigs_impl(
12743 arg_req,
12744 rpc_options,
12745 )
12746 }
12747 fn createSnapshot_with_rpc_opts(
12748 &self,
12749 arg_req: &crate::types::CreateSnapshotReq,
12750 rpc_options: T::RpcOptions,
12751 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>> {
12752 self._createSnapshot_impl(
12753 arg_req,
12754 rpc_options,
12755 )
12756 }
12757 fn dropSnapshot_with_rpc_opts(
12758 &self,
12759 arg_req: &crate::types::DropSnapshotReq,
12760 rpc_options: T::RpcOptions,
12761 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>> {
12762 self._dropSnapshot_impl(
12763 arg_req,
12764 rpc_options,
12765 )
12766 }
12767 fn listSnapshots_with_rpc_opts(
12768 &self,
12769 arg_req: &crate::types::ListSnapshotsReq,
12770 rpc_options: T::RpcOptions,
12771 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>> {
12772 self._listSnapshots_impl(
12773 arg_req,
12774 rpc_options,
12775 )
12776 }
12777 fn runAdminJob_with_rpc_opts(
12778 &self,
12779 arg_req: &crate::types::AdminJobReq,
12780 rpc_options: T::RpcOptions,
12781 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>> {
12782 self._runAdminJob_impl(
12783 arg_req,
12784 rpc_options,
12785 )
12786 }
12787 }
12788
12789 impl<'a, S> MetaService for S
12790 where
12791 S: ::std::convert::AsRef<dyn MetaService + 'a>,
12792 S: ::std::marker::Send,
12793 {
12794 fn createSpace(
12795 &self,
12796 arg_req: &crate::types::CreateSpaceReq,
12797 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>> {
12798 self.as_ref().createSpace(
12799 arg_req,
12800 )
12801 }
12802 fn dropSpace(
12803 &self,
12804 arg_req: &crate::types::DropSpaceReq,
12805 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>> {
12806 self.as_ref().dropSpace(
12807 arg_req,
12808 )
12809 }
12810 fn getSpace(
12811 &self,
12812 arg_req: &crate::types::GetSpaceReq,
12813 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>> {
12814 self.as_ref().getSpace(
12815 arg_req,
12816 )
12817 }
12818 fn listSpaces(
12819 &self,
12820 arg_req: &crate::types::ListSpacesReq,
12821 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>> {
12822 self.as_ref().listSpaces(
12823 arg_req,
12824 )
12825 }
12826 fn createTag(
12827 &self,
12828 arg_req: &crate::types::CreateTagReq,
12829 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>> {
12830 self.as_ref().createTag(
12831 arg_req,
12832 )
12833 }
12834 fn alterTag(
12835 &self,
12836 arg_req: &crate::types::AlterTagReq,
12837 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>> {
12838 self.as_ref().alterTag(
12839 arg_req,
12840 )
12841 }
12842 fn dropTag(
12843 &self,
12844 arg_req: &crate::types::DropTagReq,
12845 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>> {
12846 self.as_ref().dropTag(
12847 arg_req,
12848 )
12849 }
12850 fn getTag(
12851 &self,
12852 arg_req: &crate::types::GetTagReq,
12853 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>> {
12854 self.as_ref().getTag(
12855 arg_req,
12856 )
12857 }
12858 fn listTags(
12859 &self,
12860 arg_req: &crate::types::ListTagsReq,
12861 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>> {
12862 self.as_ref().listTags(
12863 arg_req,
12864 )
12865 }
12866 fn createEdge(
12867 &self,
12868 arg_req: &crate::types::CreateEdgeReq,
12869 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>> {
12870 self.as_ref().createEdge(
12871 arg_req,
12872 )
12873 }
12874 fn alterEdge(
12875 &self,
12876 arg_req: &crate::types::AlterEdgeReq,
12877 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>> {
12878 self.as_ref().alterEdge(
12879 arg_req,
12880 )
12881 }
12882 fn dropEdge(
12883 &self,
12884 arg_req: &crate::types::DropEdgeReq,
12885 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>> {
12886 self.as_ref().dropEdge(
12887 arg_req,
12888 )
12889 }
12890 fn getEdge(
12891 &self,
12892 arg_req: &crate::types::GetEdgeReq,
12893 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>> {
12894 self.as_ref().getEdge(
12895 arg_req,
12896 )
12897 }
12898 fn listEdges(
12899 &self,
12900 arg_req: &crate::types::ListEdgesReq,
12901 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>> {
12902 self.as_ref().listEdges(
12903 arg_req,
12904 )
12905 }
12906 fn listHosts(
12907 &self,
12908 arg_req: &crate::types::ListHostsReq,
12909 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>> {
12910 self.as_ref().listHosts(
12911 arg_req,
12912 )
12913 }
12914 fn getPartsAlloc(
12915 &self,
12916 arg_req: &crate::types::GetPartsAllocReq,
12917 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>> {
12918 self.as_ref().getPartsAlloc(
12919 arg_req,
12920 )
12921 }
12922 fn listParts(
12923 &self,
12924 arg_req: &crate::types::ListPartsReq,
12925 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>> {
12926 self.as_ref().listParts(
12927 arg_req,
12928 )
12929 }
12930 fn multiPut(
12931 &self,
12932 arg_req: &crate::types::MultiPutReq,
12933 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>> {
12934 self.as_ref().multiPut(
12935 arg_req,
12936 )
12937 }
12938 fn get(
12939 &self,
12940 arg_req: &crate::types::GetReq,
12941 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>> {
12942 self.as_ref().get(
12943 arg_req,
12944 )
12945 }
12946 fn multiGet(
12947 &self,
12948 arg_req: &crate::types::MultiGetReq,
12949 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>> {
12950 self.as_ref().multiGet(
12951 arg_req,
12952 )
12953 }
12954 fn remove(
12955 &self,
12956 arg_req: &crate::types::RemoveReq,
12957 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>> {
12958 self.as_ref().remove(
12959 arg_req,
12960 )
12961 }
12962 fn removeRange(
12963 &self,
12964 arg_req: &crate::types::RemoveRangeReq,
12965 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>> {
12966 self.as_ref().removeRange(
12967 arg_req,
12968 )
12969 }
12970 fn scan(
12971 &self,
12972 arg_req: &crate::types::ScanReq,
12973 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>> {
12974 self.as_ref().scan(
12975 arg_req,
12976 )
12977 }
12978 fn createTagIndex(
12979 &self,
12980 arg_req: &crate::types::CreateTagIndexReq,
12981 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>> {
12982 self.as_ref().createTagIndex(
12983 arg_req,
12984 )
12985 }
12986 fn dropTagIndex(
12987 &self,
12988 arg_req: &crate::types::DropTagIndexReq,
12989 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>> {
12990 self.as_ref().dropTagIndex(
12991 arg_req,
12992 )
12993 }
12994 fn getTagIndex(
12995 &self,
12996 arg_req: &crate::types::GetTagIndexReq,
12997 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>> {
12998 self.as_ref().getTagIndex(
12999 arg_req,
13000 )
13001 }
13002 fn listTagIndexes(
13003 &self,
13004 arg_req: &crate::types::ListTagIndexesReq,
13005 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>> {
13006 self.as_ref().listTagIndexes(
13007 arg_req,
13008 )
13009 }
13010 fn rebuildTagIndex(
13011 &self,
13012 arg_req: &crate::types::RebuildIndexReq,
13013 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>> {
13014 self.as_ref().rebuildTagIndex(
13015 arg_req,
13016 )
13017 }
13018 fn listTagIndexStatus(
13019 &self,
13020 arg_req: &crate::types::ListIndexStatusReq,
13021 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>> {
13022 self.as_ref().listTagIndexStatus(
13023 arg_req,
13024 )
13025 }
13026 fn createEdgeIndex(
13027 &self,
13028 arg_req: &crate::types::CreateEdgeIndexReq,
13029 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>> {
13030 self.as_ref().createEdgeIndex(
13031 arg_req,
13032 )
13033 }
13034 fn dropEdgeIndex(
13035 &self,
13036 arg_req: &crate::types::DropEdgeIndexReq,
13037 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>> {
13038 self.as_ref().dropEdgeIndex(
13039 arg_req,
13040 )
13041 }
13042 fn getEdgeIndex(
13043 &self,
13044 arg_req: &crate::types::GetEdgeIndexReq,
13045 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>> {
13046 self.as_ref().getEdgeIndex(
13047 arg_req,
13048 )
13049 }
13050 fn listEdgeIndexes(
13051 &self,
13052 arg_req: &crate::types::ListEdgeIndexesReq,
13053 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>> {
13054 self.as_ref().listEdgeIndexes(
13055 arg_req,
13056 )
13057 }
13058 fn rebuildEdgeIndex(
13059 &self,
13060 arg_req: &crate::types::RebuildIndexReq,
13061 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>> {
13062 self.as_ref().rebuildEdgeIndex(
13063 arg_req,
13064 )
13065 }
13066 fn listEdgeIndexStatus(
13067 &self,
13068 arg_req: &crate::types::ListIndexStatusReq,
13069 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>> {
13070 self.as_ref().listEdgeIndexStatus(
13071 arg_req,
13072 )
13073 }
13074 fn createUser(
13075 &self,
13076 arg_req: &crate::types::CreateUserReq,
13077 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>> {
13078 self.as_ref().createUser(
13079 arg_req,
13080 )
13081 }
13082 fn dropUser(
13083 &self,
13084 arg_req: &crate::types::DropUserReq,
13085 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>> {
13086 self.as_ref().dropUser(
13087 arg_req,
13088 )
13089 }
13090 fn alterUser(
13091 &self,
13092 arg_req: &crate::types::AlterUserReq,
13093 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>> {
13094 self.as_ref().alterUser(
13095 arg_req,
13096 )
13097 }
13098 fn grantRole(
13099 &self,
13100 arg_req: &crate::types::GrantRoleReq,
13101 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>> {
13102 self.as_ref().grantRole(
13103 arg_req,
13104 )
13105 }
13106 fn revokeRole(
13107 &self,
13108 arg_req: &crate::types::RevokeRoleReq,
13109 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>> {
13110 self.as_ref().revokeRole(
13111 arg_req,
13112 )
13113 }
13114 fn listUsers(
13115 &self,
13116 arg_req: &crate::types::ListUsersReq,
13117 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>> {
13118 self.as_ref().listUsers(
13119 arg_req,
13120 )
13121 }
13122 fn listRoles(
13123 &self,
13124 arg_req: &crate::types::ListRolesReq,
13125 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>> {
13126 self.as_ref().listRoles(
13127 arg_req,
13128 )
13129 }
13130 fn getUserRoles(
13131 &self,
13132 arg_req: &crate::types::GetUserRolesReq,
13133 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>> {
13134 self.as_ref().getUserRoles(
13135 arg_req,
13136 )
13137 }
13138 fn changePassword(
13139 &self,
13140 arg_req: &crate::types::ChangePasswordReq,
13141 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>> {
13142 self.as_ref().changePassword(
13143 arg_req,
13144 )
13145 }
13146 fn heartBeat(
13147 &self,
13148 arg_req: &crate::types::HBReq,
13149 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>> {
13150 self.as_ref().heartBeat(
13151 arg_req,
13152 )
13153 }
13154 fn balance(
13155 &self,
13156 arg_req: &crate::types::BalanceReq,
13157 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>> {
13158 self.as_ref().balance(
13159 arg_req,
13160 )
13161 }
13162 fn leaderBalance(
13163 &self,
13164 arg_req: &crate::types::LeaderBalanceReq,
13165 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>> {
13166 self.as_ref().leaderBalance(
13167 arg_req,
13168 )
13169 }
13170 fn regConfig(
13171 &self,
13172 arg_req: &crate::types::RegConfigReq,
13173 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>> {
13174 self.as_ref().regConfig(
13175 arg_req,
13176 )
13177 }
13178 fn getConfig(
13179 &self,
13180 arg_req: &crate::types::GetConfigReq,
13181 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>> {
13182 self.as_ref().getConfig(
13183 arg_req,
13184 )
13185 }
13186 fn setConfig(
13187 &self,
13188 arg_req: &crate::types::SetConfigReq,
13189 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>> {
13190 self.as_ref().setConfig(
13191 arg_req,
13192 )
13193 }
13194 fn listConfigs(
13195 &self,
13196 arg_req: &crate::types::ListConfigsReq,
13197 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>> {
13198 self.as_ref().listConfigs(
13199 arg_req,
13200 )
13201 }
13202 fn createSnapshot(
13203 &self,
13204 arg_req: &crate::types::CreateSnapshotReq,
13205 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>> {
13206 self.as_ref().createSnapshot(
13207 arg_req,
13208 )
13209 }
13210 fn dropSnapshot(
13211 &self,
13212 arg_req: &crate::types::DropSnapshotReq,
13213 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>> {
13214 self.as_ref().dropSnapshot(
13215 arg_req,
13216 )
13217 }
13218 fn listSnapshots(
13219 &self,
13220 arg_req: &crate::types::ListSnapshotsReq,
13221 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>> {
13222 self.as_ref().listSnapshots(
13223 arg_req,
13224 )
13225 }
13226 fn runAdminJob(
13227 &self,
13228 arg_req: &crate::types::AdminJobReq,
13229 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>> {
13230 self.as_ref().runAdminJob(
13231 arg_req,
13232 )
13233 }
13234 }
13235
13236 impl<'a, S, T> MetaServiceExt<T> for S
13237 where
13238 S: ::std::convert::AsRef<dyn MetaService + 'a>,
13239 S: ::std::convert::AsRef<dyn MetaServiceExt<T> + 'a>,
13240 S: ::std::marker::Send,
13241 T: ::fbthrift::Transport,
13242 {
13243 fn createSpace_with_rpc_opts(
13244 &self,
13245 arg_req: &crate::types::CreateSpaceReq,
13246 rpc_options: T::RpcOptions,
13247 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>> {
13248 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).createSpace_with_rpc_opts(
13249 arg_req,
13250 rpc_options,
13251 )
13252 }
13253 fn dropSpace_with_rpc_opts(
13254 &self,
13255 arg_req: &crate::types::DropSpaceReq,
13256 rpc_options: T::RpcOptions,
13257 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>> {
13258 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).dropSpace_with_rpc_opts(
13259 arg_req,
13260 rpc_options,
13261 )
13262 }
13263 fn getSpace_with_rpc_opts(
13264 &self,
13265 arg_req: &crate::types::GetSpaceReq,
13266 rpc_options: T::RpcOptions,
13267 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>> {
13268 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getSpace_with_rpc_opts(
13269 arg_req,
13270 rpc_options,
13271 )
13272 }
13273 fn listSpaces_with_rpc_opts(
13274 &self,
13275 arg_req: &crate::types::ListSpacesReq,
13276 rpc_options: T::RpcOptions,
13277 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>> {
13278 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listSpaces_with_rpc_opts(
13279 arg_req,
13280 rpc_options,
13281 )
13282 }
13283 fn createTag_with_rpc_opts(
13284 &self,
13285 arg_req: &crate::types::CreateTagReq,
13286 rpc_options: T::RpcOptions,
13287 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>> {
13288 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).createTag_with_rpc_opts(
13289 arg_req,
13290 rpc_options,
13291 )
13292 }
13293 fn alterTag_with_rpc_opts(
13294 &self,
13295 arg_req: &crate::types::AlterTagReq,
13296 rpc_options: T::RpcOptions,
13297 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>> {
13298 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).alterTag_with_rpc_opts(
13299 arg_req,
13300 rpc_options,
13301 )
13302 }
13303 fn dropTag_with_rpc_opts(
13304 &self,
13305 arg_req: &crate::types::DropTagReq,
13306 rpc_options: T::RpcOptions,
13307 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>> {
13308 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).dropTag_with_rpc_opts(
13309 arg_req,
13310 rpc_options,
13311 )
13312 }
13313 fn getTag_with_rpc_opts(
13314 &self,
13315 arg_req: &crate::types::GetTagReq,
13316 rpc_options: T::RpcOptions,
13317 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>> {
13318 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getTag_with_rpc_opts(
13319 arg_req,
13320 rpc_options,
13321 )
13322 }
13323 fn listTags_with_rpc_opts(
13324 &self,
13325 arg_req: &crate::types::ListTagsReq,
13326 rpc_options: T::RpcOptions,
13327 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>> {
13328 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listTags_with_rpc_opts(
13329 arg_req,
13330 rpc_options,
13331 )
13332 }
13333 fn createEdge_with_rpc_opts(
13334 &self,
13335 arg_req: &crate::types::CreateEdgeReq,
13336 rpc_options: T::RpcOptions,
13337 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>> {
13338 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).createEdge_with_rpc_opts(
13339 arg_req,
13340 rpc_options,
13341 )
13342 }
13343 fn alterEdge_with_rpc_opts(
13344 &self,
13345 arg_req: &crate::types::AlterEdgeReq,
13346 rpc_options: T::RpcOptions,
13347 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>> {
13348 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).alterEdge_with_rpc_opts(
13349 arg_req,
13350 rpc_options,
13351 )
13352 }
13353 fn dropEdge_with_rpc_opts(
13354 &self,
13355 arg_req: &crate::types::DropEdgeReq,
13356 rpc_options: T::RpcOptions,
13357 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>> {
13358 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).dropEdge_with_rpc_opts(
13359 arg_req,
13360 rpc_options,
13361 )
13362 }
13363 fn getEdge_with_rpc_opts(
13364 &self,
13365 arg_req: &crate::types::GetEdgeReq,
13366 rpc_options: T::RpcOptions,
13367 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>> {
13368 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getEdge_with_rpc_opts(
13369 arg_req,
13370 rpc_options,
13371 )
13372 }
13373 fn listEdges_with_rpc_opts(
13374 &self,
13375 arg_req: &crate::types::ListEdgesReq,
13376 rpc_options: T::RpcOptions,
13377 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>> {
13378 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listEdges_with_rpc_opts(
13379 arg_req,
13380 rpc_options,
13381 )
13382 }
13383 fn listHosts_with_rpc_opts(
13384 &self,
13385 arg_req: &crate::types::ListHostsReq,
13386 rpc_options: T::RpcOptions,
13387 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>> {
13388 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listHosts_with_rpc_opts(
13389 arg_req,
13390 rpc_options,
13391 )
13392 }
13393 fn getPartsAlloc_with_rpc_opts(
13394 &self,
13395 arg_req: &crate::types::GetPartsAllocReq,
13396 rpc_options: T::RpcOptions,
13397 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>> {
13398 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getPartsAlloc_with_rpc_opts(
13399 arg_req,
13400 rpc_options,
13401 )
13402 }
13403 fn listParts_with_rpc_opts(
13404 &self,
13405 arg_req: &crate::types::ListPartsReq,
13406 rpc_options: T::RpcOptions,
13407 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>> {
13408 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listParts_with_rpc_opts(
13409 arg_req,
13410 rpc_options,
13411 )
13412 }
13413 fn multiPut_with_rpc_opts(
13414 &self,
13415 arg_req: &crate::types::MultiPutReq,
13416 rpc_options: T::RpcOptions,
13417 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>> {
13418 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).multiPut_with_rpc_opts(
13419 arg_req,
13420 rpc_options,
13421 )
13422 }
13423 fn get_with_rpc_opts(
13424 &self,
13425 arg_req: &crate::types::GetReq,
13426 rpc_options: T::RpcOptions,
13427 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>> {
13428 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).get_with_rpc_opts(
13429 arg_req,
13430 rpc_options,
13431 )
13432 }
13433 fn multiGet_with_rpc_opts(
13434 &self,
13435 arg_req: &crate::types::MultiGetReq,
13436 rpc_options: T::RpcOptions,
13437 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>> {
13438 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).multiGet_with_rpc_opts(
13439 arg_req,
13440 rpc_options,
13441 )
13442 }
13443 fn remove_with_rpc_opts(
13444 &self,
13445 arg_req: &crate::types::RemoveReq,
13446 rpc_options: T::RpcOptions,
13447 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>> {
13448 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).remove_with_rpc_opts(
13449 arg_req,
13450 rpc_options,
13451 )
13452 }
13453 fn removeRange_with_rpc_opts(
13454 &self,
13455 arg_req: &crate::types::RemoveRangeReq,
13456 rpc_options: T::RpcOptions,
13457 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>> {
13458 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).removeRange_with_rpc_opts(
13459 arg_req,
13460 rpc_options,
13461 )
13462 }
13463 fn scan_with_rpc_opts(
13464 &self,
13465 arg_req: &crate::types::ScanReq,
13466 rpc_options: T::RpcOptions,
13467 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>> {
13468 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).scan_with_rpc_opts(
13469 arg_req,
13470 rpc_options,
13471 )
13472 }
13473 fn createTagIndex_with_rpc_opts(
13474 &self,
13475 arg_req: &crate::types::CreateTagIndexReq,
13476 rpc_options: T::RpcOptions,
13477 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>> {
13478 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).createTagIndex_with_rpc_opts(
13479 arg_req,
13480 rpc_options,
13481 )
13482 }
13483 fn dropTagIndex_with_rpc_opts(
13484 &self,
13485 arg_req: &crate::types::DropTagIndexReq,
13486 rpc_options: T::RpcOptions,
13487 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>> {
13488 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).dropTagIndex_with_rpc_opts(
13489 arg_req,
13490 rpc_options,
13491 )
13492 }
13493 fn getTagIndex_with_rpc_opts(
13494 &self,
13495 arg_req: &crate::types::GetTagIndexReq,
13496 rpc_options: T::RpcOptions,
13497 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>> {
13498 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getTagIndex_with_rpc_opts(
13499 arg_req,
13500 rpc_options,
13501 )
13502 }
13503 fn listTagIndexes_with_rpc_opts(
13504 &self,
13505 arg_req: &crate::types::ListTagIndexesReq,
13506 rpc_options: T::RpcOptions,
13507 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>> {
13508 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listTagIndexes_with_rpc_opts(
13509 arg_req,
13510 rpc_options,
13511 )
13512 }
13513 fn rebuildTagIndex_with_rpc_opts(
13514 &self,
13515 arg_req: &crate::types::RebuildIndexReq,
13516 rpc_options: T::RpcOptions,
13517 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>> {
13518 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).rebuildTagIndex_with_rpc_opts(
13519 arg_req,
13520 rpc_options,
13521 )
13522 }
13523 fn listTagIndexStatus_with_rpc_opts(
13524 &self,
13525 arg_req: &crate::types::ListIndexStatusReq,
13526 rpc_options: T::RpcOptions,
13527 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>> {
13528 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listTagIndexStatus_with_rpc_opts(
13529 arg_req,
13530 rpc_options,
13531 )
13532 }
13533 fn createEdgeIndex_with_rpc_opts(
13534 &self,
13535 arg_req: &crate::types::CreateEdgeIndexReq,
13536 rpc_options: T::RpcOptions,
13537 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>> {
13538 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).createEdgeIndex_with_rpc_opts(
13539 arg_req,
13540 rpc_options,
13541 )
13542 }
13543 fn dropEdgeIndex_with_rpc_opts(
13544 &self,
13545 arg_req: &crate::types::DropEdgeIndexReq,
13546 rpc_options: T::RpcOptions,
13547 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>> {
13548 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).dropEdgeIndex_with_rpc_opts(
13549 arg_req,
13550 rpc_options,
13551 )
13552 }
13553 fn getEdgeIndex_with_rpc_opts(
13554 &self,
13555 arg_req: &crate::types::GetEdgeIndexReq,
13556 rpc_options: T::RpcOptions,
13557 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>> {
13558 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getEdgeIndex_with_rpc_opts(
13559 arg_req,
13560 rpc_options,
13561 )
13562 }
13563 fn listEdgeIndexes_with_rpc_opts(
13564 &self,
13565 arg_req: &crate::types::ListEdgeIndexesReq,
13566 rpc_options: T::RpcOptions,
13567 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>> {
13568 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listEdgeIndexes_with_rpc_opts(
13569 arg_req,
13570 rpc_options,
13571 )
13572 }
13573 fn rebuildEdgeIndex_with_rpc_opts(
13574 &self,
13575 arg_req: &crate::types::RebuildIndexReq,
13576 rpc_options: T::RpcOptions,
13577 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>> {
13578 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).rebuildEdgeIndex_with_rpc_opts(
13579 arg_req,
13580 rpc_options,
13581 )
13582 }
13583 fn listEdgeIndexStatus_with_rpc_opts(
13584 &self,
13585 arg_req: &crate::types::ListIndexStatusReq,
13586 rpc_options: T::RpcOptions,
13587 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>> {
13588 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listEdgeIndexStatus_with_rpc_opts(
13589 arg_req,
13590 rpc_options,
13591 )
13592 }
13593 fn createUser_with_rpc_opts(
13594 &self,
13595 arg_req: &crate::types::CreateUserReq,
13596 rpc_options: T::RpcOptions,
13597 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>> {
13598 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).createUser_with_rpc_opts(
13599 arg_req,
13600 rpc_options,
13601 )
13602 }
13603 fn dropUser_with_rpc_opts(
13604 &self,
13605 arg_req: &crate::types::DropUserReq,
13606 rpc_options: T::RpcOptions,
13607 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>> {
13608 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).dropUser_with_rpc_opts(
13609 arg_req,
13610 rpc_options,
13611 )
13612 }
13613 fn alterUser_with_rpc_opts(
13614 &self,
13615 arg_req: &crate::types::AlterUserReq,
13616 rpc_options: T::RpcOptions,
13617 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>> {
13618 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).alterUser_with_rpc_opts(
13619 arg_req,
13620 rpc_options,
13621 )
13622 }
13623 fn grantRole_with_rpc_opts(
13624 &self,
13625 arg_req: &crate::types::GrantRoleReq,
13626 rpc_options: T::RpcOptions,
13627 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>> {
13628 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).grantRole_with_rpc_opts(
13629 arg_req,
13630 rpc_options,
13631 )
13632 }
13633 fn revokeRole_with_rpc_opts(
13634 &self,
13635 arg_req: &crate::types::RevokeRoleReq,
13636 rpc_options: T::RpcOptions,
13637 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>> {
13638 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).revokeRole_with_rpc_opts(
13639 arg_req,
13640 rpc_options,
13641 )
13642 }
13643 fn listUsers_with_rpc_opts(
13644 &self,
13645 arg_req: &crate::types::ListUsersReq,
13646 rpc_options: T::RpcOptions,
13647 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>> {
13648 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listUsers_with_rpc_opts(
13649 arg_req,
13650 rpc_options,
13651 )
13652 }
13653 fn listRoles_with_rpc_opts(
13654 &self,
13655 arg_req: &crate::types::ListRolesReq,
13656 rpc_options: T::RpcOptions,
13657 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>> {
13658 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listRoles_with_rpc_opts(
13659 arg_req,
13660 rpc_options,
13661 )
13662 }
13663 fn getUserRoles_with_rpc_opts(
13664 &self,
13665 arg_req: &crate::types::GetUserRolesReq,
13666 rpc_options: T::RpcOptions,
13667 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>> {
13668 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getUserRoles_with_rpc_opts(
13669 arg_req,
13670 rpc_options,
13671 )
13672 }
13673 fn changePassword_with_rpc_opts(
13674 &self,
13675 arg_req: &crate::types::ChangePasswordReq,
13676 rpc_options: T::RpcOptions,
13677 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>> {
13678 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).changePassword_with_rpc_opts(
13679 arg_req,
13680 rpc_options,
13681 )
13682 }
13683 fn heartBeat_with_rpc_opts(
13684 &self,
13685 arg_req: &crate::types::HBReq,
13686 rpc_options: T::RpcOptions,
13687 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>> {
13688 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).heartBeat_with_rpc_opts(
13689 arg_req,
13690 rpc_options,
13691 )
13692 }
13693 fn balance_with_rpc_opts(
13694 &self,
13695 arg_req: &crate::types::BalanceReq,
13696 rpc_options: T::RpcOptions,
13697 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>> {
13698 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).balance_with_rpc_opts(
13699 arg_req,
13700 rpc_options,
13701 )
13702 }
13703 fn leaderBalance_with_rpc_opts(
13704 &self,
13705 arg_req: &crate::types::LeaderBalanceReq,
13706 rpc_options: T::RpcOptions,
13707 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>> {
13708 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).leaderBalance_with_rpc_opts(
13709 arg_req,
13710 rpc_options,
13711 )
13712 }
13713 fn regConfig_with_rpc_opts(
13714 &self,
13715 arg_req: &crate::types::RegConfigReq,
13716 rpc_options: T::RpcOptions,
13717 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>> {
13718 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).regConfig_with_rpc_opts(
13719 arg_req,
13720 rpc_options,
13721 )
13722 }
13723 fn getConfig_with_rpc_opts(
13724 &self,
13725 arg_req: &crate::types::GetConfigReq,
13726 rpc_options: T::RpcOptions,
13727 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>> {
13728 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).getConfig_with_rpc_opts(
13729 arg_req,
13730 rpc_options,
13731 )
13732 }
13733 fn setConfig_with_rpc_opts(
13734 &self,
13735 arg_req: &crate::types::SetConfigReq,
13736 rpc_options: T::RpcOptions,
13737 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>> {
13738 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).setConfig_with_rpc_opts(
13739 arg_req,
13740 rpc_options,
13741 )
13742 }
13743 fn listConfigs_with_rpc_opts(
13744 &self,
13745 arg_req: &crate::types::ListConfigsReq,
13746 rpc_options: T::RpcOptions,
13747 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>> {
13748 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listConfigs_with_rpc_opts(
13749 arg_req,
13750 rpc_options,
13751 )
13752 }
13753 fn createSnapshot_with_rpc_opts(
13754 &self,
13755 arg_req: &crate::types::CreateSnapshotReq,
13756 rpc_options: T::RpcOptions,
13757 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>> {
13758 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).createSnapshot_with_rpc_opts(
13759 arg_req,
13760 rpc_options,
13761 )
13762 }
13763 fn dropSnapshot_with_rpc_opts(
13764 &self,
13765 arg_req: &crate::types::DropSnapshotReq,
13766 rpc_options: T::RpcOptions,
13767 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>> {
13768 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).dropSnapshot_with_rpc_opts(
13769 arg_req,
13770 rpc_options,
13771 )
13772 }
13773 fn listSnapshots_with_rpc_opts(
13774 &self,
13775 arg_req: &crate::types::ListSnapshotsReq,
13776 rpc_options: T::RpcOptions,
13777 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>> {
13778 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).listSnapshots_with_rpc_opts(
13779 arg_req,
13780 rpc_options,
13781 )
13782 }
13783 fn runAdminJob_with_rpc_opts(
13784 &self,
13785 arg_req: &crate::types::AdminJobReq,
13786 rpc_options: T::RpcOptions,
13787 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>> {
13788 <Self as ::std::convert::AsRef<dyn MetaServiceExt<T>>>::as_ref(self).runAdminJob_with_rpc_opts(
13789 arg_req,
13790 rpc_options,
13791 )
13792 }
13793 }
13794
13795 #[derive(Clone)]
13796 pub struct make_MetaService;
13797
13798 impl dyn MetaService {
13812 pub fn new<P, T>(
13813 protocol: P,
13814 transport: T,
13815 ) -> ::std::sync::Arc<impl MetaService + ::std::marker::Send + ::std::marker::Sync + 'static>
13816 where
13817 P: ::fbthrift::Protocol<Frame = T>,
13818 T: ::fbthrift::Transport,
13819 P::Deserializer: ::std::marker::Send,
13820 {
13821 let spawner = ::fbthrift::help::NoopSpawner;
13822 Self::with_spawner(protocol, transport, spawner)
13823 }
13824
13825 pub fn with_spawner<P, T, S>(
13826 protocol: P,
13827 transport: T,
13828 spawner: S,
13829 ) -> ::std::sync::Arc<impl MetaService + ::std::marker::Send + ::std::marker::Sync + 'static>
13830 where
13831 P: ::fbthrift::Protocol<Frame = T>,
13832 T: ::fbthrift::Transport,
13833 P::Deserializer: ::std::marker::Send,
13834 S: ::fbthrift::help::Spawner,
13835 {
13836 let _ = protocol;
13837 let _ = spawner;
13838 ::std::sync::Arc::new(MetaServiceImpl::<P, T, S>::new(transport))
13839 }
13840 }
13841
13842 impl<T> dyn MetaServiceExt<T>
13843 where
13844 T: ::fbthrift::Transport,
13845 {
13846 pub fn new<P>(
13847 protocol: P,
13848 transport: T,
13849 ) -> ::std::sync::Arc<impl MetaServiceExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
13850 where
13851 P: ::fbthrift::Protocol<Frame = T>,
13852 P::Deserializer: ::std::marker::Send,
13853 {
13854 let spawner = ::fbthrift::help::NoopSpawner;
13855 Self::with_spawner(protocol, transport, spawner)
13856 }
13857
13858 pub fn with_spawner<P, S>(
13859 protocol: P,
13860 transport: T,
13861 spawner: S,
13862 ) -> ::std::sync::Arc<impl MetaServiceExt<T> + ::std::marker::Send + ::std::marker::Sync + 'static>
13863 where
13864 P: ::fbthrift::Protocol<Frame = T>,
13865 P::Deserializer: ::std::marker::Send,
13866 S: ::fbthrift::help::Spawner,
13867 {
13868 let _ = protocol;
13869 let _ = spawner;
13870 ::std::sync::Arc::new(MetaServiceImpl::<P, T, S>::new(transport))
13871 }
13872 }
13873
13874 pub type MetaServiceDynClient = <make_MetaService as ::fbthrift::ClientFactory>::Api;
13875 pub type MetaServiceClient = ::std::sync::Arc<MetaServiceDynClient>;
13876
13877 impl ::fbthrift::ClientFactory for make_MetaService {
13880 type Api = dyn MetaService + ::std::marker::Send + ::std::marker::Sync + 'static;
13881
13882 fn with_spawner<P, T, S>(protocol: P, transport: T, spawner: S) -> ::std::sync::Arc<Self::Api>
13883 where
13884 P: ::fbthrift::Protocol<Frame = T>,
13885 T: ::fbthrift::Transport,
13886 P::Deserializer: ::std::marker::Send,
13887 S: ::fbthrift::help::Spawner,
13888 {
13889 <dyn MetaService>::with_spawner(protocol, transport, spawner)
13890 }
13891 }
13892
13893}
13894
13895pub mod server {
13897 #[::async_trait::async_trait]
13898 pub trait MetaService: ::std::marker::Send + ::std::marker::Sync + 'static {
13899 async fn createSpace(
13900 &self,
13901 _req: crate::types::CreateSpaceReq,
13902 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateSpaceExn> {
13903 ::std::result::Result::Err(crate::services::meta_service::CreateSpaceExn::ApplicationException(
13904 ::fbthrift::ApplicationException::unimplemented_method(
13905 "MetaService",
13906 "createSpace",
13907 ),
13908 ))
13909 }
13910 async fn dropSpace(
13911 &self,
13912 _req: crate::types::DropSpaceReq,
13913 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropSpaceExn> {
13914 ::std::result::Result::Err(crate::services::meta_service::DropSpaceExn::ApplicationException(
13915 ::fbthrift::ApplicationException::unimplemented_method(
13916 "MetaService",
13917 "dropSpace",
13918 ),
13919 ))
13920 }
13921 async fn getSpace(
13922 &self,
13923 _req: crate::types::GetSpaceReq,
13924 ) -> ::std::result::Result<crate::types::GetSpaceResp, crate::services::meta_service::GetSpaceExn> {
13925 ::std::result::Result::Err(crate::services::meta_service::GetSpaceExn::ApplicationException(
13926 ::fbthrift::ApplicationException::unimplemented_method(
13927 "MetaService",
13928 "getSpace",
13929 ),
13930 ))
13931 }
13932 async fn listSpaces(
13933 &self,
13934 _req: crate::types::ListSpacesReq,
13935 ) -> ::std::result::Result<crate::types::ListSpacesResp, crate::services::meta_service::ListSpacesExn> {
13936 ::std::result::Result::Err(crate::services::meta_service::ListSpacesExn::ApplicationException(
13937 ::fbthrift::ApplicationException::unimplemented_method(
13938 "MetaService",
13939 "listSpaces",
13940 ),
13941 ))
13942 }
13943 async fn createTag(
13944 &self,
13945 _req: crate::types::CreateTagReq,
13946 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateTagExn> {
13947 ::std::result::Result::Err(crate::services::meta_service::CreateTagExn::ApplicationException(
13948 ::fbthrift::ApplicationException::unimplemented_method(
13949 "MetaService",
13950 "createTag",
13951 ),
13952 ))
13953 }
13954 async fn alterTag(
13955 &self,
13956 _req: crate::types::AlterTagReq,
13957 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::AlterTagExn> {
13958 ::std::result::Result::Err(crate::services::meta_service::AlterTagExn::ApplicationException(
13959 ::fbthrift::ApplicationException::unimplemented_method(
13960 "MetaService",
13961 "alterTag",
13962 ),
13963 ))
13964 }
13965 async fn dropTag(
13966 &self,
13967 _req: crate::types::DropTagReq,
13968 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropTagExn> {
13969 ::std::result::Result::Err(crate::services::meta_service::DropTagExn::ApplicationException(
13970 ::fbthrift::ApplicationException::unimplemented_method(
13971 "MetaService",
13972 "dropTag",
13973 ),
13974 ))
13975 }
13976 async fn getTag(
13977 &self,
13978 _req: crate::types::GetTagReq,
13979 ) -> ::std::result::Result<crate::types::GetTagResp, crate::services::meta_service::GetTagExn> {
13980 ::std::result::Result::Err(crate::services::meta_service::GetTagExn::ApplicationException(
13981 ::fbthrift::ApplicationException::unimplemented_method(
13982 "MetaService",
13983 "getTag",
13984 ),
13985 ))
13986 }
13987 async fn listTags(
13988 &self,
13989 _req: crate::types::ListTagsReq,
13990 ) -> ::std::result::Result<crate::types::ListTagsResp, crate::services::meta_service::ListTagsExn> {
13991 ::std::result::Result::Err(crate::services::meta_service::ListTagsExn::ApplicationException(
13992 ::fbthrift::ApplicationException::unimplemented_method(
13993 "MetaService",
13994 "listTags",
13995 ),
13996 ))
13997 }
13998 async fn createEdge(
13999 &self,
14000 _req: crate::types::CreateEdgeReq,
14001 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateEdgeExn> {
14002 ::std::result::Result::Err(crate::services::meta_service::CreateEdgeExn::ApplicationException(
14003 ::fbthrift::ApplicationException::unimplemented_method(
14004 "MetaService",
14005 "createEdge",
14006 ),
14007 ))
14008 }
14009 async fn alterEdge(
14010 &self,
14011 _req: crate::types::AlterEdgeReq,
14012 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::AlterEdgeExn> {
14013 ::std::result::Result::Err(crate::services::meta_service::AlterEdgeExn::ApplicationException(
14014 ::fbthrift::ApplicationException::unimplemented_method(
14015 "MetaService",
14016 "alterEdge",
14017 ),
14018 ))
14019 }
14020 async fn dropEdge(
14021 &self,
14022 _req: crate::types::DropEdgeReq,
14023 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropEdgeExn> {
14024 ::std::result::Result::Err(crate::services::meta_service::DropEdgeExn::ApplicationException(
14025 ::fbthrift::ApplicationException::unimplemented_method(
14026 "MetaService",
14027 "dropEdge",
14028 ),
14029 ))
14030 }
14031 async fn getEdge(
14032 &self,
14033 _req: crate::types::GetEdgeReq,
14034 ) -> ::std::result::Result<crate::types::GetEdgeResp, crate::services::meta_service::GetEdgeExn> {
14035 ::std::result::Result::Err(crate::services::meta_service::GetEdgeExn::ApplicationException(
14036 ::fbthrift::ApplicationException::unimplemented_method(
14037 "MetaService",
14038 "getEdge",
14039 ),
14040 ))
14041 }
14042 async fn listEdges(
14043 &self,
14044 _req: crate::types::ListEdgesReq,
14045 ) -> ::std::result::Result<crate::types::ListEdgesResp, crate::services::meta_service::ListEdgesExn> {
14046 ::std::result::Result::Err(crate::services::meta_service::ListEdgesExn::ApplicationException(
14047 ::fbthrift::ApplicationException::unimplemented_method(
14048 "MetaService",
14049 "listEdges",
14050 ),
14051 ))
14052 }
14053 async fn listHosts(
14054 &self,
14055 _req: crate::types::ListHostsReq,
14056 ) -> ::std::result::Result<crate::types::ListHostsResp, crate::services::meta_service::ListHostsExn> {
14057 ::std::result::Result::Err(crate::services::meta_service::ListHostsExn::ApplicationException(
14058 ::fbthrift::ApplicationException::unimplemented_method(
14059 "MetaService",
14060 "listHosts",
14061 ),
14062 ))
14063 }
14064 async fn getPartsAlloc(
14065 &self,
14066 _req: crate::types::GetPartsAllocReq,
14067 ) -> ::std::result::Result<crate::types::GetPartsAllocResp, crate::services::meta_service::GetPartsAllocExn> {
14068 ::std::result::Result::Err(crate::services::meta_service::GetPartsAllocExn::ApplicationException(
14069 ::fbthrift::ApplicationException::unimplemented_method(
14070 "MetaService",
14071 "getPartsAlloc",
14072 ),
14073 ))
14074 }
14075 async fn listParts(
14076 &self,
14077 _req: crate::types::ListPartsReq,
14078 ) -> ::std::result::Result<crate::types::ListPartsResp, crate::services::meta_service::ListPartsExn> {
14079 ::std::result::Result::Err(crate::services::meta_service::ListPartsExn::ApplicationException(
14080 ::fbthrift::ApplicationException::unimplemented_method(
14081 "MetaService",
14082 "listParts",
14083 ),
14084 ))
14085 }
14086 async fn multiPut(
14087 &self,
14088 _req: crate::types::MultiPutReq,
14089 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::MultiPutExn> {
14090 ::std::result::Result::Err(crate::services::meta_service::MultiPutExn::ApplicationException(
14091 ::fbthrift::ApplicationException::unimplemented_method(
14092 "MetaService",
14093 "multiPut",
14094 ),
14095 ))
14096 }
14097 async fn get(
14098 &self,
14099 _req: crate::types::GetReq,
14100 ) -> ::std::result::Result<crate::types::GetResp, crate::services::meta_service::GetExn> {
14101 ::std::result::Result::Err(crate::services::meta_service::GetExn::ApplicationException(
14102 ::fbthrift::ApplicationException::unimplemented_method(
14103 "MetaService",
14104 "get",
14105 ),
14106 ))
14107 }
14108 async fn multiGet(
14109 &self,
14110 _req: crate::types::MultiGetReq,
14111 ) -> ::std::result::Result<crate::types::MultiGetResp, crate::services::meta_service::MultiGetExn> {
14112 ::std::result::Result::Err(crate::services::meta_service::MultiGetExn::ApplicationException(
14113 ::fbthrift::ApplicationException::unimplemented_method(
14114 "MetaService",
14115 "multiGet",
14116 ),
14117 ))
14118 }
14119 async fn remove(
14120 &self,
14121 _req: crate::types::RemoveReq,
14122 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RemoveExn> {
14123 ::std::result::Result::Err(crate::services::meta_service::RemoveExn::ApplicationException(
14124 ::fbthrift::ApplicationException::unimplemented_method(
14125 "MetaService",
14126 "remove",
14127 ),
14128 ))
14129 }
14130 async fn removeRange(
14131 &self,
14132 _req: crate::types::RemoveRangeReq,
14133 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RemoveRangeExn> {
14134 ::std::result::Result::Err(crate::services::meta_service::RemoveRangeExn::ApplicationException(
14135 ::fbthrift::ApplicationException::unimplemented_method(
14136 "MetaService",
14137 "removeRange",
14138 ),
14139 ))
14140 }
14141 async fn scan(
14142 &self,
14143 _req: crate::types::ScanReq,
14144 ) -> ::std::result::Result<crate::types::ScanResp, crate::services::meta_service::ScanExn> {
14145 ::std::result::Result::Err(crate::services::meta_service::ScanExn::ApplicationException(
14146 ::fbthrift::ApplicationException::unimplemented_method(
14147 "MetaService",
14148 "scan",
14149 ),
14150 ))
14151 }
14152 async fn createTagIndex(
14153 &self,
14154 _req: crate::types::CreateTagIndexReq,
14155 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateTagIndexExn> {
14156 ::std::result::Result::Err(crate::services::meta_service::CreateTagIndexExn::ApplicationException(
14157 ::fbthrift::ApplicationException::unimplemented_method(
14158 "MetaService",
14159 "createTagIndex",
14160 ),
14161 ))
14162 }
14163 async fn dropTagIndex(
14164 &self,
14165 _req: crate::types::DropTagIndexReq,
14166 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropTagIndexExn> {
14167 ::std::result::Result::Err(crate::services::meta_service::DropTagIndexExn::ApplicationException(
14168 ::fbthrift::ApplicationException::unimplemented_method(
14169 "MetaService",
14170 "dropTagIndex",
14171 ),
14172 ))
14173 }
14174 async fn getTagIndex(
14175 &self,
14176 _req: crate::types::GetTagIndexReq,
14177 ) -> ::std::result::Result<crate::types::GetTagIndexResp, crate::services::meta_service::GetTagIndexExn> {
14178 ::std::result::Result::Err(crate::services::meta_service::GetTagIndexExn::ApplicationException(
14179 ::fbthrift::ApplicationException::unimplemented_method(
14180 "MetaService",
14181 "getTagIndex",
14182 ),
14183 ))
14184 }
14185 async fn listTagIndexes(
14186 &self,
14187 _req: crate::types::ListTagIndexesReq,
14188 ) -> ::std::result::Result<crate::types::ListTagIndexesResp, crate::services::meta_service::ListTagIndexesExn> {
14189 ::std::result::Result::Err(crate::services::meta_service::ListTagIndexesExn::ApplicationException(
14190 ::fbthrift::ApplicationException::unimplemented_method(
14191 "MetaService",
14192 "listTagIndexes",
14193 ),
14194 ))
14195 }
14196 async fn rebuildTagIndex(
14197 &self,
14198 _req: crate::types::RebuildIndexReq,
14199 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RebuildTagIndexExn> {
14200 ::std::result::Result::Err(crate::services::meta_service::RebuildTagIndexExn::ApplicationException(
14201 ::fbthrift::ApplicationException::unimplemented_method(
14202 "MetaService",
14203 "rebuildTagIndex",
14204 ),
14205 ))
14206 }
14207 async fn listTagIndexStatus(
14208 &self,
14209 _req: crate::types::ListIndexStatusReq,
14210 ) -> ::std::result::Result<crate::types::ListIndexStatusResp, crate::services::meta_service::ListTagIndexStatusExn> {
14211 ::std::result::Result::Err(crate::services::meta_service::ListTagIndexStatusExn::ApplicationException(
14212 ::fbthrift::ApplicationException::unimplemented_method(
14213 "MetaService",
14214 "listTagIndexStatus",
14215 ),
14216 ))
14217 }
14218 async fn createEdgeIndex(
14219 &self,
14220 _req: crate::types::CreateEdgeIndexReq,
14221 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateEdgeIndexExn> {
14222 ::std::result::Result::Err(crate::services::meta_service::CreateEdgeIndexExn::ApplicationException(
14223 ::fbthrift::ApplicationException::unimplemented_method(
14224 "MetaService",
14225 "createEdgeIndex",
14226 ),
14227 ))
14228 }
14229 async fn dropEdgeIndex(
14230 &self,
14231 _req: crate::types::DropEdgeIndexReq,
14232 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropEdgeIndexExn> {
14233 ::std::result::Result::Err(crate::services::meta_service::DropEdgeIndexExn::ApplicationException(
14234 ::fbthrift::ApplicationException::unimplemented_method(
14235 "MetaService",
14236 "dropEdgeIndex",
14237 ),
14238 ))
14239 }
14240 async fn getEdgeIndex(
14241 &self,
14242 _req: crate::types::GetEdgeIndexReq,
14243 ) -> ::std::result::Result<crate::types::GetEdgeIndexResp, crate::services::meta_service::GetEdgeIndexExn> {
14244 ::std::result::Result::Err(crate::services::meta_service::GetEdgeIndexExn::ApplicationException(
14245 ::fbthrift::ApplicationException::unimplemented_method(
14246 "MetaService",
14247 "getEdgeIndex",
14248 ),
14249 ))
14250 }
14251 async fn listEdgeIndexes(
14252 &self,
14253 _req: crate::types::ListEdgeIndexesReq,
14254 ) -> ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::services::meta_service::ListEdgeIndexesExn> {
14255 ::std::result::Result::Err(crate::services::meta_service::ListEdgeIndexesExn::ApplicationException(
14256 ::fbthrift::ApplicationException::unimplemented_method(
14257 "MetaService",
14258 "listEdgeIndexes",
14259 ),
14260 ))
14261 }
14262 async fn rebuildEdgeIndex(
14263 &self,
14264 _req: crate::types::RebuildIndexReq,
14265 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RebuildEdgeIndexExn> {
14266 ::std::result::Result::Err(crate::services::meta_service::RebuildEdgeIndexExn::ApplicationException(
14267 ::fbthrift::ApplicationException::unimplemented_method(
14268 "MetaService",
14269 "rebuildEdgeIndex",
14270 ),
14271 ))
14272 }
14273 async fn listEdgeIndexStatus(
14274 &self,
14275 _req: crate::types::ListIndexStatusReq,
14276 ) -> ::std::result::Result<crate::types::ListIndexStatusResp, crate::services::meta_service::ListEdgeIndexStatusExn> {
14277 ::std::result::Result::Err(crate::services::meta_service::ListEdgeIndexStatusExn::ApplicationException(
14278 ::fbthrift::ApplicationException::unimplemented_method(
14279 "MetaService",
14280 "listEdgeIndexStatus",
14281 ),
14282 ))
14283 }
14284 async fn createUser(
14285 &self,
14286 _req: crate::types::CreateUserReq,
14287 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateUserExn> {
14288 ::std::result::Result::Err(crate::services::meta_service::CreateUserExn::ApplicationException(
14289 ::fbthrift::ApplicationException::unimplemented_method(
14290 "MetaService",
14291 "createUser",
14292 ),
14293 ))
14294 }
14295 async fn dropUser(
14296 &self,
14297 _req: crate::types::DropUserReq,
14298 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropUserExn> {
14299 ::std::result::Result::Err(crate::services::meta_service::DropUserExn::ApplicationException(
14300 ::fbthrift::ApplicationException::unimplemented_method(
14301 "MetaService",
14302 "dropUser",
14303 ),
14304 ))
14305 }
14306 async fn alterUser(
14307 &self,
14308 _req: crate::types::AlterUserReq,
14309 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::AlterUserExn> {
14310 ::std::result::Result::Err(crate::services::meta_service::AlterUserExn::ApplicationException(
14311 ::fbthrift::ApplicationException::unimplemented_method(
14312 "MetaService",
14313 "alterUser",
14314 ),
14315 ))
14316 }
14317 async fn grantRole(
14318 &self,
14319 _req: crate::types::GrantRoleReq,
14320 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::GrantRoleExn> {
14321 ::std::result::Result::Err(crate::services::meta_service::GrantRoleExn::ApplicationException(
14322 ::fbthrift::ApplicationException::unimplemented_method(
14323 "MetaService",
14324 "grantRole",
14325 ),
14326 ))
14327 }
14328 async fn revokeRole(
14329 &self,
14330 _req: crate::types::RevokeRoleReq,
14331 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RevokeRoleExn> {
14332 ::std::result::Result::Err(crate::services::meta_service::RevokeRoleExn::ApplicationException(
14333 ::fbthrift::ApplicationException::unimplemented_method(
14334 "MetaService",
14335 "revokeRole",
14336 ),
14337 ))
14338 }
14339 async fn listUsers(
14340 &self,
14341 _req: crate::types::ListUsersReq,
14342 ) -> ::std::result::Result<crate::types::ListUsersResp, crate::services::meta_service::ListUsersExn> {
14343 ::std::result::Result::Err(crate::services::meta_service::ListUsersExn::ApplicationException(
14344 ::fbthrift::ApplicationException::unimplemented_method(
14345 "MetaService",
14346 "listUsers",
14347 ),
14348 ))
14349 }
14350 async fn listRoles(
14351 &self,
14352 _req: crate::types::ListRolesReq,
14353 ) -> ::std::result::Result<crate::types::ListRolesResp, crate::services::meta_service::ListRolesExn> {
14354 ::std::result::Result::Err(crate::services::meta_service::ListRolesExn::ApplicationException(
14355 ::fbthrift::ApplicationException::unimplemented_method(
14356 "MetaService",
14357 "listRoles",
14358 ),
14359 ))
14360 }
14361 async fn getUserRoles(
14362 &self,
14363 _req: crate::types::GetUserRolesReq,
14364 ) -> ::std::result::Result<crate::types::ListRolesResp, crate::services::meta_service::GetUserRolesExn> {
14365 ::std::result::Result::Err(crate::services::meta_service::GetUserRolesExn::ApplicationException(
14366 ::fbthrift::ApplicationException::unimplemented_method(
14367 "MetaService",
14368 "getUserRoles",
14369 ),
14370 ))
14371 }
14372 async fn changePassword(
14373 &self,
14374 _req: crate::types::ChangePasswordReq,
14375 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::ChangePasswordExn> {
14376 ::std::result::Result::Err(crate::services::meta_service::ChangePasswordExn::ApplicationException(
14377 ::fbthrift::ApplicationException::unimplemented_method(
14378 "MetaService",
14379 "changePassword",
14380 ),
14381 ))
14382 }
14383 async fn heartBeat(
14384 &self,
14385 _req: crate::types::HBReq,
14386 ) -> ::std::result::Result<crate::types::HBResp, crate::services::meta_service::HeartBeatExn> {
14387 ::std::result::Result::Err(crate::services::meta_service::HeartBeatExn::ApplicationException(
14388 ::fbthrift::ApplicationException::unimplemented_method(
14389 "MetaService",
14390 "heartBeat",
14391 ),
14392 ))
14393 }
14394 async fn balance(
14395 &self,
14396 _req: crate::types::BalanceReq,
14397 ) -> ::std::result::Result<crate::types::BalanceResp, crate::services::meta_service::BalanceExn> {
14398 ::std::result::Result::Err(crate::services::meta_service::BalanceExn::ApplicationException(
14399 ::fbthrift::ApplicationException::unimplemented_method(
14400 "MetaService",
14401 "balance",
14402 ),
14403 ))
14404 }
14405 async fn leaderBalance(
14406 &self,
14407 _req: crate::types::LeaderBalanceReq,
14408 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::LeaderBalanceExn> {
14409 ::std::result::Result::Err(crate::services::meta_service::LeaderBalanceExn::ApplicationException(
14410 ::fbthrift::ApplicationException::unimplemented_method(
14411 "MetaService",
14412 "leaderBalance",
14413 ),
14414 ))
14415 }
14416 async fn regConfig(
14417 &self,
14418 _req: crate::types::RegConfigReq,
14419 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RegConfigExn> {
14420 ::std::result::Result::Err(crate::services::meta_service::RegConfigExn::ApplicationException(
14421 ::fbthrift::ApplicationException::unimplemented_method(
14422 "MetaService",
14423 "regConfig",
14424 ),
14425 ))
14426 }
14427 async fn getConfig(
14428 &self,
14429 _req: crate::types::GetConfigReq,
14430 ) -> ::std::result::Result<crate::types::GetConfigResp, crate::services::meta_service::GetConfigExn> {
14431 ::std::result::Result::Err(crate::services::meta_service::GetConfigExn::ApplicationException(
14432 ::fbthrift::ApplicationException::unimplemented_method(
14433 "MetaService",
14434 "getConfig",
14435 ),
14436 ))
14437 }
14438 async fn setConfig(
14439 &self,
14440 _req: crate::types::SetConfigReq,
14441 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::SetConfigExn> {
14442 ::std::result::Result::Err(crate::services::meta_service::SetConfigExn::ApplicationException(
14443 ::fbthrift::ApplicationException::unimplemented_method(
14444 "MetaService",
14445 "setConfig",
14446 ),
14447 ))
14448 }
14449 async fn listConfigs(
14450 &self,
14451 _req: crate::types::ListConfigsReq,
14452 ) -> ::std::result::Result<crate::types::ListConfigsResp, crate::services::meta_service::ListConfigsExn> {
14453 ::std::result::Result::Err(crate::services::meta_service::ListConfigsExn::ApplicationException(
14454 ::fbthrift::ApplicationException::unimplemented_method(
14455 "MetaService",
14456 "listConfigs",
14457 ),
14458 ))
14459 }
14460 async fn createSnapshot(
14461 &self,
14462 _req: crate::types::CreateSnapshotReq,
14463 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateSnapshotExn> {
14464 ::std::result::Result::Err(crate::services::meta_service::CreateSnapshotExn::ApplicationException(
14465 ::fbthrift::ApplicationException::unimplemented_method(
14466 "MetaService",
14467 "createSnapshot",
14468 ),
14469 ))
14470 }
14471 async fn dropSnapshot(
14472 &self,
14473 _req: crate::types::DropSnapshotReq,
14474 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropSnapshotExn> {
14475 ::std::result::Result::Err(crate::services::meta_service::DropSnapshotExn::ApplicationException(
14476 ::fbthrift::ApplicationException::unimplemented_method(
14477 "MetaService",
14478 "dropSnapshot",
14479 ),
14480 ))
14481 }
14482 async fn listSnapshots(
14483 &self,
14484 _req: crate::types::ListSnapshotsReq,
14485 ) -> ::std::result::Result<crate::types::ListSnapshotsResp, crate::services::meta_service::ListSnapshotsExn> {
14486 ::std::result::Result::Err(crate::services::meta_service::ListSnapshotsExn::ApplicationException(
14487 ::fbthrift::ApplicationException::unimplemented_method(
14488 "MetaService",
14489 "listSnapshots",
14490 ),
14491 ))
14492 }
14493 async fn runAdminJob(
14494 &self,
14495 _req: crate::types::AdminJobReq,
14496 ) -> ::std::result::Result<crate::types::AdminJobResp, crate::services::meta_service::RunAdminJobExn> {
14497 ::std::result::Result::Err(crate::services::meta_service::RunAdminJobExn::ApplicationException(
14498 ::fbthrift::ApplicationException::unimplemented_method(
14499 "MetaService",
14500 "runAdminJob",
14501 ),
14502 ))
14503 }
14504 }
14505
14506 #[::async_trait::async_trait]
14507 impl<T> MetaService for ::std::boxed::Box<T>
14508 where
14509 T: MetaService + Send + Sync + ?Sized,
14510 {
14511 async fn createSpace(
14512 &self,
14513 req: crate::types::CreateSpaceReq,
14514 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateSpaceExn> {
14515 (**self).createSpace(
14516 req,
14517 ).await
14518 }
14519 async fn dropSpace(
14520 &self,
14521 req: crate::types::DropSpaceReq,
14522 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropSpaceExn> {
14523 (**self).dropSpace(
14524 req,
14525 ).await
14526 }
14527 async fn getSpace(
14528 &self,
14529 req: crate::types::GetSpaceReq,
14530 ) -> ::std::result::Result<crate::types::GetSpaceResp, crate::services::meta_service::GetSpaceExn> {
14531 (**self).getSpace(
14532 req,
14533 ).await
14534 }
14535 async fn listSpaces(
14536 &self,
14537 req: crate::types::ListSpacesReq,
14538 ) -> ::std::result::Result<crate::types::ListSpacesResp, crate::services::meta_service::ListSpacesExn> {
14539 (**self).listSpaces(
14540 req,
14541 ).await
14542 }
14543 async fn createTag(
14544 &self,
14545 req: crate::types::CreateTagReq,
14546 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateTagExn> {
14547 (**self).createTag(
14548 req,
14549 ).await
14550 }
14551 async fn alterTag(
14552 &self,
14553 req: crate::types::AlterTagReq,
14554 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::AlterTagExn> {
14555 (**self).alterTag(
14556 req,
14557 ).await
14558 }
14559 async fn dropTag(
14560 &self,
14561 req: crate::types::DropTagReq,
14562 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropTagExn> {
14563 (**self).dropTag(
14564 req,
14565 ).await
14566 }
14567 async fn getTag(
14568 &self,
14569 req: crate::types::GetTagReq,
14570 ) -> ::std::result::Result<crate::types::GetTagResp, crate::services::meta_service::GetTagExn> {
14571 (**self).getTag(
14572 req,
14573 ).await
14574 }
14575 async fn listTags(
14576 &self,
14577 req: crate::types::ListTagsReq,
14578 ) -> ::std::result::Result<crate::types::ListTagsResp, crate::services::meta_service::ListTagsExn> {
14579 (**self).listTags(
14580 req,
14581 ).await
14582 }
14583 async fn createEdge(
14584 &self,
14585 req: crate::types::CreateEdgeReq,
14586 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateEdgeExn> {
14587 (**self).createEdge(
14588 req,
14589 ).await
14590 }
14591 async fn alterEdge(
14592 &self,
14593 req: crate::types::AlterEdgeReq,
14594 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::AlterEdgeExn> {
14595 (**self).alterEdge(
14596 req,
14597 ).await
14598 }
14599 async fn dropEdge(
14600 &self,
14601 req: crate::types::DropEdgeReq,
14602 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropEdgeExn> {
14603 (**self).dropEdge(
14604 req,
14605 ).await
14606 }
14607 async fn getEdge(
14608 &self,
14609 req: crate::types::GetEdgeReq,
14610 ) -> ::std::result::Result<crate::types::GetEdgeResp, crate::services::meta_service::GetEdgeExn> {
14611 (**self).getEdge(
14612 req,
14613 ).await
14614 }
14615 async fn listEdges(
14616 &self,
14617 req: crate::types::ListEdgesReq,
14618 ) -> ::std::result::Result<crate::types::ListEdgesResp, crate::services::meta_service::ListEdgesExn> {
14619 (**self).listEdges(
14620 req,
14621 ).await
14622 }
14623 async fn listHosts(
14624 &self,
14625 req: crate::types::ListHostsReq,
14626 ) -> ::std::result::Result<crate::types::ListHostsResp, crate::services::meta_service::ListHostsExn> {
14627 (**self).listHosts(
14628 req,
14629 ).await
14630 }
14631 async fn getPartsAlloc(
14632 &self,
14633 req: crate::types::GetPartsAllocReq,
14634 ) -> ::std::result::Result<crate::types::GetPartsAllocResp, crate::services::meta_service::GetPartsAllocExn> {
14635 (**self).getPartsAlloc(
14636 req,
14637 ).await
14638 }
14639 async fn listParts(
14640 &self,
14641 req: crate::types::ListPartsReq,
14642 ) -> ::std::result::Result<crate::types::ListPartsResp, crate::services::meta_service::ListPartsExn> {
14643 (**self).listParts(
14644 req,
14645 ).await
14646 }
14647 async fn multiPut(
14648 &self,
14649 req: crate::types::MultiPutReq,
14650 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::MultiPutExn> {
14651 (**self).multiPut(
14652 req,
14653 ).await
14654 }
14655 async fn get(
14656 &self,
14657 req: crate::types::GetReq,
14658 ) -> ::std::result::Result<crate::types::GetResp, crate::services::meta_service::GetExn> {
14659 (**self).get(
14660 req,
14661 ).await
14662 }
14663 async fn multiGet(
14664 &self,
14665 req: crate::types::MultiGetReq,
14666 ) -> ::std::result::Result<crate::types::MultiGetResp, crate::services::meta_service::MultiGetExn> {
14667 (**self).multiGet(
14668 req,
14669 ).await
14670 }
14671 async fn remove(
14672 &self,
14673 req: crate::types::RemoveReq,
14674 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RemoveExn> {
14675 (**self).remove(
14676 req,
14677 ).await
14678 }
14679 async fn removeRange(
14680 &self,
14681 req: crate::types::RemoveRangeReq,
14682 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RemoveRangeExn> {
14683 (**self).removeRange(
14684 req,
14685 ).await
14686 }
14687 async fn scan(
14688 &self,
14689 req: crate::types::ScanReq,
14690 ) -> ::std::result::Result<crate::types::ScanResp, crate::services::meta_service::ScanExn> {
14691 (**self).scan(
14692 req,
14693 ).await
14694 }
14695 async fn createTagIndex(
14696 &self,
14697 req: crate::types::CreateTagIndexReq,
14698 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateTagIndexExn> {
14699 (**self).createTagIndex(
14700 req,
14701 ).await
14702 }
14703 async fn dropTagIndex(
14704 &self,
14705 req: crate::types::DropTagIndexReq,
14706 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropTagIndexExn> {
14707 (**self).dropTagIndex(
14708 req,
14709 ).await
14710 }
14711 async fn getTagIndex(
14712 &self,
14713 req: crate::types::GetTagIndexReq,
14714 ) -> ::std::result::Result<crate::types::GetTagIndexResp, crate::services::meta_service::GetTagIndexExn> {
14715 (**self).getTagIndex(
14716 req,
14717 ).await
14718 }
14719 async fn listTagIndexes(
14720 &self,
14721 req: crate::types::ListTagIndexesReq,
14722 ) -> ::std::result::Result<crate::types::ListTagIndexesResp, crate::services::meta_service::ListTagIndexesExn> {
14723 (**self).listTagIndexes(
14724 req,
14725 ).await
14726 }
14727 async fn rebuildTagIndex(
14728 &self,
14729 req: crate::types::RebuildIndexReq,
14730 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RebuildTagIndexExn> {
14731 (**self).rebuildTagIndex(
14732 req,
14733 ).await
14734 }
14735 async fn listTagIndexStatus(
14736 &self,
14737 req: crate::types::ListIndexStatusReq,
14738 ) -> ::std::result::Result<crate::types::ListIndexStatusResp, crate::services::meta_service::ListTagIndexStatusExn> {
14739 (**self).listTagIndexStatus(
14740 req,
14741 ).await
14742 }
14743 async fn createEdgeIndex(
14744 &self,
14745 req: crate::types::CreateEdgeIndexReq,
14746 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateEdgeIndexExn> {
14747 (**self).createEdgeIndex(
14748 req,
14749 ).await
14750 }
14751 async fn dropEdgeIndex(
14752 &self,
14753 req: crate::types::DropEdgeIndexReq,
14754 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropEdgeIndexExn> {
14755 (**self).dropEdgeIndex(
14756 req,
14757 ).await
14758 }
14759 async fn getEdgeIndex(
14760 &self,
14761 req: crate::types::GetEdgeIndexReq,
14762 ) -> ::std::result::Result<crate::types::GetEdgeIndexResp, crate::services::meta_service::GetEdgeIndexExn> {
14763 (**self).getEdgeIndex(
14764 req,
14765 ).await
14766 }
14767 async fn listEdgeIndexes(
14768 &self,
14769 req: crate::types::ListEdgeIndexesReq,
14770 ) -> ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::services::meta_service::ListEdgeIndexesExn> {
14771 (**self).listEdgeIndexes(
14772 req,
14773 ).await
14774 }
14775 async fn rebuildEdgeIndex(
14776 &self,
14777 req: crate::types::RebuildIndexReq,
14778 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RebuildEdgeIndexExn> {
14779 (**self).rebuildEdgeIndex(
14780 req,
14781 ).await
14782 }
14783 async fn listEdgeIndexStatus(
14784 &self,
14785 req: crate::types::ListIndexStatusReq,
14786 ) -> ::std::result::Result<crate::types::ListIndexStatusResp, crate::services::meta_service::ListEdgeIndexStatusExn> {
14787 (**self).listEdgeIndexStatus(
14788 req,
14789 ).await
14790 }
14791 async fn createUser(
14792 &self,
14793 req: crate::types::CreateUserReq,
14794 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateUserExn> {
14795 (**self).createUser(
14796 req,
14797 ).await
14798 }
14799 async fn dropUser(
14800 &self,
14801 req: crate::types::DropUserReq,
14802 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropUserExn> {
14803 (**self).dropUser(
14804 req,
14805 ).await
14806 }
14807 async fn alterUser(
14808 &self,
14809 req: crate::types::AlterUserReq,
14810 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::AlterUserExn> {
14811 (**self).alterUser(
14812 req,
14813 ).await
14814 }
14815 async fn grantRole(
14816 &self,
14817 req: crate::types::GrantRoleReq,
14818 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::GrantRoleExn> {
14819 (**self).grantRole(
14820 req,
14821 ).await
14822 }
14823 async fn revokeRole(
14824 &self,
14825 req: crate::types::RevokeRoleReq,
14826 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RevokeRoleExn> {
14827 (**self).revokeRole(
14828 req,
14829 ).await
14830 }
14831 async fn listUsers(
14832 &self,
14833 req: crate::types::ListUsersReq,
14834 ) -> ::std::result::Result<crate::types::ListUsersResp, crate::services::meta_service::ListUsersExn> {
14835 (**self).listUsers(
14836 req,
14837 ).await
14838 }
14839 async fn listRoles(
14840 &self,
14841 req: crate::types::ListRolesReq,
14842 ) -> ::std::result::Result<crate::types::ListRolesResp, crate::services::meta_service::ListRolesExn> {
14843 (**self).listRoles(
14844 req,
14845 ).await
14846 }
14847 async fn getUserRoles(
14848 &self,
14849 req: crate::types::GetUserRolesReq,
14850 ) -> ::std::result::Result<crate::types::ListRolesResp, crate::services::meta_service::GetUserRolesExn> {
14851 (**self).getUserRoles(
14852 req,
14853 ).await
14854 }
14855 async fn changePassword(
14856 &self,
14857 req: crate::types::ChangePasswordReq,
14858 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::ChangePasswordExn> {
14859 (**self).changePassword(
14860 req,
14861 ).await
14862 }
14863 async fn heartBeat(
14864 &self,
14865 req: crate::types::HBReq,
14866 ) -> ::std::result::Result<crate::types::HBResp, crate::services::meta_service::HeartBeatExn> {
14867 (**self).heartBeat(
14868 req,
14869 ).await
14870 }
14871 async fn balance(
14872 &self,
14873 req: crate::types::BalanceReq,
14874 ) -> ::std::result::Result<crate::types::BalanceResp, crate::services::meta_service::BalanceExn> {
14875 (**self).balance(
14876 req,
14877 ).await
14878 }
14879 async fn leaderBalance(
14880 &self,
14881 req: crate::types::LeaderBalanceReq,
14882 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::LeaderBalanceExn> {
14883 (**self).leaderBalance(
14884 req,
14885 ).await
14886 }
14887 async fn regConfig(
14888 &self,
14889 req: crate::types::RegConfigReq,
14890 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::RegConfigExn> {
14891 (**self).regConfig(
14892 req,
14893 ).await
14894 }
14895 async fn getConfig(
14896 &self,
14897 req: crate::types::GetConfigReq,
14898 ) -> ::std::result::Result<crate::types::GetConfigResp, crate::services::meta_service::GetConfigExn> {
14899 (**self).getConfig(
14900 req,
14901 ).await
14902 }
14903 async fn setConfig(
14904 &self,
14905 req: crate::types::SetConfigReq,
14906 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::SetConfigExn> {
14907 (**self).setConfig(
14908 req,
14909 ).await
14910 }
14911 async fn listConfigs(
14912 &self,
14913 req: crate::types::ListConfigsReq,
14914 ) -> ::std::result::Result<crate::types::ListConfigsResp, crate::services::meta_service::ListConfigsExn> {
14915 (**self).listConfigs(
14916 req,
14917 ).await
14918 }
14919 async fn createSnapshot(
14920 &self,
14921 req: crate::types::CreateSnapshotReq,
14922 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::CreateSnapshotExn> {
14923 (**self).createSnapshot(
14924 req,
14925 ).await
14926 }
14927 async fn dropSnapshot(
14928 &self,
14929 req: crate::types::DropSnapshotReq,
14930 ) -> ::std::result::Result<crate::types::ExecResp, crate::services::meta_service::DropSnapshotExn> {
14931 (**self).dropSnapshot(
14932 req,
14933 ).await
14934 }
14935 async fn listSnapshots(
14936 &self,
14937 req: crate::types::ListSnapshotsReq,
14938 ) -> ::std::result::Result<crate::types::ListSnapshotsResp, crate::services::meta_service::ListSnapshotsExn> {
14939 (**self).listSnapshots(
14940 req,
14941 ).await
14942 }
14943 async fn runAdminJob(
14944 &self,
14945 req: crate::types::AdminJobReq,
14946 ) -> ::std::result::Result<crate::types::AdminJobResp, crate::services::meta_service::RunAdminJobExn> {
14947 (**self).runAdminJob(
14948 req,
14949 ).await
14950 }
14951 }
14952
14953 #[derive(Clone, Debug)]
14955 pub struct MetaServiceProcessor<P, H, R, RS> {
14956 service: H,
14957 supa: ::fbthrift::NullServiceProcessor<P, R, RS>,
14958 _phantom: ::std::marker::PhantomData<(P, H, R, RS)>,
14959 }
14960
14961 struct Args_MetaService_createSpace {
14962 req: crate::types::CreateSpaceReq,
14963 }
14964 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_createSpace {
14965 #[inline]
14966 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.createSpace"))]
14967 fn read(p: &mut P) -> ::anyhow::Result<Self> {
14968 static ARGS: &[::fbthrift::Field] = &[
14969 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
14970 ];
14971 let mut field_req = ::std::option::Option::None;
14972 let _ = p.read_struct_begin(|_| ())?;
14973 loop {
14974 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
14975 match (fty, fid as ::std::primitive::i32) {
14976 (::fbthrift::TType::Stop, _) => break,
14977 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
14978 (fty, _) => p.skip(fty)?,
14979 }
14980 p.read_field_end()?;
14981 }
14982 p.read_struct_end()?;
14983 ::std::result::Result::Ok(Self {
14984 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.createSpace", "req"))?,
14985 })
14986 }
14987 }
14988
14989 struct Args_MetaService_dropSpace {
14990 req: crate::types::DropSpaceReq,
14991 }
14992 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_dropSpace {
14993 #[inline]
14994 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.dropSpace"))]
14995 fn read(p: &mut P) -> ::anyhow::Result<Self> {
14996 static ARGS: &[::fbthrift::Field] = &[
14997 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
14998 ];
14999 let mut field_req = ::std::option::Option::None;
15000 let _ = p.read_struct_begin(|_| ())?;
15001 loop {
15002 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15003 match (fty, fid as ::std::primitive::i32) {
15004 (::fbthrift::TType::Stop, _) => break,
15005 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15006 (fty, _) => p.skip(fty)?,
15007 }
15008 p.read_field_end()?;
15009 }
15010 p.read_struct_end()?;
15011 ::std::result::Result::Ok(Self {
15012 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.dropSpace", "req"))?,
15013 })
15014 }
15015 }
15016
15017 struct Args_MetaService_getSpace {
15018 req: crate::types::GetSpaceReq,
15019 }
15020 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getSpace {
15021 #[inline]
15022 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getSpace"))]
15023 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15024 static ARGS: &[::fbthrift::Field] = &[
15025 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15026 ];
15027 let mut field_req = ::std::option::Option::None;
15028 let _ = p.read_struct_begin(|_| ())?;
15029 loop {
15030 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15031 match (fty, fid as ::std::primitive::i32) {
15032 (::fbthrift::TType::Stop, _) => break,
15033 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15034 (fty, _) => p.skip(fty)?,
15035 }
15036 p.read_field_end()?;
15037 }
15038 p.read_struct_end()?;
15039 ::std::result::Result::Ok(Self {
15040 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getSpace", "req"))?,
15041 })
15042 }
15043 }
15044
15045 struct Args_MetaService_listSpaces {
15046 req: crate::types::ListSpacesReq,
15047 }
15048 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listSpaces {
15049 #[inline]
15050 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listSpaces"))]
15051 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15052 static ARGS: &[::fbthrift::Field] = &[
15053 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15054 ];
15055 let mut field_req = ::std::option::Option::None;
15056 let _ = p.read_struct_begin(|_| ())?;
15057 loop {
15058 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15059 match (fty, fid as ::std::primitive::i32) {
15060 (::fbthrift::TType::Stop, _) => break,
15061 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15062 (fty, _) => p.skip(fty)?,
15063 }
15064 p.read_field_end()?;
15065 }
15066 p.read_struct_end()?;
15067 ::std::result::Result::Ok(Self {
15068 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listSpaces", "req"))?,
15069 })
15070 }
15071 }
15072
15073 struct Args_MetaService_createTag {
15074 req: crate::types::CreateTagReq,
15075 }
15076 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_createTag {
15077 #[inline]
15078 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.createTag"))]
15079 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15080 static ARGS: &[::fbthrift::Field] = &[
15081 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15082 ];
15083 let mut field_req = ::std::option::Option::None;
15084 let _ = p.read_struct_begin(|_| ())?;
15085 loop {
15086 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15087 match (fty, fid as ::std::primitive::i32) {
15088 (::fbthrift::TType::Stop, _) => break,
15089 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15090 (fty, _) => p.skip(fty)?,
15091 }
15092 p.read_field_end()?;
15093 }
15094 p.read_struct_end()?;
15095 ::std::result::Result::Ok(Self {
15096 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.createTag", "req"))?,
15097 })
15098 }
15099 }
15100
15101 struct Args_MetaService_alterTag {
15102 req: crate::types::AlterTagReq,
15103 }
15104 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_alterTag {
15105 #[inline]
15106 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.alterTag"))]
15107 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15108 static ARGS: &[::fbthrift::Field] = &[
15109 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15110 ];
15111 let mut field_req = ::std::option::Option::None;
15112 let _ = p.read_struct_begin(|_| ())?;
15113 loop {
15114 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15115 match (fty, fid as ::std::primitive::i32) {
15116 (::fbthrift::TType::Stop, _) => break,
15117 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15118 (fty, _) => p.skip(fty)?,
15119 }
15120 p.read_field_end()?;
15121 }
15122 p.read_struct_end()?;
15123 ::std::result::Result::Ok(Self {
15124 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.alterTag", "req"))?,
15125 })
15126 }
15127 }
15128
15129 struct Args_MetaService_dropTag {
15130 req: crate::types::DropTagReq,
15131 }
15132 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_dropTag {
15133 #[inline]
15134 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.dropTag"))]
15135 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15136 static ARGS: &[::fbthrift::Field] = &[
15137 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15138 ];
15139 let mut field_req = ::std::option::Option::None;
15140 let _ = p.read_struct_begin(|_| ())?;
15141 loop {
15142 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15143 match (fty, fid as ::std::primitive::i32) {
15144 (::fbthrift::TType::Stop, _) => break,
15145 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15146 (fty, _) => p.skip(fty)?,
15147 }
15148 p.read_field_end()?;
15149 }
15150 p.read_struct_end()?;
15151 ::std::result::Result::Ok(Self {
15152 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.dropTag", "req"))?,
15153 })
15154 }
15155 }
15156
15157 struct Args_MetaService_getTag {
15158 req: crate::types::GetTagReq,
15159 }
15160 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getTag {
15161 #[inline]
15162 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getTag"))]
15163 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15164 static ARGS: &[::fbthrift::Field] = &[
15165 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15166 ];
15167 let mut field_req = ::std::option::Option::None;
15168 let _ = p.read_struct_begin(|_| ())?;
15169 loop {
15170 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15171 match (fty, fid as ::std::primitive::i32) {
15172 (::fbthrift::TType::Stop, _) => break,
15173 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15174 (fty, _) => p.skip(fty)?,
15175 }
15176 p.read_field_end()?;
15177 }
15178 p.read_struct_end()?;
15179 ::std::result::Result::Ok(Self {
15180 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getTag", "req"))?,
15181 })
15182 }
15183 }
15184
15185 struct Args_MetaService_listTags {
15186 req: crate::types::ListTagsReq,
15187 }
15188 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listTags {
15189 #[inline]
15190 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listTags"))]
15191 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15192 static ARGS: &[::fbthrift::Field] = &[
15193 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15194 ];
15195 let mut field_req = ::std::option::Option::None;
15196 let _ = p.read_struct_begin(|_| ())?;
15197 loop {
15198 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15199 match (fty, fid as ::std::primitive::i32) {
15200 (::fbthrift::TType::Stop, _) => break,
15201 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15202 (fty, _) => p.skip(fty)?,
15203 }
15204 p.read_field_end()?;
15205 }
15206 p.read_struct_end()?;
15207 ::std::result::Result::Ok(Self {
15208 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listTags", "req"))?,
15209 })
15210 }
15211 }
15212
15213 struct Args_MetaService_createEdge {
15214 req: crate::types::CreateEdgeReq,
15215 }
15216 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_createEdge {
15217 #[inline]
15218 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.createEdge"))]
15219 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15220 static ARGS: &[::fbthrift::Field] = &[
15221 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15222 ];
15223 let mut field_req = ::std::option::Option::None;
15224 let _ = p.read_struct_begin(|_| ())?;
15225 loop {
15226 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15227 match (fty, fid as ::std::primitive::i32) {
15228 (::fbthrift::TType::Stop, _) => break,
15229 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15230 (fty, _) => p.skip(fty)?,
15231 }
15232 p.read_field_end()?;
15233 }
15234 p.read_struct_end()?;
15235 ::std::result::Result::Ok(Self {
15236 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.createEdge", "req"))?,
15237 })
15238 }
15239 }
15240
15241 struct Args_MetaService_alterEdge {
15242 req: crate::types::AlterEdgeReq,
15243 }
15244 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_alterEdge {
15245 #[inline]
15246 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.alterEdge"))]
15247 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15248 static ARGS: &[::fbthrift::Field] = &[
15249 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15250 ];
15251 let mut field_req = ::std::option::Option::None;
15252 let _ = p.read_struct_begin(|_| ())?;
15253 loop {
15254 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15255 match (fty, fid as ::std::primitive::i32) {
15256 (::fbthrift::TType::Stop, _) => break,
15257 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15258 (fty, _) => p.skip(fty)?,
15259 }
15260 p.read_field_end()?;
15261 }
15262 p.read_struct_end()?;
15263 ::std::result::Result::Ok(Self {
15264 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.alterEdge", "req"))?,
15265 })
15266 }
15267 }
15268
15269 struct Args_MetaService_dropEdge {
15270 req: crate::types::DropEdgeReq,
15271 }
15272 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_dropEdge {
15273 #[inline]
15274 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.dropEdge"))]
15275 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15276 static ARGS: &[::fbthrift::Field] = &[
15277 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15278 ];
15279 let mut field_req = ::std::option::Option::None;
15280 let _ = p.read_struct_begin(|_| ())?;
15281 loop {
15282 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15283 match (fty, fid as ::std::primitive::i32) {
15284 (::fbthrift::TType::Stop, _) => break,
15285 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15286 (fty, _) => p.skip(fty)?,
15287 }
15288 p.read_field_end()?;
15289 }
15290 p.read_struct_end()?;
15291 ::std::result::Result::Ok(Self {
15292 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.dropEdge", "req"))?,
15293 })
15294 }
15295 }
15296
15297 struct Args_MetaService_getEdge {
15298 req: crate::types::GetEdgeReq,
15299 }
15300 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getEdge {
15301 #[inline]
15302 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getEdge"))]
15303 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15304 static ARGS: &[::fbthrift::Field] = &[
15305 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15306 ];
15307 let mut field_req = ::std::option::Option::None;
15308 let _ = p.read_struct_begin(|_| ())?;
15309 loop {
15310 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15311 match (fty, fid as ::std::primitive::i32) {
15312 (::fbthrift::TType::Stop, _) => break,
15313 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15314 (fty, _) => p.skip(fty)?,
15315 }
15316 p.read_field_end()?;
15317 }
15318 p.read_struct_end()?;
15319 ::std::result::Result::Ok(Self {
15320 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getEdge", "req"))?,
15321 })
15322 }
15323 }
15324
15325 struct Args_MetaService_listEdges {
15326 req: crate::types::ListEdgesReq,
15327 }
15328 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listEdges {
15329 #[inline]
15330 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listEdges"))]
15331 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15332 static ARGS: &[::fbthrift::Field] = &[
15333 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15334 ];
15335 let mut field_req = ::std::option::Option::None;
15336 let _ = p.read_struct_begin(|_| ())?;
15337 loop {
15338 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15339 match (fty, fid as ::std::primitive::i32) {
15340 (::fbthrift::TType::Stop, _) => break,
15341 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15342 (fty, _) => p.skip(fty)?,
15343 }
15344 p.read_field_end()?;
15345 }
15346 p.read_struct_end()?;
15347 ::std::result::Result::Ok(Self {
15348 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listEdges", "req"))?,
15349 })
15350 }
15351 }
15352
15353 struct Args_MetaService_listHosts {
15354 req: crate::types::ListHostsReq,
15355 }
15356 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listHosts {
15357 #[inline]
15358 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listHosts"))]
15359 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15360 static ARGS: &[::fbthrift::Field] = &[
15361 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15362 ];
15363 let mut field_req = ::std::option::Option::None;
15364 let _ = p.read_struct_begin(|_| ())?;
15365 loop {
15366 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15367 match (fty, fid as ::std::primitive::i32) {
15368 (::fbthrift::TType::Stop, _) => break,
15369 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15370 (fty, _) => p.skip(fty)?,
15371 }
15372 p.read_field_end()?;
15373 }
15374 p.read_struct_end()?;
15375 ::std::result::Result::Ok(Self {
15376 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listHosts", "req"))?,
15377 })
15378 }
15379 }
15380
15381 struct Args_MetaService_getPartsAlloc {
15382 req: crate::types::GetPartsAllocReq,
15383 }
15384 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getPartsAlloc {
15385 #[inline]
15386 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getPartsAlloc"))]
15387 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15388 static ARGS: &[::fbthrift::Field] = &[
15389 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15390 ];
15391 let mut field_req = ::std::option::Option::None;
15392 let _ = p.read_struct_begin(|_| ())?;
15393 loop {
15394 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15395 match (fty, fid as ::std::primitive::i32) {
15396 (::fbthrift::TType::Stop, _) => break,
15397 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15398 (fty, _) => p.skip(fty)?,
15399 }
15400 p.read_field_end()?;
15401 }
15402 p.read_struct_end()?;
15403 ::std::result::Result::Ok(Self {
15404 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getPartsAlloc", "req"))?,
15405 })
15406 }
15407 }
15408
15409 struct Args_MetaService_listParts {
15410 req: crate::types::ListPartsReq,
15411 }
15412 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listParts {
15413 #[inline]
15414 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listParts"))]
15415 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15416 static ARGS: &[::fbthrift::Field] = &[
15417 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15418 ];
15419 let mut field_req = ::std::option::Option::None;
15420 let _ = p.read_struct_begin(|_| ())?;
15421 loop {
15422 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15423 match (fty, fid as ::std::primitive::i32) {
15424 (::fbthrift::TType::Stop, _) => break,
15425 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15426 (fty, _) => p.skip(fty)?,
15427 }
15428 p.read_field_end()?;
15429 }
15430 p.read_struct_end()?;
15431 ::std::result::Result::Ok(Self {
15432 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listParts", "req"))?,
15433 })
15434 }
15435 }
15436
15437 struct Args_MetaService_multiPut {
15438 req: crate::types::MultiPutReq,
15439 }
15440 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_multiPut {
15441 #[inline]
15442 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.multiPut"))]
15443 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15444 static ARGS: &[::fbthrift::Field] = &[
15445 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15446 ];
15447 let mut field_req = ::std::option::Option::None;
15448 let _ = p.read_struct_begin(|_| ())?;
15449 loop {
15450 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15451 match (fty, fid as ::std::primitive::i32) {
15452 (::fbthrift::TType::Stop, _) => break,
15453 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15454 (fty, _) => p.skip(fty)?,
15455 }
15456 p.read_field_end()?;
15457 }
15458 p.read_struct_end()?;
15459 ::std::result::Result::Ok(Self {
15460 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.multiPut", "req"))?,
15461 })
15462 }
15463 }
15464
15465 struct Args_MetaService_get {
15466 req: crate::types::GetReq,
15467 }
15468 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_get {
15469 #[inline]
15470 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.get"))]
15471 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15472 static ARGS: &[::fbthrift::Field] = &[
15473 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15474 ];
15475 let mut field_req = ::std::option::Option::None;
15476 let _ = p.read_struct_begin(|_| ())?;
15477 loop {
15478 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15479 match (fty, fid as ::std::primitive::i32) {
15480 (::fbthrift::TType::Stop, _) => break,
15481 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15482 (fty, _) => p.skip(fty)?,
15483 }
15484 p.read_field_end()?;
15485 }
15486 p.read_struct_end()?;
15487 ::std::result::Result::Ok(Self {
15488 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.get", "req"))?,
15489 })
15490 }
15491 }
15492
15493 struct Args_MetaService_multiGet {
15494 req: crate::types::MultiGetReq,
15495 }
15496 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_multiGet {
15497 #[inline]
15498 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.multiGet"))]
15499 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15500 static ARGS: &[::fbthrift::Field] = &[
15501 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15502 ];
15503 let mut field_req = ::std::option::Option::None;
15504 let _ = p.read_struct_begin(|_| ())?;
15505 loop {
15506 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15507 match (fty, fid as ::std::primitive::i32) {
15508 (::fbthrift::TType::Stop, _) => break,
15509 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15510 (fty, _) => p.skip(fty)?,
15511 }
15512 p.read_field_end()?;
15513 }
15514 p.read_struct_end()?;
15515 ::std::result::Result::Ok(Self {
15516 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.multiGet", "req"))?,
15517 })
15518 }
15519 }
15520
15521 struct Args_MetaService_remove {
15522 req: crate::types::RemoveReq,
15523 }
15524 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_remove {
15525 #[inline]
15526 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.remove"))]
15527 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15528 static ARGS: &[::fbthrift::Field] = &[
15529 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15530 ];
15531 let mut field_req = ::std::option::Option::None;
15532 let _ = p.read_struct_begin(|_| ())?;
15533 loop {
15534 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15535 match (fty, fid as ::std::primitive::i32) {
15536 (::fbthrift::TType::Stop, _) => break,
15537 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15538 (fty, _) => p.skip(fty)?,
15539 }
15540 p.read_field_end()?;
15541 }
15542 p.read_struct_end()?;
15543 ::std::result::Result::Ok(Self {
15544 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.remove", "req"))?,
15545 })
15546 }
15547 }
15548
15549 struct Args_MetaService_removeRange {
15550 req: crate::types::RemoveRangeReq,
15551 }
15552 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_removeRange {
15553 #[inline]
15554 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.removeRange"))]
15555 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15556 static ARGS: &[::fbthrift::Field] = &[
15557 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15558 ];
15559 let mut field_req = ::std::option::Option::None;
15560 let _ = p.read_struct_begin(|_| ())?;
15561 loop {
15562 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15563 match (fty, fid as ::std::primitive::i32) {
15564 (::fbthrift::TType::Stop, _) => break,
15565 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15566 (fty, _) => p.skip(fty)?,
15567 }
15568 p.read_field_end()?;
15569 }
15570 p.read_struct_end()?;
15571 ::std::result::Result::Ok(Self {
15572 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.removeRange", "req"))?,
15573 })
15574 }
15575 }
15576
15577 struct Args_MetaService_scan {
15578 req: crate::types::ScanReq,
15579 }
15580 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_scan {
15581 #[inline]
15582 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.scan"))]
15583 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15584 static ARGS: &[::fbthrift::Field] = &[
15585 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15586 ];
15587 let mut field_req = ::std::option::Option::None;
15588 let _ = p.read_struct_begin(|_| ())?;
15589 loop {
15590 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15591 match (fty, fid as ::std::primitive::i32) {
15592 (::fbthrift::TType::Stop, _) => break,
15593 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15594 (fty, _) => p.skip(fty)?,
15595 }
15596 p.read_field_end()?;
15597 }
15598 p.read_struct_end()?;
15599 ::std::result::Result::Ok(Self {
15600 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.scan", "req"))?,
15601 })
15602 }
15603 }
15604
15605 struct Args_MetaService_createTagIndex {
15606 req: crate::types::CreateTagIndexReq,
15607 }
15608 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_createTagIndex {
15609 #[inline]
15610 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.createTagIndex"))]
15611 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15612 static ARGS: &[::fbthrift::Field] = &[
15613 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15614 ];
15615 let mut field_req = ::std::option::Option::None;
15616 let _ = p.read_struct_begin(|_| ())?;
15617 loop {
15618 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15619 match (fty, fid as ::std::primitive::i32) {
15620 (::fbthrift::TType::Stop, _) => break,
15621 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15622 (fty, _) => p.skip(fty)?,
15623 }
15624 p.read_field_end()?;
15625 }
15626 p.read_struct_end()?;
15627 ::std::result::Result::Ok(Self {
15628 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.createTagIndex", "req"))?,
15629 })
15630 }
15631 }
15632
15633 struct Args_MetaService_dropTagIndex {
15634 req: crate::types::DropTagIndexReq,
15635 }
15636 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_dropTagIndex {
15637 #[inline]
15638 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.dropTagIndex"))]
15639 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15640 static ARGS: &[::fbthrift::Field] = &[
15641 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15642 ];
15643 let mut field_req = ::std::option::Option::None;
15644 let _ = p.read_struct_begin(|_| ())?;
15645 loop {
15646 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15647 match (fty, fid as ::std::primitive::i32) {
15648 (::fbthrift::TType::Stop, _) => break,
15649 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15650 (fty, _) => p.skip(fty)?,
15651 }
15652 p.read_field_end()?;
15653 }
15654 p.read_struct_end()?;
15655 ::std::result::Result::Ok(Self {
15656 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.dropTagIndex", "req"))?,
15657 })
15658 }
15659 }
15660
15661 struct Args_MetaService_getTagIndex {
15662 req: crate::types::GetTagIndexReq,
15663 }
15664 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getTagIndex {
15665 #[inline]
15666 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getTagIndex"))]
15667 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15668 static ARGS: &[::fbthrift::Field] = &[
15669 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15670 ];
15671 let mut field_req = ::std::option::Option::None;
15672 let _ = p.read_struct_begin(|_| ())?;
15673 loop {
15674 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15675 match (fty, fid as ::std::primitive::i32) {
15676 (::fbthrift::TType::Stop, _) => break,
15677 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15678 (fty, _) => p.skip(fty)?,
15679 }
15680 p.read_field_end()?;
15681 }
15682 p.read_struct_end()?;
15683 ::std::result::Result::Ok(Self {
15684 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getTagIndex", "req"))?,
15685 })
15686 }
15687 }
15688
15689 struct Args_MetaService_listTagIndexes {
15690 req: crate::types::ListTagIndexesReq,
15691 }
15692 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listTagIndexes {
15693 #[inline]
15694 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listTagIndexes"))]
15695 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15696 static ARGS: &[::fbthrift::Field] = &[
15697 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15698 ];
15699 let mut field_req = ::std::option::Option::None;
15700 let _ = p.read_struct_begin(|_| ())?;
15701 loop {
15702 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15703 match (fty, fid as ::std::primitive::i32) {
15704 (::fbthrift::TType::Stop, _) => break,
15705 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15706 (fty, _) => p.skip(fty)?,
15707 }
15708 p.read_field_end()?;
15709 }
15710 p.read_struct_end()?;
15711 ::std::result::Result::Ok(Self {
15712 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listTagIndexes", "req"))?,
15713 })
15714 }
15715 }
15716
15717 struct Args_MetaService_rebuildTagIndex {
15718 req: crate::types::RebuildIndexReq,
15719 }
15720 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_rebuildTagIndex {
15721 #[inline]
15722 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.rebuildTagIndex"))]
15723 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15724 static ARGS: &[::fbthrift::Field] = &[
15725 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15726 ];
15727 let mut field_req = ::std::option::Option::None;
15728 let _ = p.read_struct_begin(|_| ())?;
15729 loop {
15730 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15731 match (fty, fid as ::std::primitive::i32) {
15732 (::fbthrift::TType::Stop, _) => break,
15733 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15734 (fty, _) => p.skip(fty)?,
15735 }
15736 p.read_field_end()?;
15737 }
15738 p.read_struct_end()?;
15739 ::std::result::Result::Ok(Self {
15740 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.rebuildTagIndex", "req"))?,
15741 })
15742 }
15743 }
15744
15745 struct Args_MetaService_listTagIndexStatus {
15746 req: crate::types::ListIndexStatusReq,
15747 }
15748 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listTagIndexStatus {
15749 #[inline]
15750 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listTagIndexStatus"))]
15751 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15752 static ARGS: &[::fbthrift::Field] = &[
15753 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15754 ];
15755 let mut field_req = ::std::option::Option::None;
15756 let _ = p.read_struct_begin(|_| ())?;
15757 loop {
15758 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15759 match (fty, fid as ::std::primitive::i32) {
15760 (::fbthrift::TType::Stop, _) => break,
15761 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15762 (fty, _) => p.skip(fty)?,
15763 }
15764 p.read_field_end()?;
15765 }
15766 p.read_struct_end()?;
15767 ::std::result::Result::Ok(Self {
15768 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listTagIndexStatus", "req"))?,
15769 })
15770 }
15771 }
15772
15773 struct Args_MetaService_createEdgeIndex {
15774 req: crate::types::CreateEdgeIndexReq,
15775 }
15776 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_createEdgeIndex {
15777 #[inline]
15778 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.createEdgeIndex"))]
15779 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15780 static ARGS: &[::fbthrift::Field] = &[
15781 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15782 ];
15783 let mut field_req = ::std::option::Option::None;
15784 let _ = p.read_struct_begin(|_| ())?;
15785 loop {
15786 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15787 match (fty, fid as ::std::primitive::i32) {
15788 (::fbthrift::TType::Stop, _) => break,
15789 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15790 (fty, _) => p.skip(fty)?,
15791 }
15792 p.read_field_end()?;
15793 }
15794 p.read_struct_end()?;
15795 ::std::result::Result::Ok(Self {
15796 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.createEdgeIndex", "req"))?,
15797 })
15798 }
15799 }
15800
15801 struct Args_MetaService_dropEdgeIndex {
15802 req: crate::types::DropEdgeIndexReq,
15803 }
15804 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_dropEdgeIndex {
15805 #[inline]
15806 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.dropEdgeIndex"))]
15807 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15808 static ARGS: &[::fbthrift::Field] = &[
15809 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15810 ];
15811 let mut field_req = ::std::option::Option::None;
15812 let _ = p.read_struct_begin(|_| ())?;
15813 loop {
15814 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15815 match (fty, fid as ::std::primitive::i32) {
15816 (::fbthrift::TType::Stop, _) => break,
15817 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15818 (fty, _) => p.skip(fty)?,
15819 }
15820 p.read_field_end()?;
15821 }
15822 p.read_struct_end()?;
15823 ::std::result::Result::Ok(Self {
15824 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.dropEdgeIndex", "req"))?,
15825 })
15826 }
15827 }
15828
15829 struct Args_MetaService_getEdgeIndex {
15830 req: crate::types::GetEdgeIndexReq,
15831 }
15832 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getEdgeIndex {
15833 #[inline]
15834 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getEdgeIndex"))]
15835 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15836 static ARGS: &[::fbthrift::Field] = &[
15837 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15838 ];
15839 let mut field_req = ::std::option::Option::None;
15840 let _ = p.read_struct_begin(|_| ())?;
15841 loop {
15842 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15843 match (fty, fid as ::std::primitive::i32) {
15844 (::fbthrift::TType::Stop, _) => break,
15845 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15846 (fty, _) => p.skip(fty)?,
15847 }
15848 p.read_field_end()?;
15849 }
15850 p.read_struct_end()?;
15851 ::std::result::Result::Ok(Self {
15852 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getEdgeIndex", "req"))?,
15853 })
15854 }
15855 }
15856
15857 struct Args_MetaService_listEdgeIndexes {
15858 req: crate::types::ListEdgeIndexesReq,
15859 }
15860 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listEdgeIndexes {
15861 #[inline]
15862 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listEdgeIndexes"))]
15863 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15864 static ARGS: &[::fbthrift::Field] = &[
15865 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15866 ];
15867 let mut field_req = ::std::option::Option::None;
15868 let _ = p.read_struct_begin(|_| ())?;
15869 loop {
15870 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15871 match (fty, fid as ::std::primitive::i32) {
15872 (::fbthrift::TType::Stop, _) => break,
15873 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15874 (fty, _) => p.skip(fty)?,
15875 }
15876 p.read_field_end()?;
15877 }
15878 p.read_struct_end()?;
15879 ::std::result::Result::Ok(Self {
15880 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listEdgeIndexes", "req"))?,
15881 })
15882 }
15883 }
15884
15885 struct Args_MetaService_rebuildEdgeIndex {
15886 req: crate::types::RebuildIndexReq,
15887 }
15888 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_rebuildEdgeIndex {
15889 #[inline]
15890 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.rebuildEdgeIndex"))]
15891 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15892 static ARGS: &[::fbthrift::Field] = &[
15893 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15894 ];
15895 let mut field_req = ::std::option::Option::None;
15896 let _ = p.read_struct_begin(|_| ())?;
15897 loop {
15898 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15899 match (fty, fid as ::std::primitive::i32) {
15900 (::fbthrift::TType::Stop, _) => break,
15901 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15902 (fty, _) => p.skip(fty)?,
15903 }
15904 p.read_field_end()?;
15905 }
15906 p.read_struct_end()?;
15907 ::std::result::Result::Ok(Self {
15908 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.rebuildEdgeIndex", "req"))?,
15909 })
15910 }
15911 }
15912
15913 struct Args_MetaService_listEdgeIndexStatus {
15914 req: crate::types::ListIndexStatusReq,
15915 }
15916 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listEdgeIndexStatus {
15917 #[inline]
15918 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listEdgeIndexStatus"))]
15919 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15920 static ARGS: &[::fbthrift::Field] = &[
15921 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15922 ];
15923 let mut field_req = ::std::option::Option::None;
15924 let _ = p.read_struct_begin(|_| ())?;
15925 loop {
15926 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15927 match (fty, fid as ::std::primitive::i32) {
15928 (::fbthrift::TType::Stop, _) => break,
15929 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15930 (fty, _) => p.skip(fty)?,
15931 }
15932 p.read_field_end()?;
15933 }
15934 p.read_struct_end()?;
15935 ::std::result::Result::Ok(Self {
15936 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listEdgeIndexStatus", "req"))?,
15937 })
15938 }
15939 }
15940
15941 struct Args_MetaService_createUser {
15942 req: crate::types::CreateUserReq,
15943 }
15944 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_createUser {
15945 #[inline]
15946 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.createUser"))]
15947 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15948 static ARGS: &[::fbthrift::Field] = &[
15949 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15950 ];
15951 let mut field_req = ::std::option::Option::None;
15952 let _ = p.read_struct_begin(|_| ())?;
15953 loop {
15954 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15955 match (fty, fid as ::std::primitive::i32) {
15956 (::fbthrift::TType::Stop, _) => break,
15957 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15958 (fty, _) => p.skip(fty)?,
15959 }
15960 p.read_field_end()?;
15961 }
15962 p.read_struct_end()?;
15963 ::std::result::Result::Ok(Self {
15964 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.createUser", "req"))?,
15965 })
15966 }
15967 }
15968
15969 struct Args_MetaService_dropUser {
15970 req: crate::types::DropUserReq,
15971 }
15972 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_dropUser {
15973 #[inline]
15974 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.dropUser"))]
15975 fn read(p: &mut P) -> ::anyhow::Result<Self> {
15976 static ARGS: &[::fbthrift::Field] = &[
15977 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
15978 ];
15979 let mut field_req = ::std::option::Option::None;
15980 let _ = p.read_struct_begin(|_| ())?;
15981 loop {
15982 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
15983 match (fty, fid as ::std::primitive::i32) {
15984 (::fbthrift::TType::Stop, _) => break,
15985 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
15986 (fty, _) => p.skip(fty)?,
15987 }
15988 p.read_field_end()?;
15989 }
15990 p.read_struct_end()?;
15991 ::std::result::Result::Ok(Self {
15992 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.dropUser", "req"))?,
15993 })
15994 }
15995 }
15996
15997 struct Args_MetaService_alterUser {
15998 req: crate::types::AlterUserReq,
15999 }
16000 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_alterUser {
16001 #[inline]
16002 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.alterUser"))]
16003 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16004 static ARGS: &[::fbthrift::Field] = &[
16005 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16006 ];
16007 let mut field_req = ::std::option::Option::None;
16008 let _ = p.read_struct_begin(|_| ())?;
16009 loop {
16010 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16011 match (fty, fid as ::std::primitive::i32) {
16012 (::fbthrift::TType::Stop, _) => break,
16013 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16014 (fty, _) => p.skip(fty)?,
16015 }
16016 p.read_field_end()?;
16017 }
16018 p.read_struct_end()?;
16019 ::std::result::Result::Ok(Self {
16020 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.alterUser", "req"))?,
16021 })
16022 }
16023 }
16024
16025 struct Args_MetaService_grantRole {
16026 req: crate::types::GrantRoleReq,
16027 }
16028 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_grantRole {
16029 #[inline]
16030 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.grantRole"))]
16031 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16032 static ARGS: &[::fbthrift::Field] = &[
16033 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16034 ];
16035 let mut field_req = ::std::option::Option::None;
16036 let _ = p.read_struct_begin(|_| ())?;
16037 loop {
16038 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16039 match (fty, fid as ::std::primitive::i32) {
16040 (::fbthrift::TType::Stop, _) => break,
16041 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16042 (fty, _) => p.skip(fty)?,
16043 }
16044 p.read_field_end()?;
16045 }
16046 p.read_struct_end()?;
16047 ::std::result::Result::Ok(Self {
16048 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.grantRole", "req"))?,
16049 })
16050 }
16051 }
16052
16053 struct Args_MetaService_revokeRole {
16054 req: crate::types::RevokeRoleReq,
16055 }
16056 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_revokeRole {
16057 #[inline]
16058 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.revokeRole"))]
16059 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16060 static ARGS: &[::fbthrift::Field] = &[
16061 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16062 ];
16063 let mut field_req = ::std::option::Option::None;
16064 let _ = p.read_struct_begin(|_| ())?;
16065 loop {
16066 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16067 match (fty, fid as ::std::primitive::i32) {
16068 (::fbthrift::TType::Stop, _) => break,
16069 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16070 (fty, _) => p.skip(fty)?,
16071 }
16072 p.read_field_end()?;
16073 }
16074 p.read_struct_end()?;
16075 ::std::result::Result::Ok(Self {
16076 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.revokeRole", "req"))?,
16077 })
16078 }
16079 }
16080
16081 struct Args_MetaService_listUsers {
16082 req: crate::types::ListUsersReq,
16083 }
16084 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listUsers {
16085 #[inline]
16086 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listUsers"))]
16087 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16088 static ARGS: &[::fbthrift::Field] = &[
16089 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16090 ];
16091 let mut field_req = ::std::option::Option::None;
16092 let _ = p.read_struct_begin(|_| ())?;
16093 loop {
16094 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16095 match (fty, fid as ::std::primitive::i32) {
16096 (::fbthrift::TType::Stop, _) => break,
16097 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16098 (fty, _) => p.skip(fty)?,
16099 }
16100 p.read_field_end()?;
16101 }
16102 p.read_struct_end()?;
16103 ::std::result::Result::Ok(Self {
16104 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listUsers", "req"))?,
16105 })
16106 }
16107 }
16108
16109 struct Args_MetaService_listRoles {
16110 req: crate::types::ListRolesReq,
16111 }
16112 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listRoles {
16113 #[inline]
16114 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listRoles"))]
16115 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16116 static ARGS: &[::fbthrift::Field] = &[
16117 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16118 ];
16119 let mut field_req = ::std::option::Option::None;
16120 let _ = p.read_struct_begin(|_| ())?;
16121 loop {
16122 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16123 match (fty, fid as ::std::primitive::i32) {
16124 (::fbthrift::TType::Stop, _) => break,
16125 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16126 (fty, _) => p.skip(fty)?,
16127 }
16128 p.read_field_end()?;
16129 }
16130 p.read_struct_end()?;
16131 ::std::result::Result::Ok(Self {
16132 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listRoles", "req"))?,
16133 })
16134 }
16135 }
16136
16137 struct Args_MetaService_getUserRoles {
16138 req: crate::types::GetUserRolesReq,
16139 }
16140 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getUserRoles {
16141 #[inline]
16142 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getUserRoles"))]
16143 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16144 static ARGS: &[::fbthrift::Field] = &[
16145 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16146 ];
16147 let mut field_req = ::std::option::Option::None;
16148 let _ = p.read_struct_begin(|_| ())?;
16149 loop {
16150 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16151 match (fty, fid as ::std::primitive::i32) {
16152 (::fbthrift::TType::Stop, _) => break,
16153 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16154 (fty, _) => p.skip(fty)?,
16155 }
16156 p.read_field_end()?;
16157 }
16158 p.read_struct_end()?;
16159 ::std::result::Result::Ok(Self {
16160 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getUserRoles", "req"))?,
16161 })
16162 }
16163 }
16164
16165 struct Args_MetaService_changePassword {
16166 req: crate::types::ChangePasswordReq,
16167 }
16168 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_changePassword {
16169 #[inline]
16170 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.changePassword"))]
16171 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16172 static ARGS: &[::fbthrift::Field] = &[
16173 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16174 ];
16175 let mut field_req = ::std::option::Option::None;
16176 let _ = p.read_struct_begin(|_| ())?;
16177 loop {
16178 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16179 match (fty, fid as ::std::primitive::i32) {
16180 (::fbthrift::TType::Stop, _) => break,
16181 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16182 (fty, _) => p.skip(fty)?,
16183 }
16184 p.read_field_end()?;
16185 }
16186 p.read_struct_end()?;
16187 ::std::result::Result::Ok(Self {
16188 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.changePassword", "req"))?,
16189 })
16190 }
16191 }
16192
16193 struct Args_MetaService_heartBeat {
16194 req: crate::types::HBReq,
16195 }
16196 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_heartBeat {
16197 #[inline]
16198 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.heartBeat"))]
16199 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16200 static ARGS: &[::fbthrift::Field] = &[
16201 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16202 ];
16203 let mut field_req = ::std::option::Option::None;
16204 let _ = p.read_struct_begin(|_| ())?;
16205 loop {
16206 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16207 match (fty, fid as ::std::primitive::i32) {
16208 (::fbthrift::TType::Stop, _) => break,
16209 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16210 (fty, _) => p.skip(fty)?,
16211 }
16212 p.read_field_end()?;
16213 }
16214 p.read_struct_end()?;
16215 ::std::result::Result::Ok(Self {
16216 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.heartBeat", "req"))?,
16217 })
16218 }
16219 }
16220
16221 struct Args_MetaService_balance {
16222 req: crate::types::BalanceReq,
16223 }
16224 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_balance {
16225 #[inline]
16226 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.balance"))]
16227 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16228 static ARGS: &[::fbthrift::Field] = &[
16229 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16230 ];
16231 let mut field_req = ::std::option::Option::None;
16232 let _ = p.read_struct_begin(|_| ())?;
16233 loop {
16234 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16235 match (fty, fid as ::std::primitive::i32) {
16236 (::fbthrift::TType::Stop, _) => break,
16237 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16238 (fty, _) => p.skip(fty)?,
16239 }
16240 p.read_field_end()?;
16241 }
16242 p.read_struct_end()?;
16243 ::std::result::Result::Ok(Self {
16244 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.balance", "req"))?,
16245 })
16246 }
16247 }
16248
16249 struct Args_MetaService_leaderBalance {
16250 req: crate::types::LeaderBalanceReq,
16251 }
16252 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_leaderBalance {
16253 #[inline]
16254 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.leaderBalance"))]
16255 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16256 static ARGS: &[::fbthrift::Field] = &[
16257 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16258 ];
16259 let mut field_req = ::std::option::Option::None;
16260 let _ = p.read_struct_begin(|_| ())?;
16261 loop {
16262 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16263 match (fty, fid as ::std::primitive::i32) {
16264 (::fbthrift::TType::Stop, _) => break,
16265 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16266 (fty, _) => p.skip(fty)?,
16267 }
16268 p.read_field_end()?;
16269 }
16270 p.read_struct_end()?;
16271 ::std::result::Result::Ok(Self {
16272 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.leaderBalance", "req"))?,
16273 })
16274 }
16275 }
16276
16277 struct Args_MetaService_regConfig {
16278 req: crate::types::RegConfigReq,
16279 }
16280 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_regConfig {
16281 #[inline]
16282 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.regConfig"))]
16283 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16284 static ARGS: &[::fbthrift::Field] = &[
16285 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16286 ];
16287 let mut field_req = ::std::option::Option::None;
16288 let _ = p.read_struct_begin(|_| ())?;
16289 loop {
16290 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16291 match (fty, fid as ::std::primitive::i32) {
16292 (::fbthrift::TType::Stop, _) => break,
16293 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16294 (fty, _) => p.skip(fty)?,
16295 }
16296 p.read_field_end()?;
16297 }
16298 p.read_struct_end()?;
16299 ::std::result::Result::Ok(Self {
16300 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.regConfig", "req"))?,
16301 })
16302 }
16303 }
16304
16305 struct Args_MetaService_getConfig {
16306 req: crate::types::GetConfigReq,
16307 }
16308 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_getConfig {
16309 #[inline]
16310 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.getConfig"))]
16311 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16312 static ARGS: &[::fbthrift::Field] = &[
16313 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16314 ];
16315 let mut field_req = ::std::option::Option::None;
16316 let _ = p.read_struct_begin(|_| ())?;
16317 loop {
16318 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16319 match (fty, fid as ::std::primitive::i32) {
16320 (::fbthrift::TType::Stop, _) => break,
16321 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16322 (fty, _) => p.skip(fty)?,
16323 }
16324 p.read_field_end()?;
16325 }
16326 p.read_struct_end()?;
16327 ::std::result::Result::Ok(Self {
16328 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.getConfig", "req"))?,
16329 })
16330 }
16331 }
16332
16333 struct Args_MetaService_setConfig {
16334 req: crate::types::SetConfigReq,
16335 }
16336 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_setConfig {
16337 #[inline]
16338 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.setConfig"))]
16339 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16340 static ARGS: &[::fbthrift::Field] = &[
16341 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16342 ];
16343 let mut field_req = ::std::option::Option::None;
16344 let _ = p.read_struct_begin(|_| ())?;
16345 loop {
16346 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16347 match (fty, fid as ::std::primitive::i32) {
16348 (::fbthrift::TType::Stop, _) => break,
16349 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16350 (fty, _) => p.skip(fty)?,
16351 }
16352 p.read_field_end()?;
16353 }
16354 p.read_struct_end()?;
16355 ::std::result::Result::Ok(Self {
16356 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.setConfig", "req"))?,
16357 })
16358 }
16359 }
16360
16361 struct Args_MetaService_listConfigs {
16362 req: crate::types::ListConfigsReq,
16363 }
16364 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listConfigs {
16365 #[inline]
16366 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listConfigs"))]
16367 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16368 static ARGS: &[::fbthrift::Field] = &[
16369 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16370 ];
16371 let mut field_req = ::std::option::Option::None;
16372 let _ = p.read_struct_begin(|_| ())?;
16373 loop {
16374 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16375 match (fty, fid as ::std::primitive::i32) {
16376 (::fbthrift::TType::Stop, _) => break,
16377 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16378 (fty, _) => p.skip(fty)?,
16379 }
16380 p.read_field_end()?;
16381 }
16382 p.read_struct_end()?;
16383 ::std::result::Result::Ok(Self {
16384 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listConfigs", "req"))?,
16385 })
16386 }
16387 }
16388
16389 struct Args_MetaService_createSnapshot {
16390 req: crate::types::CreateSnapshotReq,
16391 }
16392 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_createSnapshot {
16393 #[inline]
16394 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.createSnapshot"))]
16395 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16396 static ARGS: &[::fbthrift::Field] = &[
16397 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16398 ];
16399 let mut field_req = ::std::option::Option::None;
16400 let _ = p.read_struct_begin(|_| ())?;
16401 loop {
16402 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16403 match (fty, fid as ::std::primitive::i32) {
16404 (::fbthrift::TType::Stop, _) => break,
16405 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16406 (fty, _) => p.skip(fty)?,
16407 }
16408 p.read_field_end()?;
16409 }
16410 p.read_struct_end()?;
16411 ::std::result::Result::Ok(Self {
16412 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.createSnapshot", "req"))?,
16413 })
16414 }
16415 }
16416
16417 struct Args_MetaService_dropSnapshot {
16418 req: crate::types::DropSnapshotReq,
16419 }
16420 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_dropSnapshot {
16421 #[inline]
16422 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.dropSnapshot"))]
16423 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16424 static ARGS: &[::fbthrift::Field] = &[
16425 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16426 ];
16427 let mut field_req = ::std::option::Option::None;
16428 let _ = p.read_struct_begin(|_| ())?;
16429 loop {
16430 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16431 match (fty, fid as ::std::primitive::i32) {
16432 (::fbthrift::TType::Stop, _) => break,
16433 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16434 (fty, _) => p.skip(fty)?,
16435 }
16436 p.read_field_end()?;
16437 }
16438 p.read_struct_end()?;
16439 ::std::result::Result::Ok(Self {
16440 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.dropSnapshot", "req"))?,
16441 })
16442 }
16443 }
16444
16445 struct Args_MetaService_listSnapshots {
16446 req: crate::types::ListSnapshotsReq,
16447 }
16448 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_listSnapshots {
16449 #[inline]
16450 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.listSnapshots"))]
16451 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16452 static ARGS: &[::fbthrift::Field] = &[
16453 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16454 ];
16455 let mut field_req = ::std::option::Option::None;
16456 let _ = p.read_struct_begin(|_| ())?;
16457 loop {
16458 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16459 match (fty, fid as ::std::primitive::i32) {
16460 (::fbthrift::TType::Stop, _) => break,
16461 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16462 (fty, _) => p.skip(fty)?,
16463 }
16464 p.read_field_end()?;
16465 }
16466 p.read_struct_end()?;
16467 ::std::result::Result::Ok(Self {
16468 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.listSnapshots", "req"))?,
16469 })
16470 }
16471 }
16472
16473 struct Args_MetaService_runAdminJob {
16474 req: crate::types::AdminJobReq,
16475 }
16476 impl<P: ::fbthrift::ProtocolReader> ::fbthrift::Deserialize<P> for self::Args_MetaService_runAdminJob {
16477 #[inline]
16478 #[::tracing::instrument(skip_all, level = "trace", name = "deserialize_args", fields(method = "MetaService.runAdminJob"))]
16479 fn read(p: &mut P) -> ::anyhow::Result<Self> {
16480 static ARGS: &[::fbthrift::Field] = &[
16481 ::fbthrift::Field::new("req", ::fbthrift::TType::Struct, 1),
16482 ];
16483 let mut field_req = ::std::option::Option::None;
16484 let _ = p.read_struct_begin(|_| ())?;
16485 loop {
16486 let (_, fty, fid) = p.read_field_begin(|_| (), ARGS)?;
16487 match (fty, fid as ::std::primitive::i32) {
16488 (::fbthrift::TType::Stop, _) => break,
16489 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
16490 (fty, _) => p.skip(fty)?,
16491 }
16492 p.read_field_end()?;
16493 }
16494 p.read_struct_end()?;
16495 ::std::result::Result::Ok(Self {
16496 req: field_req.ok_or_else(|| ::anyhow::anyhow!("`{}` missing arg `{}`", "MetaService.runAdminJob", "req"))?,
16497 })
16498 }
16499 }
16500
16501
16502 impl<P, H, R, RS> MetaServiceProcessor<P, H, R, RS>
16503 where
16504 P: ::fbthrift::Protocol + ::std::marker::Send + ::std::marker::Sync + 'static,
16505 P::Frame: ::std::marker::Send + 'static,
16506 P::Deserializer: ::std::marker::Send,
16507 H: MetaService,
16508 R: ::fbthrift::RequestContext<Name = ::std::ffi::CStr> + ::std::marker::Send + ::std::marker::Sync + 'static,
16509 RS: ::fbthrift::ReplyState<P::Frame, RequestContext = R> + ::std::marker::Send + ::std::marker::Sync + 'static,
16510 <R as ::fbthrift::RequestContext>::ContextStack: ::fbthrift::ContextStack<Name = R::Name, Buffer = ::fbthrift::ProtocolDecoded<P>>
16511 + ::std::marker::Send + ::std::marker::Sync,
16512 {
16513 pub fn new(service: H) -> Self {
16514 Self {
16515 service,
16516 supa: ::fbthrift::NullServiceProcessor::new(),
16517 _phantom: ::std::marker::PhantomData,
16518 }
16519 }
16520
16521 pub fn into_inner(self) -> H {
16522 self.service
16523 }
16524
16525 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.createSpace"))]
16526 async fn handle_createSpace<'a>(
16527 &'a self,
16528 p: &'a mut P::Deserializer,
16529 req_ctxt: &R,
16530 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
16531 _seqid: ::std::primitive::u32,
16532 ) -> ::anyhow::Result<()> {
16533 use ::const_cstr::const_cstr;
16534 use ::futures::FutureExt as _;
16535
16536 const_cstr! {
16537 SERVICE_NAME = "MetaService";
16538 METHOD_NAME = "MetaService.createSpace";
16539 }
16540 let mut ctx_stack = req_ctxt.get_context_stack(
16541 SERVICE_NAME.as_cstr(),
16542 METHOD_NAME.as_cstr(),
16543 )?;
16544 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
16545 let _args: self::Args_MetaService_createSpace = ::fbthrift::Deserialize::read(p)?;
16546 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
16547 protocol: P::PROTOCOL_ID,
16548 method_name: METHOD_NAME.as_cstr(),
16549 buffer: ::std::marker::PhantomData, })?;
16551 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
16552
16553 let res = ::std::panic::AssertUnwindSafe(
16554 self.service.createSpace(
16555 _args.req,
16556 )
16557 )
16558 .catch_unwind()
16559 .await;
16560
16561 let res = match res {
16563 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
16564 ::tracing::info!("success");
16565 crate::services::meta_service::CreateSpaceExn::Success(res)
16566 }
16567 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::CreateSpaceExn::Success(_))) => {
16568 panic!(
16569 "{} attempted to return success via error",
16570 "createSpace",
16571 )
16572 }
16573 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
16574 ::tracing::error!(exception = ?exn);
16575 exn
16576 }
16577 ::std::result::Result::Err(exn) => {
16578 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.createSpace", exn);
16579 crate::services::meta_service::CreateSpaceExn::ApplicationException(aexn)
16580 }
16581 };
16582
16583 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
16584 "createSpace",
16585 METHOD_NAME.as_cstr(),
16586 _seqid,
16587 req_ctxt,
16588 &mut ctx_stack,
16589 res
16590 )?;
16591 reply_state.lock().unwrap().send_reply(env);
16592 Ok(())
16593 }
16594
16595 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.dropSpace"))]
16596 async fn handle_dropSpace<'a>(
16597 &'a self,
16598 p: &'a mut P::Deserializer,
16599 req_ctxt: &R,
16600 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
16601 _seqid: ::std::primitive::u32,
16602 ) -> ::anyhow::Result<()> {
16603 use ::const_cstr::const_cstr;
16604 use ::futures::FutureExt as _;
16605
16606 const_cstr! {
16607 SERVICE_NAME = "MetaService";
16608 METHOD_NAME = "MetaService.dropSpace";
16609 }
16610 let mut ctx_stack = req_ctxt.get_context_stack(
16611 SERVICE_NAME.as_cstr(),
16612 METHOD_NAME.as_cstr(),
16613 )?;
16614 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
16615 let _args: self::Args_MetaService_dropSpace = ::fbthrift::Deserialize::read(p)?;
16616 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
16617 protocol: P::PROTOCOL_ID,
16618 method_name: METHOD_NAME.as_cstr(),
16619 buffer: ::std::marker::PhantomData, })?;
16621 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
16622
16623 let res = ::std::panic::AssertUnwindSafe(
16624 self.service.dropSpace(
16625 _args.req,
16626 )
16627 )
16628 .catch_unwind()
16629 .await;
16630
16631 let res = match res {
16633 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
16634 ::tracing::info!("success");
16635 crate::services::meta_service::DropSpaceExn::Success(res)
16636 }
16637 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::DropSpaceExn::Success(_))) => {
16638 panic!(
16639 "{} attempted to return success via error",
16640 "dropSpace",
16641 )
16642 }
16643 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
16644 ::tracing::error!(exception = ?exn);
16645 exn
16646 }
16647 ::std::result::Result::Err(exn) => {
16648 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.dropSpace", exn);
16649 crate::services::meta_service::DropSpaceExn::ApplicationException(aexn)
16650 }
16651 };
16652
16653 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
16654 "dropSpace",
16655 METHOD_NAME.as_cstr(),
16656 _seqid,
16657 req_ctxt,
16658 &mut ctx_stack,
16659 res
16660 )?;
16661 reply_state.lock().unwrap().send_reply(env);
16662 Ok(())
16663 }
16664
16665 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getSpace"))]
16666 async fn handle_getSpace<'a>(
16667 &'a self,
16668 p: &'a mut P::Deserializer,
16669 req_ctxt: &R,
16670 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
16671 _seqid: ::std::primitive::u32,
16672 ) -> ::anyhow::Result<()> {
16673 use ::const_cstr::const_cstr;
16674 use ::futures::FutureExt as _;
16675
16676 const_cstr! {
16677 SERVICE_NAME = "MetaService";
16678 METHOD_NAME = "MetaService.getSpace";
16679 }
16680 let mut ctx_stack = req_ctxt.get_context_stack(
16681 SERVICE_NAME.as_cstr(),
16682 METHOD_NAME.as_cstr(),
16683 )?;
16684 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
16685 let _args: self::Args_MetaService_getSpace = ::fbthrift::Deserialize::read(p)?;
16686 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
16687 protocol: P::PROTOCOL_ID,
16688 method_name: METHOD_NAME.as_cstr(),
16689 buffer: ::std::marker::PhantomData, })?;
16691 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
16692
16693 let res = ::std::panic::AssertUnwindSafe(
16694 self.service.getSpace(
16695 _args.req,
16696 )
16697 )
16698 .catch_unwind()
16699 .await;
16700
16701 let res = match res {
16703 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
16704 ::tracing::info!("success");
16705 crate::services::meta_service::GetSpaceExn::Success(res)
16706 }
16707 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetSpaceExn::Success(_))) => {
16708 panic!(
16709 "{} attempted to return success via error",
16710 "getSpace",
16711 )
16712 }
16713 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
16714 ::tracing::error!(exception = ?exn);
16715 exn
16716 }
16717 ::std::result::Result::Err(exn) => {
16718 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getSpace", exn);
16719 crate::services::meta_service::GetSpaceExn::ApplicationException(aexn)
16720 }
16721 };
16722
16723 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
16724 "getSpace",
16725 METHOD_NAME.as_cstr(),
16726 _seqid,
16727 req_ctxt,
16728 &mut ctx_stack,
16729 res
16730 )?;
16731 reply_state.lock().unwrap().send_reply(env);
16732 Ok(())
16733 }
16734
16735 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listSpaces"))]
16736 async fn handle_listSpaces<'a>(
16737 &'a self,
16738 p: &'a mut P::Deserializer,
16739 req_ctxt: &R,
16740 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
16741 _seqid: ::std::primitive::u32,
16742 ) -> ::anyhow::Result<()> {
16743 use ::const_cstr::const_cstr;
16744 use ::futures::FutureExt as _;
16745
16746 const_cstr! {
16747 SERVICE_NAME = "MetaService";
16748 METHOD_NAME = "MetaService.listSpaces";
16749 }
16750 let mut ctx_stack = req_ctxt.get_context_stack(
16751 SERVICE_NAME.as_cstr(),
16752 METHOD_NAME.as_cstr(),
16753 )?;
16754 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
16755 let _args: self::Args_MetaService_listSpaces = ::fbthrift::Deserialize::read(p)?;
16756 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
16757 protocol: P::PROTOCOL_ID,
16758 method_name: METHOD_NAME.as_cstr(),
16759 buffer: ::std::marker::PhantomData, })?;
16761 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
16762
16763 let res = ::std::panic::AssertUnwindSafe(
16764 self.service.listSpaces(
16765 _args.req,
16766 )
16767 )
16768 .catch_unwind()
16769 .await;
16770
16771 let res = match res {
16773 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
16774 ::tracing::info!("success");
16775 crate::services::meta_service::ListSpacesExn::Success(res)
16776 }
16777 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListSpacesExn::Success(_))) => {
16778 panic!(
16779 "{} attempted to return success via error",
16780 "listSpaces",
16781 )
16782 }
16783 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
16784 ::tracing::error!(exception = ?exn);
16785 exn
16786 }
16787 ::std::result::Result::Err(exn) => {
16788 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listSpaces", exn);
16789 crate::services::meta_service::ListSpacesExn::ApplicationException(aexn)
16790 }
16791 };
16792
16793 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
16794 "listSpaces",
16795 METHOD_NAME.as_cstr(),
16796 _seqid,
16797 req_ctxt,
16798 &mut ctx_stack,
16799 res
16800 )?;
16801 reply_state.lock().unwrap().send_reply(env);
16802 Ok(())
16803 }
16804
16805 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.createTag"))]
16806 async fn handle_createTag<'a>(
16807 &'a self,
16808 p: &'a mut P::Deserializer,
16809 req_ctxt: &R,
16810 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
16811 _seqid: ::std::primitive::u32,
16812 ) -> ::anyhow::Result<()> {
16813 use ::const_cstr::const_cstr;
16814 use ::futures::FutureExt as _;
16815
16816 const_cstr! {
16817 SERVICE_NAME = "MetaService";
16818 METHOD_NAME = "MetaService.createTag";
16819 }
16820 let mut ctx_stack = req_ctxt.get_context_stack(
16821 SERVICE_NAME.as_cstr(),
16822 METHOD_NAME.as_cstr(),
16823 )?;
16824 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
16825 let _args: self::Args_MetaService_createTag = ::fbthrift::Deserialize::read(p)?;
16826 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
16827 protocol: P::PROTOCOL_ID,
16828 method_name: METHOD_NAME.as_cstr(),
16829 buffer: ::std::marker::PhantomData, })?;
16831 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
16832
16833 let res = ::std::panic::AssertUnwindSafe(
16834 self.service.createTag(
16835 _args.req,
16836 )
16837 )
16838 .catch_unwind()
16839 .await;
16840
16841 let res = match res {
16843 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
16844 ::tracing::info!("success");
16845 crate::services::meta_service::CreateTagExn::Success(res)
16846 }
16847 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::CreateTagExn::Success(_))) => {
16848 panic!(
16849 "{} attempted to return success via error",
16850 "createTag",
16851 )
16852 }
16853 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
16854 ::tracing::error!(exception = ?exn);
16855 exn
16856 }
16857 ::std::result::Result::Err(exn) => {
16858 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.createTag", exn);
16859 crate::services::meta_service::CreateTagExn::ApplicationException(aexn)
16860 }
16861 };
16862
16863 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
16864 "createTag",
16865 METHOD_NAME.as_cstr(),
16866 _seqid,
16867 req_ctxt,
16868 &mut ctx_stack,
16869 res
16870 )?;
16871 reply_state.lock().unwrap().send_reply(env);
16872 Ok(())
16873 }
16874
16875 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.alterTag"))]
16876 async fn handle_alterTag<'a>(
16877 &'a self,
16878 p: &'a mut P::Deserializer,
16879 req_ctxt: &R,
16880 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
16881 _seqid: ::std::primitive::u32,
16882 ) -> ::anyhow::Result<()> {
16883 use ::const_cstr::const_cstr;
16884 use ::futures::FutureExt as _;
16885
16886 const_cstr! {
16887 SERVICE_NAME = "MetaService";
16888 METHOD_NAME = "MetaService.alterTag";
16889 }
16890 let mut ctx_stack = req_ctxt.get_context_stack(
16891 SERVICE_NAME.as_cstr(),
16892 METHOD_NAME.as_cstr(),
16893 )?;
16894 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
16895 let _args: self::Args_MetaService_alterTag = ::fbthrift::Deserialize::read(p)?;
16896 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
16897 protocol: P::PROTOCOL_ID,
16898 method_name: METHOD_NAME.as_cstr(),
16899 buffer: ::std::marker::PhantomData, })?;
16901 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
16902
16903 let res = ::std::panic::AssertUnwindSafe(
16904 self.service.alterTag(
16905 _args.req,
16906 )
16907 )
16908 .catch_unwind()
16909 .await;
16910
16911 let res = match res {
16913 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
16914 ::tracing::info!("success");
16915 crate::services::meta_service::AlterTagExn::Success(res)
16916 }
16917 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::AlterTagExn::Success(_))) => {
16918 panic!(
16919 "{} attempted to return success via error",
16920 "alterTag",
16921 )
16922 }
16923 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
16924 ::tracing::error!(exception = ?exn);
16925 exn
16926 }
16927 ::std::result::Result::Err(exn) => {
16928 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.alterTag", exn);
16929 crate::services::meta_service::AlterTagExn::ApplicationException(aexn)
16930 }
16931 };
16932
16933 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
16934 "alterTag",
16935 METHOD_NAME.as_cstr(),
16936 _seqid,
16937 req_ctxt,
16938 &mut ctx_stack,
16939 res
16940 )?;
16941 reply_state.lock().unwrap().send_reply(env);
16942 Ok(())
16943 }
16944
16945 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.dropTag"))]
16946 async fn handle_dropTag<'a>(
16947 &'a self,
16948 p: &'a mut P::Deserializer,
16949 req_ctxt: &R,
16950 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
16951 _seqid: ::std::primitive::u32,
16952 ) -> ::anyhow::Result<()> {
16953 use ::const_cstr::const_cstr;
16954 use ::futures::FutureExt as _;
16955
16956 const_cstr! {
16957 SERVICE_NAME = "MetaService";
16958 METHOD_NAME = "MetaService.dropTag";
16959 }
16960 let mut ctx_stack = req_ctxt.get_context_stack(
16961 SERVICE_NAME.as_cstr(),
16962 METHOD_NAME.as_cstr(),
16963 )?;
16964 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
16965 let _args: self::Args_MetaService_dropTag = ::fbthrift::Deserialize::read(p)?;
16966 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
16967 protocol: P::PROTOCOL_ID,
16968 method_name: METHOD_NAME.as_cstr(),
16969 buffer: ::std::marker::PhantomData, })?;
16971 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
16972
16973 let res = ::std::panic::AssertUnwindSafe(
16974 self.service.dropTag(
16975 _args.req,
16976 )
16977 )
16978 .catch_unwind()
16979 .await;
16980
16981 let res = match res {
16983 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
16984 ::tracing::info!("success");
16985 crate::services::meta_service::DropTagExn::Success(res)
16986 }
16987 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::DropTagExn::Success(_))) => {
16988 panic!(
16989 "{} attempted to return success via error",
16990 "dropTag",
16991 )
16992 }
16993 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
16994 ::tracing::error!(exception = ?exn);
16995 exn
16996 }
16997 ::std::result::Result::Err(exn) => {
16998 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.dropTag", exn);
16999 crate::services::meta_service::DropTagExn::ApplicationException(aexn)
17000 }
17001 };
17002
17003 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17004 "dropTag",
17005 METHOD_NAME.as_cstr(),
17006 _seqid,
17007 req_ctxt,
17008 &mut ctx_stack,
17009 res
17010 )?;
17011 reply_state.lock().unwrap().send_reply(env);
17012 Ok(())
17013 }
17014
17015 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getTag"))]
17016 async fn handle_getTag<'a>(
17017 &'a self,
17018 p: &'a mut P::Deserializer,
17019 req_ctxt: &R,
17020 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17021 _seqid: ::std::primitive::u32,
17022 ) -> ::anyhow::Result<()> {
17023 use ::const_cstr::const_cstr;
17024 use ::futures::FutureExt as _;
17025
17026 const_cstr! {
17027 SERVICE_NAME = "MetaService";
17028 METHOD_NAME = "MetaService.getTag";
17029 }
17030 let mut ctx_stack = req_ctxt.get_context_stack(
17031 SERVICE_NAME.as_cstr(),
17032 METHOD_NAME.as_cstr(),
17033 )?;
17034 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17035 let _args: self::Args_MetaService_getTag = ::fbthrift::Deserialize::read(p)?;
17036 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17037 protocol: P::PROTOCOL_ID,
17038 method_name: METHOD_NAME.as_cstr(),
17039 buffer: ::std::marker::PhantomData, })?;
17041 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17042
17043 let res = ::std::panic::AssertUnwindSafe(
17044 self.service.getTag(
17045 _args.req,
17046 )
17047 )
17048 .catch_unwind()
17049 .await;
17050
17051 let res = match res {
17053 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17054 ::tracing::info!("success");
17055 crate::services::meta_service::GetTagExn::Success(res)
17056 }
17057 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetTagExn::Success(_))) => {
17058 panic!(
17059 "{} attempted to return success via error",
17060 "getTag",
17061 )
17062 }
17063 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17064 ::tracing::error!(exception = ?exn);
17065 exn
17066 }
17067 ::std::result::Result::Err(exn) => {
17068 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getTag", exn);
17069 crate::services::meta_service::GetTagExn::ApplicationException(aexn)
17070 }
17071 };
17072
17073 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17074 "getTag",
17075 METHOD_NAME.as_cstr(),
17076 _seqid,
17077 req_ctxt,
17078 &mut ctx_stack,
17079 res
17080 )?;
17081 reply_state.lock().unwrap().send_reply(env);
17082 Ok(())
17083 }
17084
17085 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listTags"))]
17086 async fn handle_listTags<'a>(
17087 &'a self,
17088 p: &'a mut P::Deserializer,
17089 req_ctxt: &R,
17090 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17091 _seqid: ::std::primitive::u32,
17092 ) -> ::anyhow::Result<()> {
17093 use ::const_cstr::const_cstr;
17094 use ::futures::FutureExt as _;
17095
17096 const_cstr! {
17097 SERVICE_NAME = "MetaService";
17098 METHOD_NAME = "MetaService.listTags";
17099 }
17100 let mut ctx_stack = req_ctxt.get_context_stack(
17101 SERVICE_NAME.as_cstr(),
17102 METHOD_NAME.as_cstr(),
17103 )?;
17104 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17105 let _args: self::Args_MetaService_listTags = ::fbthrift::Deserialize::read(p)?;
17106 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17107 protocol: P::PROTOCOL_ID,
17108 method_name: METHOD_NAME.as_cstr(),
17109 buffer: ::std::marker::PhantomData, })?;
17111 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17112
17113 let res = ::std::panic::AssertUnwindSafe(
17114 self.service.listTags(
17115 _args.req,
17116 )
17117 )
17118 .catch_unwind()
17119 .await;
17120
17121 let res = match res {
17123 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17124 ::tracing::info!("success");
17125 crate::services::meta_service::ListTagsExn::Success(res)
17126 }
17127 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListTagsExn::Success(_))) => {
17128 panic!(
17129 "{} attempted to return success via error",
17130 "listTags",
17131 )
17132 }
17133 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17134 ::tracing::error!(exception = ?exn);
17135 exn
17136 }
17137 ::std::result::Result::Err(exn) => {
17138 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listTags", exn);
17139 crate::services::meta_service::ListTagsExn::ApplicationException(aexn)
17140 }
17141 };
17142
17143 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17144 "listTags",
17145 METHOD_NAME.as_cstr(),
17146 _seqid,
17147 req_ctxt,
17148 &mut ctx_stack,
17149 res
17150 )?;
17151 reply_state.lock().unwrap().send_reply(env);
17152 Ok(())
17153 }
17154
17155 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.createEdge"))]
17156 async fn handle_createEdge<'a>(
17157 &'a self,
17158 p: &'a mut P::Deserializer,
17159 req_ctxt: &R,
17160 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17161 _seqid: ::std::primitive::u32,
17162 ) -> ::anyhow::Result<()> {
17163 use ::const_cstr::const_cstr;
17164 use ::futures::FutureExt as _;
17165
17166 const_cstr! {
17167 SERVICE_NAME = "MetaService";
17168 METHOD_NAME = "MetaService.createEdge";
17169 }
17170 let mut ctx_stack = req_ctxt.get_context_stack(
17171 SERVICE_NAME.as_cstr(),
17172 METHOD_NAME.as_cstr(),
17173 )?;
17174 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17175 let _args: self::Args_MetaService_createEdge = ::fbthrift::Deserialize::read(p)?;
17176 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17177 protocol: P::PROTOCOL_ID,
17178 method_name: METHOD_NAME.as_cstr(),
17179 buffer: ::std::marker::PhantomData, })?;
17181 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17182
17183 let res = ::std::panic::AssertUnwindSafe(
17184 self.service.createEdge(
17185 _args.req,
17186 )
17187 )
17188 .catch_unwind()
17189 .await;
17190
17191 let res = match res {
17193 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17194 ::tracing::info!("success");
17195 crate::services::meta_service::CreateEdgeExn::Success(res)
17196 }
17197 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::CreateEdgeExn::Success(_))) => {
17198 panic!(
17199 "{} attempted to return success via error",
17200 "createEdge",
17201 )
17202 }
17203 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17204 ::tracing::error!(exception = ?exn);
17205 exn
17206 }
17207 ::std::result::Result::Err(exn) => {
17208 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.createEdge", exn);
17209 crate::services::meta_service::CreateEdgeExn::ApplicationException(aexn)
17210 }
17211 };
17212
17213 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17214 "createEdge",
17215 METHOD_NAME.as_cstr(),
17216 _seqid,
17217 req_ctxt,
17218 &mut ctx_stack,
17219 res
17220 )?;
17221 reply_state.lock().unwrap().send_reply(env);
17222 Ok(())
17223 }
17224
17225 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.alterEdge"))]
17226 async fn handle_alterEdge<'a>(
17227 &'a self,
17228 p: &'a mut P::Deserializer,
17229 req_ctxt: &R,
17230 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17231 _seqid: ::std::primitive::u32,
17232 ) -> ::anyhow::Result<()> {
17233 use ::const_cstr::const_cstr;
17234 use ::futures::FutureExt as _;
17235
17236 const_cstr! {
17237 SERVICE_NAME = "MetaService";
17238 METHOD_NAME = "MetaService.alterEdge";
17239 }
17240 let mut ctx_stack = req_ctxt.get_context_stack(
17241 SERVICE_NAME.as_cstr(),
17242 METHOD_NAME.as_cstr(),
17243 )?;
17244 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17245 let _args: self::Args_MetaService_alterEdge = ::fbthrift::Deserialize::read(p)?;
17246 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17247 protocol: P::PROTOCOL_ID,
17248 method_name: METHOD_NAME.as_cstr(),
17249 buffer: ::std::marker::PhantomData, })?;
17251 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17252
17253 let res = ::std::panic::AssertUnwindSafe(
17254 self.service.alterEdge(
17255 _args.req,
17256 )
17257 )
17258 .catch_unwind()
17259 .await;
17260
17261 let res = match res {
17263 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17264 ::tracing::info!("success");
17265 crate::services::meta_service::AlterEdgeExn::Success(res)
17266 }
17267 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::AlterEdgeExn::Success(_))) => {
17268 panic!(
17269 "{} attempted to return success via error",
17270 "alterEdge",
17271 )
17272 }
17273 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17274 ::tracing::error!(exception = ?exn);
17275 exn
17276 }
17277 ::std::result::Result::Err(exn) => {
17278 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.alterEdge", exn);
17279 crate::services::meta_service::AlterEdgeExn::ApplicationException(aexn)
17280 }
17281 };
17282
17283 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17284 "alterEdge",
17285 METHOD_NAME.as_cstr(),
17286 _seqid,
17287 req_ctxt,
17288 &mut ctx_stack,
17289 res
17290 )?;
17291 reply_state.lock().unwrap().send_reply(env);
17292 Ok(())
17293 }
17294
17295 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.dropEdge"))]
17296 async fn handle_dropEdge<'a>(
17297 &'a self,
17298 p: &'a mut P::Deserializer,
17299 req_ctxt: &R,
17300 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17301 _seqid: ::std::primitive::u32,
17302 ) -> ::anyhow::Result<()> {
17303 use ::const_cstr::const_cstr;
17304 use ::futures::FutureExt as _;
17305
17306 const_cstr! {
17307 SERVICE_NAME = "MetaService";
17308 METHOD_NAME = "MetaService.dropEdge";
17309 }
17310 let mut ctx_stack = req_ctxt.get_context_stack(
17311 SERVICE_NAME.as_cstr(),
17312 METHOD_NAME.as_cstr(),
17313 )?;
17314 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17315 let _args: self::Args_MetaService_dropEdge = ::fbthrift::Deserialize::read(p)?;
17316 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17317 protocol: P::PROTOCOL_ID,
17318 method_name: METHOD_NAME.as_cstr(),
17319 buffer: ::std::marker::PhantomData, })?;
17321 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17322
17323 let res = ::std::panic::AssertUnwindSafe(
17324 self.service.dropEdge(
17325 _args.req,
17326 )
17327 )
17328 .catch_unwind()
17329 .await;
17330
17331 let res = match res {
17333 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17334 ::tracing::info!("success");
17335 crate::services::meta_service::DropEdgeExn::Success(res)
17336 }
17337 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::DropEdgeExn::Success(_))) => {
17338 panic!(
17339 "{} attempted to return success via error",
17340 "dropEdge",
17341 )
17342 }
17343 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17344 ::tracing::error!(exception = ?exn);
17345 exn
17346 }
17347 ::std::result::Result::Err(exn) => {
17348 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.dropEdge", exn);
17349 crate::services::meta_service::DropEdgeExn::ApplicationException(aexn)
17350 }
17351 };
17352
17353 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17354 "dropEdge",
17355 METHOD_NAME.as_cstr(),
17356 _seqid,
17357 req_ctxt,
17358 &mut ctx_stack,
17359 res
17360 )?;
17361 reply_state.lock().unwrap().send_reply(env);
17362 Ok(())
17363 }
17364
17365 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getEdge"))]
17366 async fn handle_getEdge<'a>(
17367 &'a self,
17368 p: &'a mut P::Deserializer,
17369 req_ctxt: &R,
17370 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17371 _seqid: ::std::primitive::u32,
17372 ) -> ::anyhow::Result<()> {
17373 use ::const_cstr::const_cstr;
17374 use ::futures::FutureExt as _;
17375
17376 const_cstr! {
17377 SERVICE_NAME = "MetaService";
17378 METHOD_NAME = "MetaService.getEdge";
17379 }
17380 let mut ctx_stack = req_ctxt.get_context_stack(
17381 SERVICE_NAME.as_cstr(),
17382 METHOD_NAME.as_cstr(),
17383 )?;
17384 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17385 let _args: self::Args_MetaService_getEdge = ::fbthrift::Deserialize::read(p)?;
17386 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17387 protocol: P::PROTOCOL_ID,
17388 method_name: METHOD_NAME.as_cstr(),
17389 buffer: ::std::marker::PhantomData, })?;
17391 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17392
17393 let res = ::std::panic::AssertUnwindSafe(
17394 self.service.getEdge(
17395 _args.req,
17396 )
17397 )
17398 .catch_unwind()
17399 .await;
17400
17401 let res = match res {
17403 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17404 ::tracing::info!("success");
17405 crate::services::meta_service::GetEdgeExn::Success(res)
17406 }
17407 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetEdgeExn::Success(_))) => {
17408 panic!(
17409 "{} attempted to return success via error",
17410 "getEdge",
17411 )
17412 }
17413 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17414 ::tracing::error!(exception = ?exn);
17415 exn
17416 }
17417 ::std::result::Result::Err(exn) => {
17418 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getEdge", exn);
17419 crate::services::meta_service::GetEdgeExn::ApplicationException(aexn)
17420 }
17421 };
17422
17423 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17424 "getEdge",
17425 METHOD_NAME.as_cstr(),
17426 _seqid,
17427 req_ctxt,
17428 &mut ctx_stack,
17429 res
17430 )?;
17431 reply_state.lock().unwrap().send_reply(env);
17432 Ok(())
17433 }
17434
17435 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listEdges"))]
17436 async fn handle_listEdges<'a>(
17437 &'a self,
17438 p: &'a mut P::Deserializer,
17439 req_ctxt: &R,
17440 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17441 _seqid: ::std::primitive::u32,
17442 ) -> ::anyhow::Result<()> {
17443 use ::const_cstr::const_cstr;
17444 use ::futures::FutureExt as _;
17445
17446 const_cstr! {
17447 SERVICE_NAME = "MetaService";
17448 METHOD_NAME = "MetaService.listEdges";
17449 }
17450 let mut ctx_stack = req_ctxt.get_context_stack(
17451 SERVICE_NAME.as_cstr(),
17452 METHOD_NAME.as_cstr(),
17453 )?;
17454 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17455 let _args: self::Args_MetaService_listEdges = ::fbthrift::Deserialize::read(p)?;
17456 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17457 protocol: P::PROTOCOL_ID,
17458 method_name: METHOD_NAME.as_cstr(),
17459 buffer: ::std::marker::PhantomData, })?;
17461 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17462
17463 let res = ::std::panic::AssertUnwindSafe(
17464 self.service.listEdges(
17465 _args.req,
17466 )
17467 )
17468 .catch_unwind()
17469 .await;
17470
17471 let res = match res {
17473 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17474 ::tracing::info!("success");
17475 crate::services::meta_service::ListEdgesExn::Success(res)
17476 }
17477 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListEdgesExn::Success(_))) => {
17478 panic!(
17479 "{} attempted to return success via error",
17480 "listEdges",
17481 )
17482 }
17483 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17484 ::tracing::error!(exception = ?exn);
17485 exn
17486 }
17487 ::std::result::Result::Err(exn) => {
17488 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listEdges", exn);
17489 crate::services::meta_service::ListEdgesExn::ApplicationException(aexn)
17490 }
17491 };
17492
17493 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17494 "listEdges",
17495 METHOD_NAME.as_cstr(),
17496 _seqid,
17497 req_ctxt,
17498 &mut ctx_stack,
17499 res
17500 )?;
17501 reply_state.lock().unwrap().send_reply(env);
17502 Ok(())
17503 }
17504
17505 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listHosts"))]
17506 async fn handle_listHosts<'a>(
17507 &'a self,
17508 p: &'a mut P::Deserializer,
17509 req_ctxt: &R,
17510 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17511 _seqid: ::std::primitive::u32,
17512 ) -> ::anyhow::Result<()> {
17513 use ::const_cstr::const_cstr;
17514 use ::futures::FutureExt as _;
17515
17516 const_cstr! {
17517 SERVICE_NAME = "MetaService";
17518 METHOD_NAME = "MetaService.listHosts";
17519 }
17520 let mut ctx_stack = req_ctxt.get_context_stack(
17521 SERVICE_NAME.as_cstr(),
17522 METHOD_NAME.as_cstr(),
17523 )?;
17524 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17525 let _args: self::Args_MetaService_listHosts = ::fbthrift::Deserialize::read(p)?;
17526 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17527 protocol: P::PROTOCOL_ID,
17528 method_name: METHOD_NAME.as_cstr(),
17529 buffer: ::std::marker::PhantomData, })?;
17531 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17532
17533 let res = ::std::panic::AssertUnwindSafe(
17534 self.service.listHosts(
17535 _args.req,
17536 )
17537 )
17538 .catch_unwind()
17539 .await;
17540
17541 let res = match res {
17543 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17544 ::tracing::info!("success");
17545 crate::services::meta_service::ListHostsExn::Success(res)
17546 }
17547 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListHostsExn::Success(_))) => {
17548 panic!(
17549 "{} attempted to return success via error",
17550 "listHosts",
17551 )
17552 }
17553 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17554 ::tracing::error!(exception = ?exn);
17555 exn
17556 }
17557 ::std::result::Result::Err(exn) => {
17558 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listHosts", exn);
17559 crate::services::meta_service::ListHostsExn::ApplicationException(aexn)
17560 }
17561 };
17562
17563 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17564 "listHosts",
17565 METHOD_NAME.as_cstr(),
17566 _seqid,
17567 req_ctxt,
17568 &mut ctx_stack,
17569 res
17570 )?;
17571 reply_state.lock().unwrap().send_reply(env);
17572 Ok(())
17573 }
17574
17575 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getPartsAlloc"))]
17576 async fn handle_getPartsAlloc<'a>(
17577 &'a self,
17578 p: &'a mut P::Deserializer,
17579 req_ctxt: &R,
17580 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17581 _seqid: ::std::primitive::u32,
17582 ) -> ::anyhow::Result<()> {
17583 use ::const_cstr::const_cstr;
17584 use ::futures::FutureExt as _;
17585
17586 const_cstr! {
17587 SERVICE_NAME = "MetaService";
17588 METHOD_NAME = "MetaService.getPartsAlloc";
17589 }
17590 let mut ctx_stack = req_ctxt.get_context_stack(
17591 SERVICE_NAME.as_cstr(),
17592 METHOD_NAME.as_cstr(),
17593 )?;
17594 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17595 let _args: self::Args_MetaService_getPartsAlloc = ::fbthrift::Deserialize::read(p)?;
17596 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17597 protocol: P::PROTOCOL_ID,
17598 method_name: METHOD_NAME.as_cstr(),
17599 buffer: ::std::marker::PhantomData, })?;
17601 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17602
17603 let res = ::std::panic::AssertUnwindSafe(
17604 self.service.getPartsAlloc(
17605 _args.req,
17606 )
17607 )
17608 .catch_unwind()
17609 .await;
17610
17611 let res = match res {
17613 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17614 ::tracing::info!("success");
17615 crate::services::meta_service::GetPartsAllocExn::Success(res)
17616 }
17617 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetPartsAllocExn::Success(_))) => {
17618 panic!(
17619 "{} attempted to return success via error",
17620 "getPartsAlloc",
17621 )
17622 }
17623 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17624 ::tracing::error!(exception = ?exn);
17625 exn
17626 }
17627 ::std::result::Result::Err(exn) => {
17628 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getPartsAlloc", exn);
17629 crate::services::meta_service::GetPartsAllocExn::ApplicationException(aexn)
17630 }
17631 };
17632
17633 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17634 "getPartsAlloc",
17635 METHOD_NAME.as_cstr(),
17636 _seqid,
17637 req_ctxt,
17638 &mut ctx_stack,
17639 res
17640 )?;
17641 reply_state.lock().unwrap().send_reply(env);
17642 Ok(())
17643 }
17644
17645 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listParts"))]
17646 async fn handle_listParts<'a>(
17647 &'a self,
17648 p: &'a mut P::Deserializer,
17649 req_ctxt: &R,
17650 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17651 _seqid: ::std::primitive::u32,
17652 ) -> ::anyhow::Result<()> {
17653 use ::const_cstr::const_cstr;
17654 use ::futures::FutureExt as _;
17655
17656 const_cstr! {
17657 SERVICE_NAME = "MetaService";
17658 METHOD_NAME = "MetaService.listParts";
17659 }
17660 let mut ctx_stack = req_ctxt.get_context_stack(
17661 SERVICE_NAME.as_cstr(),
17662 METHOD_NAME.as_cstr(),
17663 )?;
17664 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17665 let _args: self::Args_MetaService_listParts = ::fbthrift::Deserialize::read(p)?;
17666 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17667 protocol: P::PROTOCOL_ID,
17668 method_name: METHOD_NAME.as_cstr(),
17669 buffer: ::std::marker::PhantomData, })?;
17671 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17672
17673 let res = ::std::panic::AssertUnwindSafe(
17674 self.service.listParts(
17675 _args.req,
17676 )
17677 )
17678 .catch_unwind()
17679 .await;
17680
17681 let res = match res {
17683 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17684 ::tracing::info!("success");
17685 crate::services::meta_service::ListPartsExn::Success(res)
17686 }
17687 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListPartsExn::Success(_))) => {
17688 panic!(
17689 "{} attempted to return success via error",
17690 "listParts",
17691 )
17692 }
17693 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17694 ::tracing::error!(exception = ?exn);
17695 exn
17696 }
17697 ::std::result::Result::Err(exn) => {
17698 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listParts", exn);
17699 crate::services::meta_service::ListPartsExn::ApplicationException(aexn)
17700 }
17701 };
17702
17703 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17704 "listParts",
17705 METHOD_NAME.as_cstr(),
17706 _seqid,
17707 req_ctxt,
17708 &mut ctx_stack,
17709 res
17710 )?;
17711 reply_state.lock().unwrap().send_reply(env);
17712 Ok(())
17713 }
17714
17715 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.multiPut"))]
17716 async fn handle_multiPut<'a>(
17717 &'a self,
17718 p: &'a mut P::Deserializer,
17719 req_ctxt: &R,
17720 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17721 _seqid: ::std::primitive::u32,
17722 ) -> ::anyhow::Result<()> {
17723 use ::const_cstr::const_cstr;
17724 use ::futures::FutureExt as _;
17725
17726 const_cstr! {
17727 SERVICE_NAME = "MetaService";
17728 METHOD_NAME = "MetaService.multiPut";
17729 }
17730 let mut ctx_stack = req_ctxt.get_context_stack(
17731 SERVICE_NAME.as_cstr(),
17732 METHOD_NAME.as_cstr(),
17733 )?;
17734 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17735 let _args: self::Args_MetaService_multiPut = ::fbthrift::Deserialize::read(p)?;
17736 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17737 protocol: P::PROTOCOL_ID,
17738 method_name: METHOD_NAME.as_cstr(),
17739 buffer: ::std::marker::PhantomData, })?;
17741 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17742
17743 let res = ::std::panic::AssertUnwindSafe(
17744 self.service.multiPut(
17745 _args.req,
17746 )
17747 )
17748 .catch_unwind()
17749 .await;
17750
17751 let res = match res {
17753 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17754 ::tracing::info!("success");
17755 crate::services::meta_service::MultiPutExn::Success(res)
17756 }
17757 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::MultiPutExn::Success(_))) => {
17758 panic!(
17759 "{} attempted to return success via error",
17760 "multiPut",
17761 )
17762 }
17763 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17764 ::tracing::error!(exception = ?exn);
17765 exn
17766 }
17767 ::std::result::Result::Err(exn) => {
17768 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.multiPut", exn);
17769 crate::services::meta_service::MultiPutExn::ApplicationException(aexn)
17770 }
17771 };
17772
17773 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17774 "multiPut",
17775 METHOD_NAME.as_cstr(),
17776 _seqid,
17777 req_ctxt,
17778 &mut ctx_stack,
17779 res
17780 )?;
17781 reply_state.lock().unwrap().send_reply(env);
17782 Ok(())
17783 }
17784
17785 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.get"))]
17786 async fn handle_get<'a>(
17787 &'a self,
17788 p: &'a mut P::Deserializer,
17789 req_ctxt: &R,
17790 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17791 _seqid: ::std::primitive::u32,
17792 ) -> ::anyhow::Result<()> {
17793 use ::const_cstr::const_cstr;
17794 use ::futures::FutureExt as _;
17795
17796 const_cstr! {
17797 SERVICE_NAME = "MetaService";
17798 METHOD_NAME = "MetaService.get";
17799 }
17800 let mut ctx_stack = req_ctxt.get_context_stack(
17801 SERVICE_NAME.as_cstr(),
17802 METHOD_NAME.as_cstr(),
17803 )?;
17804 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17805 let _args: self::Args_MetaService_get = ::fbthrift::Deserialize::read(p)?;
17806 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17807 protocol: P::PROTOCOL_ID,
17808 method_name: METHOD_NAME.as_cstr(),
17809 buffer: ::std::marker::PhantomData, })?;
17811 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17812
17813 let res = ::std::panic::AssertUnwindSafe(
17814 self.service.get(
17815 _args.req,
17816 )
17817 )
17818 .catch_unwind()
17819 .await;
17820
17821 let res = match res {
17823 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17824 ::tracing::info!("success");
17825 crate::services::meta_service::GetExn::Success(res)
17826 }
17827 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetExn::Success(_))) => {
17828 panic!(
17829 "{} attempted to return success via error",
17830 "get",
17831 )
17832 }
17833 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17834 ::tracing::error!(exception = ?exn);
17835 exn
17836 }
17837 ::std::result::Result::Err(exn) => {
17838 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.get", exn);
17839 crate::services::meta_service::GetExn::ApplicationException(aexn)
17840 }
17841 };
17842
17843 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17844 "get",
17845 METHOD_NAME.as_cstr(),
17846 _seqid,
17847 req_ctxt,
17848 &mut ctx_stack,
17849 res
17850 )?;
17851 reply_state.lock().unwrap().send_reply(env);
17852 Ok(())
17853 }
17854
17855 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.multiGet"))]
17856 async fn handle_multiGet<'a>(
17857 &'a self,
17858 p: &'a mut P::Deserializer,
17859 req_ctxt: &R,
17860 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17861 _seqid: ::std::primitive::u32,
17862 ) -> ::anyhow::Result<()> {
17863 use ::const_cstr::const_cstr;
17864 use ::futures::FutureExt as _;
17865
17866 const_cstr! {
17867 SERVICE_NAME = "MetaService";
17868 METHOD_NAME = "MetaService.multiGet";
17869 }
17870 let mut ctx_stack = req_ctxt.get_context_stack(
17871 SERVICE_NAME.as_cstr(),
17872 METHOD_NAME.as_cstr(),
17873 )?;
17874 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17875 let _args: self::Args_MetaService_multiGet = ::fbthrift::Deserialize::read(p)?;
17876 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17877 protocol: P::PROTOCOL_ID,
17878 method_name: METHOD_NAME.as_cstr(),
17879 buffer: ::std::marker::PhantomData, })?;
17881 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17882
17883 let res = ::std::panic::AssertUnwindSafe(
17884 self.service.multiGet(
17885 _args.req,
17886 )
17887 )
17888 .catch_unwind()
17889 .await;
17890
17891 let res = match res {
17893 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17894 ::tracing::info!("success");
17895 crate::services::meta_service::MultiGetExn::Success(res)
17896 }
17897 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::MultiGetExn::Success(_))) => {
17898 panic!(
17899 "{} attempted to return success via error",
17900 "multiGet",
17901 )
17902 }
17903 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17904 ::tracing::error!(exception = ?exn);
17905 exn
17906 }
17907 ::std::result::Result::Err(exn) => {
17908 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.multiGet", exn);
17909 crate::services::meta_service::MultiGetExn::ApplicationException(aexn)
17910 }
17911 };
17912
17913 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17914 "multiGet",
17915 METHOD_NAME.as_cstr(),
17916 _seqid,
17917 req_ctxt,
17918 &mut ctx_stack,
17919 res
17920 )?;
17921 reply_state.lock().unwrap().send_reply(env);
17922 Ok(())
17923 }
17924
17925 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.remove"))]
17926 async fn handle_remove<'a>(
17927 &'a self,
17928 p: &'a mut P::Deserializer,
17929 req_ctxt: &R,
17930 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
17931 _seqid: ::std::primitive::u32,
17932 ) -> ::anyhow::Result<()> {
17933 use ::const_cstr::const_cstr;
17934 use ::futures::FutureExt as _;
17935
17936 const_cstr! {
17937 SERVICE_NAME = "MetaService";
17938 METHOD_NAME = "MetaService.remove";
17939 }
17940 let mut ctx_stack = req_ctxt.get_context_stack(
17941 SERVICE_NAME.as_cstr(),
17942 METHOD_NAME.as_cstr(),
17943 )?;
17944 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
17945 let _args: self::Args_MetaService_remove = ::fbthrift::Deserialize::read(p)?;
17946 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
17947 protocol: P::PROTOCOL_ID,
17948 method_name: METHOD_NAME.as_cstr(),
17949 buffer: ::std::marker::PhantomData, })?;
17951 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
17952
17953 let res = ::std::panic::AssertUnwindSafe(
17954 self.service.remove(
17955 _args.req,
17956 )
17957 )
17958 .catch_unwind()
17959 .await;
17960
17961 let res = match res {
17963 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
17964 ::tracing::info!("success");
17965 crate::services::meta_service::RemoveExn::Success(res)
17966 }
17967 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::RemoveExn::Success(_))) => {
17968 panic!(
17969 "{} attempted to return success via error",
17970 "remove",
17971 )
17972 }
17973 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
17974 ::tracing::error!(exception = ?exn);
17975 exn
17976 }
17977 ::std::result::Result::Err(exn) => {
17978 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.remove", exn);
17979 crate::services::meta_service::RemoveExn::ApplicationException(aexn)
17980 }
17981 };
17982
17983 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
17984 "remove",
17985 METHOD_NAME.as_cstr(),
17986 _seqid,
17987 req_ctxt,
17988 &mut ctx_stack,
17989 res
17990 )?;
17991 reply_state.lock().unwrap().send_reply(env);
17992 Ok(())
17993 }
17994
17995 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.removeRange"))]
17996 async fn handle_removeRange<'a>(
17997 &'a self,
17998 p: &'a mut P::Deserializer,
17999 req_ctxt: &R,
18000 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18001 _seqid: ::std::primitive::u32,
18002 ) -> ::anyhow::Result<()> {
18003 use ::const_cstr::const_cstr;
18004 use ::futures::FutureExt as _;
18005
18006 const_cstr! {
18007 SERVICE_NAME = "MetaService";
18008 METHOD_NAME = "MetaService.removeRange";
18009 }
18010 let mut ctx_stack = req_ctxt.get_context_stack(
18011 SERVICE_NAME.as_cstr(),
18012 METHOD_NAME.as_cstr(),
18013 )?;
18014 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18015 let _args: self::Args_MetaService_removeRange = ::fbthrift::Deserialize::read(p)?;
18016 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18017 protocol: P::PROTOCOL_ID,
18018 method_name: METHOD_NAME.as_cstr(),
18019 buffer: ::std::marker::PhantomData, })?;
18021 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18022
18023 let res = ::std::panic::AssertUnwindSafe(
18024 self.service.removeRange(
18025 _args.req,
18026 )
18027 )
18028 .catch_unwind()
18029 .await;
18030
18031 let res = match res {
18033 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18034 ::tracing::info!("success");
18035 crate::services::meta_service::RemoveRangeExn::Success(res)
18036 }
18037 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::RemoveRangeExn::Success(_))) => {
18038 panic!(
18039 "{} attempted to return success via error",
18040 "removeRange",
18041 )
18042 }
18043 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18044 ::tracing::error!(exception = ?exn);
18045 exn
18046 }
18047 ::std::result::Result::Err(exn) => {
18048 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.removeRange", exn);
18049 crate::services::meta_service::RemoveRangeExn::ApplicationException(aexn)
18050 }
18051 };
18052
18053 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18054 "removeRange",
18055 METHOD_NAME.as_cstr(),
18056 _seqid,
18057 req_ctxt,
18058 &mut ctx_stack,
18059 res
18060 )?;
18061 reply_state.lock().unwrap().send_reply(env);
18062 Ok(())
18063 }
18064
18065 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.scan"))]
18066 async fn handle_scan<'a>(
18067 &'a self,
18068 p: &'a mut P::Deserializer,
18069 req_ctxt: &R,
18070 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18071 _seqid: ::std::primitive::u32,
18072 ) -> ::anyhow::Result<()> {
18073 use ::const_cstr::const_cstr;
18074 use ::futures::FutureExt as _;
18075
18076 const_cstr! {
18077 SERVICE_NAME = "MetaService";
18078 METHOD_NAME = "MetaService.scan";
18079 }
18080 let mut ctx_stack = req_ctxt.get_context_stack(
18081 SERVICE_NAME.as_cstr(),
18082 METHOD_NAME.as_cstr(),
18083 )?;
18084 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18085 let _args: self::Args_MetaService_scan = ::fbthrift::Deserialize::read(p)?;
18086 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18087 protocol: P::PROTOCOL_ID,
18088 method_name: METHOD_NAME.as_cstr(),
18089 buffer: ::std::marker::PhantomData, })?;
18091 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18092
18093 let res = ::std::panic::AssertUnwindSafe(
18094 self.service.scan(
18095 _args.req,
18096 )
18097 )
18098 .catch_unwind()
18099 .await;
18100
18101 let res = match res {
18103 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18104 ::tracing::info!("success");
18105 crate::services::meta_service::ScanExn::Success(res)
18106 }
18107 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ScanExn::Success(_))) => {
18108 panic!(
18109 "{} attempted to return success via error",
18110 "scan",
18111 )
18112 }
18113 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18114 ::tracing::error!(exception = ?exn);
18115 exn
18116 }
18117 ::std::result::Result::Err(exn) => {
18118 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.scan", exn);
18119 crate::services::meta_service::ScanExn::ApplicationException(aexn)
18120 }
18121 };
18122
18123 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18124 "scan",
18125 METHOD_NAME.as_cstr(),
18126 _seqid,
18127 req_ctxt,
18128 &mut ctx_stack,
18129 res
18130 )?;
18131 reply_state.lock().unwrap().send_reply(env);
18132 Ok(())
18133 }
18134
18135 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.createTagIndex"))]
18136 async fn handle_createTagIndex<'a>(
18137 &'a self,
18138 p: &'a mut P::Deserializer,
18139 req_ctxt: &R,
18140 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18141 _seqid: ::std::primitive::u32,
18142 ) -> ::anyhow::Result<()> {
18143 use ::const_cstr::const_cstr;
18144 use ::futures::FutureExt as _;
18145
18146 const_cstr! {
18147 SERVICE_NAME = "MetaService";
18148 METHOD_NAME = "MetaService.createTagIndex";
18149 }
18150 let mut ctx_stack = req_ctxt.get_context_stack(
18151 SERVICE_NAME.as_cstr(),
18152 METHOD_NAME.as_cstr(),
18153 )?;
18154 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18155 let _args: self::Args_MetaService_createTagIndex = ::fbthrift::Deserialize::read(p)?;
18156 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18157 protocol: P::PROTOCOL_ID,
18158 method_name: METHOD_NAME.as_cstr(),
18159 buffer: ::std::marker::PhantomData, })?;
18161 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18162
18163 let res = ::std::panic::AssertUnwindSafe(
18164 self.service.createTagIndex(
18165 _args.req,
18166 )
18167 )
18168 .catch_unwind()
18169 .await;
18170
18171 let res = match res {
18173 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18174 ::tracing::info!("success");
18175 crate::services::meta_service::CreateTagIndexExn::Success(res)
18176 }
18177 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::CreateTagIndexExn::Success(_))) => {
18178 panic!(
18179 "{} attempted to return success via error",
18180 "createTagIndex",
18181 )
18182 }
18183 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18184 ::tracing::error!(exception = ?exn);
18185 exn
18186 }
18187 ::std::result::Result::Err(exn) => {
18188 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.createTagIndex", exn);
18189 crate::services::meta_service::CreateTagIndexExn::ApplicationException(aexn)
18190 }
18191 };
18192
18193 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18194 "createTagIndex",
18195 METHOD_NAME.as_cstr(),
18196 _seqid,
18197 req_ctxt,
18198 &mut ctx_stack,
18199 res
18200 )?;
18201 reply_state.lock().unwrap().send_reply(env);
18202 Ok(())
18203 }
18204
18205 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.dropTagIndex"))]
18206 async fn handle_dropTagIndex<'a>(
18207 &'a self,
18208 p: &'a mut P::Deserializer,
18209 req_ctxt: &R,
18210 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18211 _seqid: ::std::primitive::u32,
18212 ) -> ::anyhow::Result<()> {
18213 use ::const_cstr::const_cstr;
18214 use ::futures::FutureExt as _;
18215
18216 const_cstr! {
18217 SERVICE_NAME = "MetaService";
18218 METHOD_NAME = "MetaService.dropTagIndex";
18219 }
18220 let mut ctx_stack = req_ctxt.get_context_stack(
18221 SERVICE_NAME.as_cstr(),
18222 METHOD_NAME.as_cstr(),
18223 )?;
18224 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18225 let _args: self::Args_MetaService_dropTagIndex = ::fbthrift::Deserialize::read(p)?;
18226 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18227 protocol: P::PROTOCOL_ID,
18228 method_name: METHOD_NAME.as_cstr(),
18229 buffer: ::std::marker::PhantomData, })?;
18231 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18232
18233 let res = ::std::panic::AssertUnwindSafe(
18234 self.service.dropTagIndex(
18235 _args.req,
18236 )
18237 )
18238 .catch_unwind()
18239 .await;
18240
18241 let res = match res {
18243 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18244 ::tracing::info!("success");
18245 crate::services::meta_service::DropTagIndexExn::Success(res)
18246 }
18247 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::DropTagIndexExn::Success(_))) => {
18248 panic!(
18249 "{} attempted to return success via error",
18250 "dropTagIndex",
18251 )
18252 }
18253 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18254 ::tracing::error!(exception = ?exn);
18255 exn
18256 }
18257 ::std::result::Result::Err(exn) => {
18258 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.dropTagIndex", exn);
18259 crate::services::meta_service::DropTagIndexExn::ApplicationException(aexn)
18260 }
18261 };
18262
18263 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18264 "dropTagIndex",
18265 METHOD_NAME.as_cstr(),
18266 _seqid,
18267 req_ctxt,
18268 &mut ctx_stack,
18269 res
18270 )?;
18271 reply_state.lock().unwrap().send_reply(env);
18272 Ok(())
18273 }
18274
18275 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getTagIndex"))]
18276 async fn handle_getTagIndex<'a>(
18277 &'a self,
18278 p: &'a mut P::Deserializer,
18279 req_ctxt: &R,
18280 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18281 _seqid: ::std::primitive::u32,
18282 ) -> ::anyhow::Result<()> {
18283 use ::const_cstr::const_cstr;
18284 use ::futures::FutureExt as _;
18285
18286 const_cstr! {
18287 SERVICE_NAME = "MetaService";
18288 METHOD_NAME = "MetaService.getTagIndex";
18289 }
18290 let mut ctx_stack = req_ctxt.get_context_stack(
18291 SERVICE_NAME.as_cstr(),
18292 METHOD_NAME.as_cstr(),
18293 )?;
18294 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18295 let _args: self::Args_MetaService_getTagIndex = ::fbthrift::Deserialize::read(p)?;
18296 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18297 protocol: P::PROTOCOL_ID,
18298 method_name: METHOD_NAME.as_cstr(),
18299 buffer: ::std::marker::PhantomData, })?;
18301 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18302
18303 let res = ::std::panic::AssertUnwindSafe(
18304 self.service.getTagIndex(
18305 _args.req,
18306 )
18307 )
18308 .catch_unwind()
18309 .await;
18310
18311 let res = match res {
18313 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18314 ::tracing::info!("success");
18315 crate::services::meta_service::GetTagIndexExn::Success(res)
18316 }
18317 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetTagIndexExn::Success(_))) => {
18318 panic!(
18319 "{} attempted to return success via error",
18320 "getTagIndex",
18321 )
18322 }
18323 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18324 ::tracing::error!(exception = ?exn);
18325 exn
18326 }
18327 ::std::result::Result::Err(exn) => {
18328 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getTagIndex", exn);
18329 crate::services::meta_service::GetTagIndexExn::ApplicationException(aexn)
18330 }
18331 };
18332
18333 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18334 "getTagIndex",
18335 METHOD_NAME.as_cstr(),
18336 _seqid,
18337 req_ctxt,
18338 &mut ctx_stack,
18339 res
18340 )?;
18341 reply_state.lock().unwrap().send_reply(env);
18342 Ok(())
18343 }
18344
18345 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listTagIndexes"))]
18346 async fn handle_listTagIndexes<'a>(
18347 &'a self,
18348 p: &'a mut P::Deserializer,
18349 req_ctxt: &R,
18350 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18351 _seqid: ::std::primitive::u32,
18352 ) -> ::anyhow::Result<()> {
18353 use ::const_cstr::const_cstr;
18354 use ::futures::FutureExt as _;
18355
18356 const_cstr! {
18357 SERVICE_NAME = "MetaService";
18358 METHOD_NAME = "MetaService.listTagIndexes";
18359 }
18360 let mut ctx_stack = req_ctxt.get_context_stack(
18361 SERVICE_NAME.as_cstr(),
18362 METHOD_NAME.as_cstr(),
18363 )?;
18364 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18365 let _args: self::Args_MetaService_listTagIndexes = ::fbthrift::Deserialize::read(p)?;
18366 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18367 protocol: P::PROTOCOL_ID,
18368 method_name: METHOD_NAME.as_cstr(),
18369 buffer: ::std::marker::PhantomData, })?;
18371 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18372
18373 let res = ::std::panic::AssertUnwindSafe(
18374 self.service.listTagIndexes(
18375 _args.req,
18376 )
18377 )
18378 .catch_unwind()
18379 .await;
18380
18381 let res = match res {
18383 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18384 ::tracing::info!("success");
18385 crate::services::meta_service::ListTagIndexesExn::Success(res)
18386 }
18387 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListTagIndexesExn::Success(_))) => {
18388 panic!(
18389 "{} attempted to return success via error",
18390 "listTagIndexes",
18391 )
18392 }
18393 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18394 ::tracing::error!(exception = ?exn);
18395 exn
18396 }
18397 ::std::result::Result::Err(exn) => {
18398 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listTagIndexes", exn);
18399 crate::services::meta_service::ListTagIndexesExn::ApplicationException(aexn)
18400 }
18401 };
18402
18403 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18404 "listTagIndexes",
18405 METHOD_NAME.as_cstr(),
18406 _seqid,
18407 req_ctxt,
18408 &mut ctx_stack,
18409 res
18410 )?;
18411 reply_state.lock().unwrap().send_reply(env);
18412 Ok(())
18413 }
18414
18415 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.rebuildTagIndex"))]
18416 async fn handle_rebuildTagIndex<'a>(
18417 &'a self,
18418 p: &'a mut P::Deserializer,
18419 req_ctxt: &R,
18420 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18421 _seqid: ::std::primitive::u32,
18422 ) -> ::anyhow::Result<()> {
18423 use ::const_cstr::const_cstr;
18424 use ::futures::FutureExt as _;
18425
18426 const_cstr! {
18427 SERVICE_NAME = "MetaService";
18428 METHOD_NAME = "MetaService.rebuildTagIndex";
18429 }
18430 let mut ctx_stack = req_ctxt.get_context_stack(
18431 SERVICE_NAME.as_cstr(),
18432 METHOD_NAME.as_cstr(),
18433 )?;
18434 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18435 let _args: self::Args_MetaService_rebuildTagIndex = ::fbthrift::Deserialize::read(p)?;
18436 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18437 protocol: P::PROTOCOL_ID,
18438 method_name: METHOD_NAME.as_cstr(),
18439 buffer: ::std::marker::PhantomData, })?;
18441 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18442
18443 let res = ::std::panic::AssertUnwindSafe(
18444 self.service.rebuildTagIndex(
18445 _args.req,
18446 )
18447 )
18448 .catch_unwind()
18449 .await;
18450
18451 let res = match res {
18453 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18454 ::tracing::info!("success");
18455 crate::services::meta_service::RebuildTagIndexExn::Success(res)
18456 }
18457 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::RebuildTagIndexExn::Success(_))) => {
18458 panic!(
18459 "{} attempted to return success via error",
18460 "rebuildTagIndex",
18461 )
18462 }
18463 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18464 ::tracing::error!(exception = ?exn);
18465 exn
18466 }
18467 ::std::result::Result::Err(exn) => {
18468 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.rebuildTagIndex", exn);
18469 crate::services::meta_service::RebuildTagIndexExn::ApplicationException(aexn)
18470 }
18471 };
18472
18473 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18474 "rebuildTagIndex",
18475 METHOD_NAME.as_cstr(),
18476 _seqid,
18477 req_ctxt,
18478 &mut ctx_stack,
18479 res
18480 )?;
18481 reply_state.lock().unwrap().send_reply(env);
18482 Ok(())
18483 }
18484
18485 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listTagIndexStatus"))]
18486 async fn handle_listTagIndexStatus<'a>(
18487 &'a self,
18488 p: &'a mut P::Deserializer,
18489 req_ctxt: &R,
18490 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18491 _seqid: ::std::primitive::u32,
18492 ) -> ::anyhow::Result<()> {
18493 use ::const_cstr::const_cstr;
18494 use ::futures::FutureExt as _;
18495
18496 const_cstr! {
18497 SERVICE_NAME = "MetaService";
18498 METHOD_NAME = "MetaService.listTagIndexStatus";
18499 }
18500 let mut ctx_stack = req_ctxt.get_context_stack(
18501 SERVICE_NAME.as_cstr(),
18502 METHOD_NAME.as_cstr(),
18503 )?;
18504 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18505 let _args: self::Args_MetaService_listTagIndexStatus = ::fbthrift::Deserialize::read(p)?;
18506 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18507 protocol: P::PROTOCOL_ID,
18508 method_name: METHOD_NAME.as_cstr(),
18509 buffer: ::std::marker::PhantomData, })?;
18511 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18512
18513 let res = ::std::panic::AssertUnwindSafe(
18514 self.service.listTagIndexStatus(
18515 _args.req,
18516 )
18517 )
18518 .catch_unwind()
18519 .await;
18520
18521 let res = match res {
18523 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18524 ::tracing::info!("success");
18525 crate::services::meta_service::ListTagIndexStatusExn::Success(res)
18526 }
18527 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListTagIndexStatusExn::Success(_))) => {
18528 panic!(
18529 "{} attempted to return success via error",
18530 "listTagIndexStatus",
18531 )
18532 }
18533 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18534 ::tracing::error!(exception = ?exn);
18535 exn
18536 }
18537 ::std::result::Result::Err(exn) => {
18538 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listTagIndexStatus", exn);
18539 crate::services::meta_service::ListTagIndexStatusExn::ApplicationException(aexn)
18540 }
18541 };
18542
18543 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18544 "listTagIndexStatus",
18545 METHOD_NAME.as_cstr(),
18546 _seqid,
18547 req_ctxt,
18548 &mut ctx_stack,
18549 res
18550 )?;
18551 reply_state.lock().unwrap().send_reply(env);
18552 Ok(())
18553 }
18554
18555 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.createEdgeIndex"))]
18556 async fn handle_createEdgeIndex<'a>(
18557 &'a self,
18558 p: &'a mut P::Deserializer,
18559 req_ctxt: &R,
18560 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18561 _seqid: ::std::primitive::u32,
18562 ) -> ::anyhow::Result<()> {
18563 use ::const_cstr::const_cstr;
18564 use ::futures::FutureExt as _;
18565
18566 const_cstr! {
18567 SERVICE_NAME = "MetaService";
18568 METHOD_NAME = "MetaService.createEdgeIndex";
18569 }
18570 let mut ctx_stack = req_ctxt.get_context_stack(
18571 SERVICE_NAME.as_cstr(),
18572 METHOD_NAME.as_cstr(),
18573 )?;
18574 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18575 let _args: self::Args_MetaService_createEdgeIndex = ::fbthrift::Deserialize::read(p)?;
18576 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18577 protocol: P::PROTOCOL_ID,
18578 method_name: METHOD_NAME.as_cstr(),
18579 buffer: ::std::marker::PhantomData, })?;
18581 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18582
18583 let res = ::std::panic::AssertUnwindSafe(
18584 self.service.createEdgeIndex(
18585 _args.req,
18586 )
18587 )
18588 .catch_unwind()
18589 .await;
18590
18591 let res = match res {
18593 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18594 ::tracing::info!("success");
18595 crate::services::meta_service::CreateEdgeIndexExn::Success(res)
18596 }
18597 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::CreateEdgeIndexExn::Success(_))) => {
18598 panic!(
18599 "{} attempted to return success via error",
18600 "createEdgeIndex",
18601 )
18602 }
18603 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18604 ::tracing::error!(exception = ?exn);
18605 exn
18606 }
18607 ::std::result::Result::Err(exn) => {
18608 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.createEdgeIndex", exn);
18609 crate::services::meta_service::CreateEdgeIndexExn::ApplicationException(aexn)
18610 }
18611 };
18612
18613 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18614 "createEdgeIndex",
18615 METHOD_NAME.as_cstr(),
18616 _seqid,
18617 req_ctxt,
18618 &mut ctx_stack,
18619 res
18620 )?;
18621 reply_state.lock().unwrap().send_reply(env);
18622 Ok(())
18623 }
18624
18625 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.dropEdgeIndex"))]
18626 async fn handle_dropEdgeIndex<'a>(
18627 &'a self,
18628 p: &'a mut P::Deserializer,
18629 req_ctxt: &R,
18630 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18631 _seqid: ::std::primitive::u32,
18632 ) -> ::anyhow::Result<()> {
18633 use ::const_cstr::const_cstr;
18634 use ::futures::FutureExt as _;
18635
18636 const_cstr! {
18637 SERVICE_NAME = "MetaService";
18638 METHOD_NAME = "MetaService.dropEdgeIndex";
18639 }
18640 let mut ctx_stack = req_ctxt.get_context_stack(
18641 SERVICE_NAME.as_cstr(),
18642 METHOD_NAME.as_cstr(),
18643 )?;
18644 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18645 let _args: self::Args_MetaService_dropEdgeIndex = ::fbthrift::Deserialize::read(p)?;
18646 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18647 protocol: P::PROTOCOL_ID,
18648 method_name: METHOD_NAME.as_cstr(),
18649 buffer: ::std::marker::PhantomData, })?;
18651 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18652
18653 let res = ::std::panic::AssertUnwindSafe(
18654 self.service.dropEdgeIndex(
18655 _args.req,
18656 )
18657 )
18658 .catch_unwind()
18659 .await;
18660
18661 let res = match res {
18663 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18664 ::tracing::info!("success");
18665 crate::services::meta_service::DropEdgeIndexExn::Success(res)
18666 }
18667 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::DropEdgeIndexExn::Success(_))) => {
18668 panic!(
18669 "{} attempted to return success via error",
18670 "dropEdgeIndex",
18671 )
18672 }
18673 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18674 ::tracing::error!(exception = ?exn);
18675 exn
18676 }
18677 ::std::result::Result::Err(exn) => {
18678 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.dropEdgeIndex", exn);
18679 crate::services::meta_service::DropEdgeIndexExn::ApplicationException(aexn)
18680 }
18681 };
18682
18683 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18684 "dropEdgeIndex",
18685 METHOD_NAME.as_cstr(),
18686 _seqid,
18687 req_ctxt,
18688 &mut ctx_stack,
18689 res
18690 )?;
18691 reply_state.lock().unwrap().send_reply(env);
18692 Ok(())
18693 }
18694
18695 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getEdgeIndex"))]
18696 async fn handle_getEdgeIndex<'a>(
18697 &'a self,
18698 p: &'a mut P::Deserializer,
18699 req_ctxt: &R,
18700 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18701 _seqid: ::std::primitive::u32,
18702 ) -> ::anyhow::Result<()> {
18703 use ::const_cstr::const_cstr;
18704 use ::futures::FutureExt as _;
18705
18706 const_cstr! {
18707 SERVICE_NAME = "MetaService";
18708 METHOD_NAME = "MetaService.getEdgeIndex";
18709 }
18710 let mut ctx_stack = req_ctxt.get_context_stack(
18711 SERVICE_NAME.as_cstr(),
18712 METHOD_NAME.as_cstr(),
18713 )?;
18714 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18715 let _args: self::Args_MetaService_getEdgeIndex = ::fbthrift::Deserialize::read(p)?;
18716 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18717 protocol: P::PROTOCOL_ID,
18718 method_name: METHOD_NAME.as_cstr(),
18719 buffer: ::std::marker::PhantomData, })?;
18721 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18722
18723 let res = ::std::panic::AssertUnwindSafe(
18724 self.service.getEdgeIndex(
18725 _args.req,
18726 )
18727 )
18728 .catch_unwind()
18729 .await;
18730
18731 let res = match res {
18733 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18734 ::tracing::info!("success");
18735 crate::services::meta_service::GetEdgeIndexExn::Success(res)
18736 }
18737 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetEdgeIndexExn::Success(_))) => {
18738 panic!(
18739 "{} attempted to return success via error",
18740 "getEdgeIndex",
18741 )
18742 }
18743 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18744 ::tracing::error!(exception = ?exn);
18745 exn
18746 }
18747 ::std::result::Result::Err(exn) => {
18748 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getEdgeIndex", exn);
18749 crate::services::meta_service::GetEdgeIndexExn::ApplicationException(aexn)
18750 }
18751 };
18752
18753 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18754 "getEdgeIndex",
18755 METHOD_NAME.as_cstr(),
18756 _seqid,
18757 req_ctxt,
18758 &mut ctx_stack,
18759 res
18760 )?;
18761 reply_state.lock().unwrap().send_reply(env);
18762 Ok(())
18763 }
18764
18765 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listEdgeIndexes"))]
18766 async fn handle_listEdgeIndexes<'a>(
18767 &'a self,
18768 p: &'a mut P::Deserializer,
18769 req_ctxt: &R,
18770 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18771 _seqid: ::std::primitive::u32,
18772 ) -> ::anyhow::Result<()> {
18773 use ::const_cstr::const_cstr;
18774 use ::futures::FutureExt as _;
18775
18776 const_cstr! {
18777 SERVICE_NAME = "MetaService";
18778 METHOD_NAME = "MetaService.listEdgeIndexes";
18779 }
18780 let mut ctx_stack = req_ctxt.get_context_stack(
18781 SERVICE_NAME.as_cstr(),
18782 METHOD_NAME.as_cstr(),
18783 )?;
18784 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18785 let _args: self::Args_MetaService_listEdgeIndexes = ::fbthrift::Deserialize::read(p)?;
18786 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18787 protocol: P::PROTOCOL_ID,
18788 method_name: METHOD_NAME.as_cstr(),
18789 buffer: ::std::marker::PhantomData, })?;
18791 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18792
18793 let res = ::std::panic::AssertUnwindSafe(
18794 self.service.listEdgeIndexes(
18795 _args.req,
18796 )
18797 )
18798 .catch_unwind()
18799 .await;
18800
18801 let res = match res {
18803 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18804 ::tracing::info!("success");
18805 crate::services::meta_service::ListEdgeIndexesExn::Success(res)
18806 }
18807 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListEdgeIndexesExn::Success(_))) => {
18808 panic!(
18809 "{} attempted to return success via error",
18810 "listEdgeIndexes",
18811 )
18812 }
18813 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18814 ::tracing::error!(exception = ?exn);
18815 exn
18816 }
18817 ::std::result::Result::Err(exn) => {
18818 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listEdgeIndexes", exn);
18819 crate::services::meta_service::ListEdgeIndexesExn::ApplicationException(aexn)
18820 }
18821 };
18822
18823 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18824 "listEdgeIndexes",
18825 METHOD_NAME.as_cstr(),
18826 _seqid,
18827 req_ctxt,
18828 &mut ctx_stack,
18829 res
18830 )?;
18831 reply_state.lock().unwrap().send_reply(env);
18832 Ok(())
18833 }
18834
18835 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.rebuildEdgeIndex"))]
18836 async fn handle_rebuildEdgeIndex<'a>(
18837 &'a self,
18838 p: &'a mut P::Deserializer,
18839 req_ctxt: &R,
18840 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18841 _seqid: ::std::primitive::u32,
18842 ) -> ::anyhow::Result<()> {
18843 use ::const_cstr::const_cstr;
18844 use ::futures::FutureExt as _;
18845
18846 const_cstr! {
18847 SERVICE_NAME = "MetaService";
18848 METHOD_NAME = "MetaService.rebuildEdgeIndex";
18849 }
18850 let mut ctx_stack = req_ctxt.get_context_stack(
18851 SERVICE_NAME.as_cstr(),
18852 METHOD_NAME.as_cstr(),
18853 )?;
18854 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18855 let _args: self::Args_MetaService_rebuildEdgeIndex = ::fbthrift::Deserialize::read(p)?;
18856 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18857 protocol: P::PROTOCOL_ID,
18858 method_name: METHOD_NAME.as_cstr(),
18859 buffer: ::std::marker::PhantomData, })?;
18861 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18862
18863 let res = ::std::panic::AssertUnwindSafe(
18864 self.service.rebuildEdgeIndex(
18865 _args.req,
18866 )
18867 )
18868 .catch_unwind()
18869 .await;
18870
18871 let res = match res {
18873 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18874 ::tracing::info!("success");
18875 crate::services::meta_service::RebuildEdgeIndexExn::Success(res)
18876 }
18877 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::RebuildEdgeIndexExn::Success(_))) => {
18878 panic!(
18879 "{} attempted to return success via error",
18880 "rebuildEdgeIndex",
18881 )
18882 }
18883 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18884 ::tracing::error!(exception = ?exn);
18885 exn
18886 }
18887 ::std::result::Result::Err(exn) => {
18888 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.rebuildEdgeIndex", exn);
18889 crate::services::meta_service::RebuildEdgeIndexExn::ApplicationException(aexn)
18890 }
18891 };
18892
18893 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18894 "rebuildEdgeIndex",
18895 METHOD_NAME.as_cstr(),
18896 _seqid,
18897 req_ctxt,
18898 &mut ctx_stack,
18899 res
18900 )?;
18901 reply_state.lock().unwrap().send_reply(env);
18902 Ok(())
18903 }
18904
18905 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listEdgeIndexStatus"))]
18906 async fn handle_listEdgeIndexStatus<'a>(
18907 &'a self,
18908 p: &'a mut P::Deserializer,
18909 req_ctxt: &R,
18910 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18911 _seqid: ::std::primitive::u32,
18912 ) -> ::anyhow::Result<()> {
18913 use ::const_cstr::const_cstr;
18914 use ::futures::FutureExt as _;
18915
18916 const_cstr! {
18917 SERVICE_NAME = "MetaService";
18918 METHOD_NAME = "MetaService.listEdgeIndexStatus";
18919 }
18920 let mut ctx_stack = req_ctxt.get_context_stack(
18921 SERVICE_NAME.as_cstr(),
18922 METHOD_NAME.as_cstr(),
18923 )?;
18924 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18925 let _args: self::Args_MetaService_listEdgeIndexStatus = ::fbthrift::Deserialize::read(p)?;
18926 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18927 protocol: P::PROTOCOL_ID,
18928 method_name: METHOD_NAME.as_cstr(),
18929 buffer: ::std::marker::PhantomData, })?;
18931 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
18932
18933 let res = ::std::panic::AssertUnwindSafe(
18934 self.service.listEdgeIndexStatus(
18935 _args.req,
18936 )
18937 )
18938 .catch_unwind()
18939 .await;
18940
18941 let res = match res {
18943 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
18944 ::tracing::info!("success");
18945 crate::services::meta_service::ListEdgeIndexStatusExn::Success(res)
18946 }
18947 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListEdgeIndexStatusExn::Success(_))) => {
18948 panic!(
18949 "{} attempted to return success via error",
18950 "listEdgeIndexStatus",
18951 )
18952 }
18953 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
18954 ::tracing::error!(exception = ?exn);
18955 exn
18956 }
18957 ::std::result::Result::Err(exn) => {
18958 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listEdgeIndexStatus", exn);
18959 crate::services::meta_service::ListEdgeIndexStatusExn::ApplicationException(aexn)
18960 }
18961 };
18962
18963 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
18964 "listEdgeIndexStatus",
18965 METHOD_NAME.as_cstr(),
18966 _seqid,
18967 req_ctxt,
18968 &mut ctx_stack,
18969 res
18970 )?;
18971 reply_state.lock().unwrap().send_reply(env);
18972 Ok(())
18973 }
18974
18975 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.createUser"))]
18976 async fn handle_createUser<'a>(
18977 &'a self,
18978 p: &'a mut P::Deserializer,
18979 req_ctxt: &R,
18980 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
18981 _seqid: ::std::primitive::u32,
18982 ) -> ::anyhow::Result<()> {
18983 use ::const_cstr::const_cstr;
18984 use ::futures::FutureExt as _;
18985
18986 const_cstr! {
18987 SERVICE_NAME = "MetaService";
18988 METHOD_NAME = "MetaService.createUser";
18989 }
18990 let mut ctx_stack = req_ctxt.get_context_stack(
18991 SERVICE_NAME.as_cstr(),
18992 METHOD_NAME.as_cstr(),
18993 )?;
18994 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
18995 let _args: self::Args_MetaService_createUser = ::fbthrift::Deserialize::read(p)?;
18996 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
18997 protocol: P::PROTOCOL_ID,
18998 method_name: METHOD_NAME.as_cstr(),
18999 buffer: ::std::marker::PhantomData, })?;
19001 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19002
19003 let res = ::std::panic::AssertUnwindSafe(
19004 self.service.createUser(
19005 _args.req,
19006 )
19007 )
19008 .catch_unwind()
19009 .await;
19010
19011 let res = match res {
19013 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19014 ::tracing::info!("success");
19015 crate::services::meta_service::CreateUserExn::Success(res)
19016 }
19017 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::CreateUserExn::Success(_))) => {
19018 panic!(
19019 "{} attempted to return success via error",
19020 "createUser",
19021 )
19022 }
19023 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19024 ::tracing::error!(exception = ?exn);
19025 exn
19026 }
19027 ::std::result::Result::Err(exn) => {
19028 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.createUser", exn);
19029 crate::services::meta_service::CreateUserExn::ApplicationException(aexn)
19030 }
19031 };
19032
19033 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19034 "createUser",
19035 METHOD_NAME.as_cstr(),
19036 _seqid,
19037 req_ctxt,
19038 &mut ctx_stack,
19039 res
19040 )?;
19041 reply_state.lock().unwrap().send_reply(env);
19042 Ok(())
19043 }
19044
19045 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.dropUser"))]
19046 async fn handle_dropUser<'a>(
19047 &'a self,
19048 p: &'a mut P::Deserializer,
19049 req_ctxt: &R,
19050 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19051 _seqid: ::std::primitive::u32,
19052 ) -> ::anyhow::Result<()> {
19053 use ::const_cstr::const_cstr;
19054 use ::futures::FutureExt as _;
19055
19056 const_cstr! {
19057 SERVICE_NAME = "MetaService";
19058 METHOD_NAME = "MetaService.dropUser";
19059 }
19060 let mut ctx_stack = req_ctxt.get_context_stack(
19061 SERVICE_NAME.as_cstr(),
19062 METHOD_NAME.as_cstr(),
19063 )?;
19064 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19065 let _args: self::Args_MetaService_dropUser = ::fbthrift::Deserialize::read(p)?;
19066 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19067 protocol: P::PROTOCOL_ID,
19068 method_name: METHOD_NAME.as_cstr(),
19069 buffer: ::std::marker::PhantomData, })?;
19071 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19072
19073 let res = ::std::panic::AssertUnwindSafe(
19074 self.service.dropUser(
19075 _args.req,
19076 )
19077 )
19078 .catch_unwind()
19079 .await;
19080
19081 let res = match res {
19083 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19084 ::tracing::info!("success");
19085 crate::services::meta_service::DropUserExn::Success(res)
19086 }
19087 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::DropUserExn::Success(_))) => {
19088 panic!(
19089 "{} attempted to return success via error",
19090 "dropUser",
19091 )
19092 }
19093 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19094 ::tracing::error!(exception = ?exn);
19095 exn
19096 }
19097 ::std::result::Result::Err(exn) => {
19098 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.dropUser", exn);
19099 crate::services::meta_service::DropUserExn::ApplicationException(aexn)
19100 }
19101 };
19102
19103 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19104 "dropUser",
19105 METHOD_NAME.as_cstr(),
19106 _seqid,
19107 req_ctxt,
19108 &mut ctx_stack,
19109 res
19110 )?;
19111 reply_state.lock().unwrap().send_reply(env);
19112 Ok(())
19113 }
19114
19115 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.alterUser"))]
19116 async fn handle_alterUser<'a>(
19117 &'a self,
19118 p: &'a mut P::Deserializer,
19119 req_ctxt: &R,
19120 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19121 _seqid: ::std::primitive::u32,
19122 ) -> ::anyhow::Result<()> {
19123 use ::const_cstr::const_cstr;
19124 use ::futures::FutureExt as _;
19125
19126 const_cstr! {
19127 SERVICE_NAME = "MetaService";
19128 METHOD_NAME = "MetaService.alterUser";
19129 }
19130 let mut ctx_stack = req_ctxt.get_context_stack(
19131 SERVICE_NAME.as_cstr(),
19132 METHOD_NAME.as_cstr(),
19133 )?;
19134 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19135 let _args: self::Args_MetaService_alterUser = ::fbthrift::Deserialize::read(p)?;
19136 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19137 protocol: P::PROTOCOL_ID,
19138 method_name: METHOD_NAME.as_cstr(),
19139 buffer: ::std::marker::PhantomData, })?;
19141 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19142
19143 let res = ::std::panic::AssertUnwindSafe(
19144 self.service.alterUser(
19145 _args.req,
19146 )
19147 )
19148 .catch_unwind()
19149 .await;
19150
19151 let res = match res {
19153 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19154 ::tracing::info!("success");
19155 crate::services::meta_service::AlterUserExn::Success(res)
19156 }
19157 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::AlterUserExn::Success(_))) => {
19158 panic!(
19159 "{} attempted to return success via error",
19160 "alterUser",
19161 )
19162 }
19163 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19164 ::tracing::error!(exception = ?exn);
19165 exn
19166 }
19167 ::std::result::Result::Err(exn) => {
19168 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.alterUser", exn);
19169 crate::services::meta_service::AlterUserExn::ApplicationException(aexn)
19170 }
19171 };
19172
19173 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19174 "alterUser",
19175 METHOD_NAME.as_cstr(),
19176 _seqid,
19177 req_ctxt,
19178 &mut ctx_stack,
19179 res
19180 )?;
19181 reply_state.lock().unwrap().send_reply(env);
19182 Ok(())
19183 }
19184
19185 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.grantRole"))]
19186 async fn handle_grantRole<'a>(
19187 &'a self,
19188 p: &'a mut P::Deserializer,
19189 req_ctxt: &R,
19190 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19191 _seqid: ::std::primitive::u32,
19192 ) -> ::anyhow::Result<()> {
19193 use ::const_cstr::const_cstr;
19194 use ::futures::FutureExt as _;
19195
19196 const_cstr! {
19197 SERVICE_NAME = "MetaService";
19198 METHOD_NAME = "MetaService.grantRole";
19199 }
19200 let mut ctx_stack = req_ctxt.get_context_stack(
19201 SERVICE_NAME.as_cstr(),
19202 METHOD_NAME.as_cstr(),
19203 )?;
19204 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19205 let _args: self::Args_MetaService_grantRole = ::fbthrift::Deserialize::read(p)?;
19206 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19207 protocol: P::PROTOCOL_ID,
19208 method_name: METHOD_NAME.as_cstr(),
19209 buffer: ::std::marker::PhantomData, })?;
19211 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19212
19213 let res = ::std::panic::AssertUnwindSafe(
19214 self.service.grantRole(
19215 _args.req,
19216 )
19217 )
19218 .catch_unwind()
19219 .await;
19220
19221 let res = match res {
19223 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19224 ::tracing::info!("success");
19225 crate::services::meta_service::GrantRoleExn::Success(res)
19226 }
19227 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GrantRoleExn::Success(_))) => {
19228 panic!(
19229 "{} attempted to return success via error",
19230 "grantRole",
19231 )
19232 }
19233 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19234 ::tracing::error!(exception = ?exn);
19235 exn
19236 }
19237 ::std::result::Result::Err(exn) => {
19238 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.grantRole", exn);
19239 crate::services::meta_service::GrantRoleExn::ApplicationException(aexn)
19240 }
19241 };
19242
19243 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19244 "grantRole",
19245 METHOD_NAME.as_cstr(),
19246 _seqid,
19247 req_ctxt,
19248 &mut ctx_stack,
19249 res
19250 )?;
19251 reply_state.lock().unwrap().send_reply(env);
19252 Ok(())
19253 }
19254
19255 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.revokeRole"))]
19256 async fn handle_revokeRole<'a>(
19257 &'a self,
19258 p: &'a mut P::Deserializer,
19259 req_ctxt: &R,
19260 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19261 _seqid: ::std::primitive::u32,
19262 ) -> ::anyhow::Result<()> {
19263 use ::const_cstr::const_cstr;
19264 use ::futures::FutureExt as _;
19265
19266 const_cstr! {
19267 SERVICE_NAME = "MetaService";
19268 METHOD_NAME = "MetaService.revokeRole";
19269 }
19270 let mut ctx_stack = req_ctxt.get_context_stack(
19271 SERVICE_NAME.as_cstr(),
19272 METHOD_NAME.as_cstr(),
19273 )?;
19274 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19275 let _args: self::Args_MetaService_revokeRole = ::fbthrift::Deserialize::read(p)?;
19276 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19277 protocol: P::PROTOCOL_ID,
19278 method_name: METHOD_NAME.as_cstr(),
19279 buffer: ::std::marker::PhantomData, })?;
19281 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19282
19283 let res = ::std::panic::AssertUnwindSafe(
19284 self.service.revokeRole(
19285 _args.req,
19286 )
19287 )
19288 .catch_unwind()
19289 .await;
19290
19291 let res = match res {
19293 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19294 ::tracing::info!("success");
19295 crate::services::meta_service::RevokeRoleExn::Success(res)
19296 }
19297 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::RevokeRoleExn::Success(_))) => {
19298 panic!(
19299 "{} attempted to return success via error",
19300 "revokeRole",
19301 )
19302 }
19303 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19304 ::tracing::error!(exception = ?exn);
19305 exn
19306 }
19307 ::std::result::Result::Err(exn) => {
19308 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.revokeRole", exn);
19309 crate::services::meta_service::RevokeRoleExn::ApplicationException(aexn)
19310 }
19311 };
19312
19313 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19314 "revokeRole",
19315 METHOD_NAME.as_cstr(),
19316 _seqid,
19317 req_ctxt,
19318 &mut ctx_stack,
19319 res
19320 )?;
19321 reply_state.lock().unwrap().send_reply(env);
19322 Ok(())
19323 }
19324
19325 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listUsers"))]
19326 async fn handle_listUsers<'a>(
19327 &'a self,
19328 p: &'a mut P::Deserializer,
19329 req_ctxt: &R,
19330 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19331 _seqid: ::std::primitive::u32,
19332 ) -> ::anyhow::Result<()> {
19333 use ::const_cstr::const_cstr;
19334 use ::futures::FutureExt as _;
19335
19336 const_cstr! {
19337 SERVICE_NAME = "MetaService";
19338 METHOD_NAME = "MetaService.listUsers";
19339 }
19340 let mut ctx_stack = req_ctxt.get_context_stack(
19341 SERVICE_NAME.as_cstr(),
19342 METHOD_NAME.as_cstr(),
19343 )?;
19344 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19345 let _args: self::Args_MetaService_listUsers = ::fbthrift::Deserialize::read(p)?;
19346 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19347 protocol: P::PROTOCOL_ID,
19348 method_name: METHOD_NAME.as_cstr(),
19349 buffer: ::std::marker::PhantomData, })?;
19351 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19352
19353 let res = ::std::panic::AssertUnwindSafe(
19354 self.service.listUsers(
19355 _args.req,
19356 )
19357 )
19358 .catch_unwind()
19359 .await;
19360
19361 let res = match res {
19363 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19364 ::tracing::info!("success");
19365 crate::services::meta_service::ListUsersExn::Success(res)
19366 }
19367 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListUsersExn::Success(_))) => {
19368 panic!(
19369 "{} attempted to return success via error",
19370 "listUsers",
19371 )
19372 }
19373 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19374 ::tracing::error!(exception = ?exn);
19375 exn
19376 }
19377 ::std::result::Result::Err(exn) => {
19378 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listUsers", exn);
19379 crate::services::meta_service::ListUsersExn::ApplicationException(aexn)
19380 }
19381 };
19382
19383 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19384 "listUsers",
19385 METHOD_NAME.as_cstr(),
19386 _seqid,
19387 req_ctxt,
19388 &mut ctx_stack,
19389 res
19390 )?;
19391 reply_state.lock().unwrap().send_reply(env);
19392 Ok(())
19393 }
19394
19395 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listRoles"))]
19396 async fn handle_listRoles<'a>(
19397 &'a self,
19398 p: &'a mut P::Deserializer,
19399 req_ctxt: &R,
19400 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19401 _seqid: ::std::primitive::u32,
19402 ) -> ::anyhow::Result<()> {
19403 use ::const_cstr::const_cstr;
19404 use ::futures::FutureExt as _;
19405
19406 const_cstr! {
19407 SERVICE_NAME = "MetaService";
19408 METHOD_NAME = "MetaService.listRoles";
19409 }
19410 let mut ctx_stack = req_ctxt.get_context_stack(
19411 SERVICE_NAME.as_cstr(),
19412 METHOD_NAME.as_cstr(),
19413 )?;
19414 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19415 let _args: self::Args_MetaService_listRoles = ::fbthrift::Deserialize::read(p)?;
19416 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19417 protocol: P::PROTOCOL_ID,
19418 method_name: METHOD_NAME.as_cstr(),
19419 buffer: ::std::marker::PhantomData, })?;
19421 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19422
19423 let res = ::std::panic::AssertUnwindSafe(
19424 self.service.listRoles(
19425 _args.req,
19426 )
19427 )
19428 .catch_unwind()
19429 .await;
19430
19431 let res = match res {
19433 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19434 ::tracing::info!("success");
19435 crate::services::meta_service::ListRolesExn::Success(res)
19436 }
19437 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListRolesExn::Success(_))) => {
19438 panic!(
19439 "{} attempted to return success via error",
19440 "listRoles",
19441 )
19442 }
19443 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19444 ::tracing::error!(exception = ?exn);
19445 exn
19446 }
19447 ::std::result::Result::Err(exn) => {
19448 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listRoles", exn);
19449 crate::services::meta_service::ListRolesExn::ApplicationException(aexn)
19450 }
19451 };
19452
19453 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19454 "listRoles",
19455 METHOD_NAME.as_cstr(),
19456 _seqid,
19457 req_ctxt,
19458 &mut ctx_stack,
19459 res
19460 )?;
19461 reply_state.lock().unwrap().send_reply(env);
19462 Ok(())
19463 }
19464
19465 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getUserRoles"))]
19466 async fn handle_getUserRoles<'a>(
19467 &'a self,
19468 p: &'a mut P::Deserializer,
19469 req_ctxt: &R,
19470 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19471 _seqid: ::std::primitive::u32,
19472 ) -> ::anyhow::Result<()> {
19473 use ::const_cstr::const_cstr;
19474 use ::futures::FutureExt as _;
19475
19476 const_cstr! {
19477 SERVICE_NAME = "MetaService";
19478 METHOD_NAME = "MetaService.getUserRoles";
19479 }
19480 let mut ctx_stack = req_ctxt.get_context_stack(
19481 SERVICE_NAME.as_cstr(),
19482 METHOD_NAME.as_cstr(),
19483 )?;
19484 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19485 let _args: self::Args_MetaService_getUserRoles = ::fbthrift::Deserialize::read(p)?;
19486 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19487 protocol: P::PROTOCOL_ID,
19488 method_name: METHOD_NAME.as_cstr(),
19489 buffer: ::std::marker::PhantomData, })?;
19491 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19492
19493 let res = ::std::panic::AssertUnwindSafe(
19494 self.service.getUserRoles(
19495 _args.req,
19496 )
19497 )
19498 .catch_unwind()
19499 .await;
19500
19501 let res = match res {
19503 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19504 ::tracing::info!("success");
19505 crate::services::meta_service::GetUserRolesExn::Success(res)
19506 }
19507 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetUserRolesExn::Success(_))) => {
19508 panic!(
19509 "{} attempted to return success via error",
19510 "getUserRoles",
19511 )
19512 }
19513 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19514 ::tracing::error!(exception = ?exn);
19515 exn
19516 }
19517 ::std::result::Result::Err(exn) => {
19518 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getUserRoles", exn);
19519 crate::services::meta_service::GetUserRolesExn::ApplicationException(aexn)
19520 }
19521 };
19522
19523 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19524 "getUserRoles",
19525 METHOD_NAME.as_cstr(),
19526 _seqid,
19527 req_ctxt,
19528 &mut ctx_stack,
19529 res
19530 )?;
19531 reply_state.lock().unwrap().send_reply(env);
19532 Ok(())
19533 }
19534
19535 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.changePassword"))]
19536 async fn handle_changePassword<'a>(
19537 &'a self,
19538 p: &'a mut P::Deserializer,
19539 req_ctxt: &R,
19540 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19541 _seqid: ::std::primitive::u32,
19542 ) -> ::anyhow::Result<()> {
19543 use ::const_cstr::const_cstr;
19544 use ::futures::FutureExt as _;
19545
19546 const_cstr! {
19547 SERVICE_NAME = "MetaService";
19548 METHOD_NAME = "MetaService.changePassword";
19549 }
19550 let mut ctx_stack = req_ctxt.get_context_stack(
19551 SERVICE_NAME.as_cstr(),
19552 METHOD_NAME.as_cstr(),
19553 )?;
19554 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19555 let _args: self::Args_MetaService_changePassword = ::fbthrift::Deserialize::read(p)?;
19556 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19557 protocol: P::PROTOCOL_ID,
19558 method_name: METHOD_NAME.as_cstr(),
19559 buffer: ::std::marker::PhantomData, })?;
19561 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19562
19563 let res = ::std::panic::AssertUnwindSafe(
19564 self.service.changePassword(
19565 _args.req,
19566 )
19567 )
19568 .catch_unwind()
19569 .await;
19570
19571 let res = match res {
19573 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19574 ::tracing::info!("success");
19575 crate::services::meta_service::ChangePasswordExn::Success(res)
19576 }
19577 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ChangePasswordExn::Success(_))) => {
19578 panic!(
19579 "{} attempted to return success via error",
19580 "changePassword",
19581 )
19582 }
19583 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19584 ::tracing::error!(exception = ?exn);
19585 exn
19586 }
19587 ::std::result::Result::Err(exn) => {
19588 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.changePassword", exn);
19589 crate::services::meta_service::ChangePasswordExn::ApplicationException(aexn)
19590 }
19591 };
19592
19593 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19594 "changePassword",
19595 METHOD_NAME.as_cstr(),
19596 _seqid,
19597 req_ctxt,
19598 &mut ctx_stack,
19599 res
19600 )?;
19601 reply_state.lock().unwrap().send_reply(env);
19602 Ok(())
19603 }
19604
19605 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.heartBeat"))]
19606 async fn handle_heartBeat<'a>(
19607 &'a self,
19608 p: &'a mut P::Deserializer,
19609 req_ctxt: &R,
19610 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19611 _seqid: ::std::primitive::u32,
19612 ) -> ::anyhow::Result<()> {
19613 use ::const_cstr::const_cstr;
19614 use ::futures::FutureExt as _;
19615
19616 const_cstr! {
19617 SERVICE_NAME = "MetaService";
19618 METHOD_NAME = "MetaService.heartBeat";
19619 }
19620 let mut ctx_stack = req_ctxt.get_context_stack(
19621 SERVICE_NAME.as_cstr(),
19622 METHOD_NAME.as_cstr(),
19623 )?;
19624 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19625 let _args: self::Args_MetaService_heartBeat = ::fbthrift::Deserialize::read(p)?;
19626 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19627 protocol: P::PROTOCOL_ID,
19628 method_name: METHOD_NAME.as_cstr(),
19629 buffer: ::std::marker::PhantomData, })?;
19631 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19632
19633 let res = ::std::panic::AssertUnwindSafe(
19634 self.service.heartBeat(
19635 _args.req,
19636 )
19637 )
19638 .catch_unwind()
19639 .await;
19640
19641 let res = match res {
19643 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19644 ::tracing::info!("success");
19645 crate::services::meta_service::HeartBeatExn::Success(res)
19646 }
19647 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::HeartBeatExn::Success(_))) => {
19648 panic!(
19649 "{} attempted to return success via error",
19650 "heartBeat",
19651 )
19652 }
19653 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19654 ::tracing::error!(exception = ?exn);
19655 exn
19656 }
19657 ::std::result::Result::Err(exn) => {
19658 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.heartBeat", exn);
19659 crate::services::meta_service::HeartBeatExn::ApplicationException(aexn)
19660 }
19661 };
19662
19663 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19664 "heartBeat",
19665 METHOD_NAME.as_cstr(),
19666 _seqid,
19667 req_ctxt,
19668 &mut ctx_stack,
19669 res
19670 )?;
19671 reply_state.lock().unwrap().send_reply(env);
19672 Ok(())
19673 }
19674
19675 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.balance"))]
19676 async fn handle_balance<'a>(
19677 &'a self,
19678 p: &'a mut P::Deserializer,
19679 req_ctxt: &R,
19680 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19681 _seqid: ::std::primitive::u32,
19682 ) -> ::anyhow::Result<()> {
19683 use ::const_cstr::const_cstr;
19684 use ::futures::FutureExt as _;
19685
19686 const_cstr! {
19687 SERVICE_NAME = "MetaService";
19688 METHOD_NAME = "MetaService.balance";
19689 }
19690 let mut ctx_stack = req_ctxt.get_context_stack(
19691 SERVICE_NAME.as_cstr(),
19692 METHOD_NAME.as_cstr(),
19693 )?;
19694 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19695 let _args: self::Args_MetaService_balance = ::fbthrift::Deserialize::read(p)?;
19696 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19697 protocol: P::PROTOCOL_ID,
19698 method_name: METHOD_NAME.as_cstr(),
19699 buffer: ::std::marker::PhantomData, })?;
19701 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19702
19703 let res = ::std::panic::AssertUnwindSafe(
19704 self.service.balance(
19705 _args.req,
19706 )
19707 )
19708 .catch_unwind()
19709 .await;
19710
19711 let res = match res {
19713 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19714 ::tracing::info!("success");
19715 crate::services::meta_service::BalanceExn::Success(res)
19716 }
19717 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::BalanceExn::Success(_))) => {
19718 panic!(
19719 "{} attempted to return success via error",
19720 "balance",
19721 )
19722 }
19723 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19724 ::tracing::error!(exception = ?exn);
19725 exn
19726 }
19727 ::std::result::Result::Err(exn) => {
19728 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.balance", exn);
19729 crate::services::meta_service::BalanceExn::ApplicationException(aexn)
19730 }
19731 };
19732
19733 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19734 "balance",
19735 METHOD_NAME.as_cstr(),
19736 _seqid,
19737 req_ctxt,
19738 &mut ctx_stack,
19739 res
19740 )?;
19741 reply_state.lock().unwrap().send_reply(env);
19742 Ok(())
19743 }
19744
19745 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.leaderBalance"))]
19746 async fn handle_leaderBalance<'a>(
19747 &'a self,
19748 p: &'a mut P::Deserializer,
19749 req_ctxt: &R,
19750 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19751 _seqid: ::std::primitive::u32,
19752 ) -> ::anyhow::Result<()> {
19753 use ::const_cstr::const_cstr;
19754 use ::futures::FutureExt as _;
19755
19756 const_cstr! {
19757 SERVICE_NAME = "MetaService";
19758 METHOD_NAME = "MetaService.leaderBalance";
19759 }
19760 let mut ctx_stack = req_ctxt.get_context_stack(
19761 SERVICE_NAME.as_cstr(),
19762 METHOD_NAME.as_cstr(),
19763 )?;
19764 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19765 let _args: self::Args_MetaService_leaderBalance = ::fbthrift::Deserialize::read(p)?;
19766 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19767 protocol: P::PROTOCOL_ID,
19768 method_name: METHOD_NAME.as_cstr(),
19769 buffer: ::std::marker::PhantomData, })?;
19771 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19772
19773 let res = ::std::panic::AssertUnwindSafe(
19774 self.service.leaderBalance(
19775 _args.req,
19776 )
19777 )
19778 .catch_unwind()
19779 .await;
19780
19781 let res = match res {
19783 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19784 ::tracing::info!("success");
19785 crate::services::meta_service::LeaderBalanceExn::Success(res)
19786 }
19787 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::LeaderBalanceExn::Success(_))) => {
19788 panic!(
19789 "{} attempted to return success via error",
19790 "leaderBalance",
19791 )
19792 }
19793 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19794 ::tracing::error!(exception = ?exn);
19795 exn
19796 }
19797 ::std::result::Result::Err(exn) => {
19798 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.leaderBalance", exn);
19799 crate::services::meta_service::LeaderBalanceExn::ApplicationException(aexn)
19800 }
19801 };
19802
19803 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19804 "leaderBalance",
19805 METHOD_NAME.as_cstr(),
19806 _seqid,
19807 req_ctxt,
19808 &mut ctx_stack,
19809 res
19810 )?;
19811 reply_state.lock().unwrap().send_reply(env);
19812 Ok(())
19813 }
19814
19815 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.regConfig"))]
19816 async fn handle_regConfig<'a>(
19817 &'a self,
19818 p: &'a mut P::Deserializer,
19819 req_ctxt: &R,
19820 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19821 _seqid: ::std::primitive::u32,
19822 ) -> ::anyhow::Result<()> {
19823 use ::const_cstr::const_cstr;
19824 use ::futures::FutureExt as _;
19825
19826 const_cstr! {
19827 SERVICE_NAME = "MetaService";
19828 METHOD_NAME = "MetaService.regConfig";
19829 }
19830 let mut ctx_stack = req_ctxt.get_context_stack(
19831 SERVICE_NAME.as_cstr(),
19832 METHOD_NAME.as_cstr(),
19833 )?;
19834 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19835 let _args: self::Args_MetaService_regConfig = ::fbthrift::Deserialize::read(p)?;
19836 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19837 protocol: P::PROTOCOL_ID,
19838 method_name: METHOD_NAME.as_cstr(),
19839 buffer: ::std::marker::PhantomData, })?;
19841 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19842
19843 let res = ::std::panic::AssertUnwindSafe(
19844 self.service.regConfig(
19845 _args.req,
19846 )
19847 )
19848 .catch_unwind()
19849 .await;
19850
19851 let res = match res {
19853 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19854 ::tracing::info!("success");
19855 crate::services::meta_service::RegConfigExn::Success(res)
19856 }
19857 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::RegConfigExn::Success(_))) => {
19858 panic!(
19859 "{} attempted to return success via error",
19860 "regConfig",
19861 )
19862 }
19863 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19864 ::tracing::error!(exception = ?exn);
19865 exn
19866 }
19867 ::std::result::Result::Err(exn) => {
19868 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.regConfig", exn);
19869 crate::services::meta_service::RegConfigExn::ApplicationException(aexn)
19870 }
19871 };
19872
19873 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19874 "regConfig",
19875 METHOD_NAME.as_cstr(),
19876 _seqid,
19877 req_ctxt,
19878 &mut ctx_stack,
19879 res
19880 )?;
19881 reply_state.lock().unwrap().send_reply(env);
19882 Ok(())
19883 }
19884
19885 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.getConfig"))]
19886 async fn handle_getConfig<'a>(
19887 &'a self,
19888 p: &'a mut P::Deserializer,
19889 req_ctxt: &R,
19890 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19891 _seqid: ::std::primitive::u32,
19892 ) -> ::anyhow::Result<()> {
19893 use ::const_cstr::const_cstr;
19894 use ::futures::FutureExt as _;
19895
19896 const_cstr! {
19897 SERVICE_NAME = "MetaService";
19898 METHOD_NAME = "MetaService.getConfig";
19899 }
19900 let mut ctx_stack = req_ctxt.get_context_stack(
19901 SERVICE_NAME.as_cstr(),
19902 METHOD_NAME.as_cstr(),
19903 )?;
19904 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19905 let _args: self::Args_MetaService_getConfig = ::fbthrift::Deserialize::read(p)?;
19906 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19907 protocol: P::PROTOCOL_ID,
19908 method_name: METHOD_NAME.as_cstr(),
19909 buffer: ::std::marker::PhantomData, })?;
19911 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19912
19913 let res = ::std::panic::AssertUnwindSafe(
19914 self.service.getConfig(
19915 _args.req,
19916 )
19917 )
19918 .catch_unwind()
19919 .await;
19920
19921 let res = match res {
19923 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19924 ::tracing::info!("success");
19925 crate::services::meta_service::GetConfigExn::Success(res)
19926 }
19927 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::GetConfigExn::Success(_))) => {
19928 panic!(
19929 "{} attempted to return success via error",
19930 "getConfig",
19931 )
19932 }
19933 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
19934 ::tracing::error!(exception = ?exn);
19935 exn
19936 }
19937 ::std::result::Result::Err(exn) => {
19938 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.getConfig", exn);
19939 crate::services::meta_service::GetConfigExn::ApplicationException(aexn)
19940 }
19941 };
19942
19943 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
19944 "getConfig",
19945 METHOD_NAME.as_cstr(),
19946 _seqid,
19947 req_ctxt,
19948 &mut ctx_stack,
19949 res
19950 )?;
19951 reply_state.lock().unwrap().send_reply(env);
19952 Ok(())
19953 }
19954
19955 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.setConfig"))]
19956 async fn handle_setConfig<'a>(
19957 &'a self,
19958 p: &'a mut P::Deserializer,
19959 req_ctxt: &R,
19960 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
19961 _seqid: ::std::primitive::u32,
19962 ) -> ::anyhow::Result<()> {
19963 use ::const_cstr::const_cstr;
19964 use ::futures::FutureExt as _;
19965
19966 const_cstr! {
19967 SERVICE_NAME = "MetaService";
19968 METHOD_NAME = "MetaService.setConfig";
19969 }
19970 let mut ctx_stack = req_ctxt.get_context_stack(
19971 SERVICE_NAME.as_cstr(),
19972 METHOD_NAME.as_cstr(),
19973 )?;
19974 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
19975 let _args: self::Args_MetaService_setConfig = ::fbthrift::Deserialize::read(p)?;
19976 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
19977 protocol: P::PROTOCOL_ID,
19978 method_name: METHOD_NAME.as_cstr(),
19979 buffer: ::std::marker::PhantomData, })?;
19981 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
19982
19983 let res = ::std::panic::AssertUnwindSafe(
19984 self.service.setConfig(
19985 _args.req,
19986 )
19987 )
19988 .catch_unwind()
19989 .await;
19990
19991 let res = match res {
19993 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
19994 ::tracing::info!("success");
19995 crate::services::meta_service::SetConfigExn::Success(res)
19996 }
19997 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::SetConfigExn::Success(_))) => {
19998 panic!(
19999 "{} attempted to return success via error",
20000 "setConfig",
20001 )
20002 }
20003 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
20004 ::tracing::error!(exception = ?exn);
20005 exn
20006 }
20007 ::std::result::Result::Err(exn) => {
20008 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.setConfig", exn);
20009 crate::services::meta_service::SetConfigExn::ApplicationException(aexn)
20010 }
20011 };
20012
20013 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
20014 "setConfig",
20015 METHOD_NAME.as_cstr(),
20016 _seqid,
20017 req_ctxt,
20018 &mut ctx_stack,
20019 res
20020 )?;
20021 reply_state.lock().unwrap().send_reply(env);
20022 Ok(())
20023 }
20024
20025 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listConfigs"))]
20026 async fn handle_listConfigs<'a>(
20027 &'a self,
20028 p: &'a mut P::Deserializer,
20029 req_ctxt: &R,
20030 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
20031 _seqid: ::std::primitive::u32,
20032 ) -> ::anyhow::Result<()> {
20033 use ::const_cstr::const_cstr;
20034 use ::futures::FutureExt as _;
20035
20036 const_cstr! {
20037 SERVICE_NAME = "MetaService";
20038 METHOD_NAME = "MetaService.listConfigs";
20039 }
20040 let mut ctx_stack = req_ctxt.get_context_stack(
20041 SERVICE_NAME.as_cstr(),
20042 METHOD_NAME.as_cstr(),
20043 )?;
20044 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
20045 let _args: self::Args_MetaService_listConfigs = ::fbthrift::Deserialize::read(p)?;
20046 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
20047 protocol: P::PROTOCOL_ID,
20048 method_name: METHOD_NAME.as_cstr(),
20049 buffer: ::std::marker::PhantomData, })?;
20051 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
20052
20053 let res = ::std::panic::AssertUnwindSafe(
20054 self.service.listConfigs(
20055 _args.req,
20056 )
20057 )
20058 .catch_unwind()
20059 .await;
20060
20061 let res = match res {
20063 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
20064 ::tracing::info!("success");
20065 crate::services::meta_service::ListConfigsExn::Success(res)
20066 }
20067 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListConfigsExn::Success(_))) => {
20068 panic!(
20069 "{} attempted to return success via error",
20070 "listConfigs",
20071 )
20072 }
20073 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
20074 ::tracing::error!(exception = ?exn);
20075 exn
20076 }
20077 ::std::result::Result::Err(exn) => {
20078 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listConfigs", exn);
20079 crate::services::meta_service::ListConfigsExn::ApplicationException(aexn)
20080 }
20081 };
20082
20083 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
20084 "listConfigs",
20085 METHOD_NAME.as_cstr(),
20086 _seqid,
20087 req_ctxt,
20088 &mut ctx_stack,
20089 res
20090 )?;
20091 reply_state.lock().unwrap().send_reply(env);
20092 Ok(())
20093 }
20094
20095 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.createSnapshot"))]
20096 async fn handle_createSnapshot<'a>(
20097 &'a self,
20098 p: &'a mut P::Deserializer,
20099 req_ctxt: &R,
20100 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
20101 _seqid: ::std::primitive::u32,
20102 ) -> ::anyhow::Result<()> {
20103 use ::const_cstr::const_cstr;
20104 use ::futures::FutureExt as _;
20105
20106 const_cstr! {
20107 SERVICE_NAME = "MetaService";
20108 METHOD_NAME = "MetaService.createSnapshot";
20109 }
20110 let mut ctx_stack = req_ctxt.get_context_stack(
20111 SERVICE_NAME.as_cstr(),
20112 METHOD_NAME.as_cstr(),
20113 )?;
20114 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
20115 let _args: self::Args_MetaService_createSnapshot = ::fbthrift::Deserialize::read(p)?;
20116 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
20117 protocol: P::PROTOCOL_ID,
20118 method_name: METHOD_NAME.as_cstr(),
20119 buffer: ::std::marker::PhantomData, })?;
20121 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
20122
20123 let res = ::std::panic::AssertUnwindSafe(
20124 self.service.createSnapshot(
20125 _args.req,
20126 )
20127 )
20128 .catch_unwind()
20129 .await;
20130
20131 let res = match res {
20133 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
20134 ::tracing::info!("success");
20135 crate::services::meta_service::CreateSnapshotExn::Success(res)
20136 }
20137 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::CreateSnapshotExn::Success(_))) => {
20138 panic!(
20139 "{} attempted to return success via error",
20140 "createSnapshot",
20141 )
20142 }
20143 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
20144 ::tracing::error!(exception = ?exn);
20145 exn
20146 }
20147 ::std::result::Result::Err(exn) => {
20148 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.createSnapshot", exn);
20149 crate::services::meta_service::CreateSnapshotExn::ApplicationException(aexn)
20150 }
20151 };
20152
20153 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
20154 "createSnapshot",
20155 METHOD_NAME.as_cstr(),
20156 _seqid,
20157 req_ctxt,
20158 &mut ctx_stack,
20159 res
20160 )?;
20161 reply_state.lock().unwrap().send_reply(env);
20162 Ok(())
20163 }
20164
20165 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.dropSnapshot"))]
20166 async fn handle_dropSnapshot<'a>(
20167 &'a self,
20168 p: &'a mut P::Deserializer,
20169 req_ctxt: &R,
20170 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
20171 _seqid: ::std::primitive::u32,
20172 ) -> ::anyhow::Result<()> {
20173 use ::const_cstr::const_cstr;
20174 use ::futures::FutureExt as _;
20175
20176 const_cstr! {
20177 SERVICE_NAME = "MetaService";
20178 METHOD_NAME = "MetaService.dropSnapshot";
20179 }
20180 let mut ctx_stack = req_ctxt.get_context_stack(
20181 SERVICE_NAME.as_cstr(),
20182 METHOD_NAME.as_cstr(),
20183 )?;
20184 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
20185 let _args: self::Args_MetaService_dropSnapshot = ::fbthrift::Deserialize::read(p)?;
20186 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
20187 protocol: P::PROTOCOL_ID,
20188 method_name: METHOD_NAME.as_cstr(),
20189 buffer: ::std::marker::PhantomData, })?;
20191 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
20192
20193 let res = ::std::panic::AssertUnwindSafe(
20194 self.service.dropSnapshot(
20195 _args.req,
20196 )
20197 )
20198 .catch_unwind()
20199 .await;
20200
20201 let res = match res {
20203 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
20204 ::tracing::info!("success");
20205 crate::services::meta_service::DropSnapshotExn::Success(res)
20206 }
20207 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::DropSnapshotExn::Success(_))) => {
20208 panic!(
20209 "{} attempted to return success via error",
20210 "dropSnapshot",
20211 )
20212 }
20213 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
20214 ::tracing::error!(exception = ?exn);
20215 exn
20216 }
20217 ::std::result::Result::Err(exn) => {
20218 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.dropSnapshot", exn);
20219 crate::services::meta_service::DropSnapshotExn::ApplicationException(aexn)
20220 }
20221 };
20222
20223 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
20224 "dropSnapshot",
20225 METHOD_NAME.as_cstr(),
20226 _seqid,
20227 req_ctxt,
20228 &mut ctx_stack,
20229 res
20230 )?;
20231 reply_state.lock().unwrap().send_reply(env);
20232 Ok(())
20233 }
20234
20235 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.listSnapshots"))]
20236 async fn handle_listSnapshots<'a>(
20237 &'a self,
20238 p: &'a mut P::Deserializer,
20239 req_ctxt: &R,
20240 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
20241 _seqid: ::std::primitive::u32,
20242 ) -> ::anyhow::Result<()> {
20243 use ::const_cstr::const_cstr;
20244 use ::futures::FutureExt as _;
20245
20246 const_cstr! {
20247 SERVICE_NAME = "MetaService";
20248 METHOD_NAME = "MetaService.listSnapshots";
20249 }
20250 let mut ctx_stack = req_ctxt.get_context_stack(
20251 SERVICE_NAME.as_cstr(),
20252 METHOD_NAME.as_cstr(),
20253 )?;
20254 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
20255 let _args: self::Args_MetaService_listSnapshots = ::fbthrift::Deserialize::read(p)?;
20256 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
20257 protocol: P::PROTOCOL_ID,
20258 method_name: METHOD_NAME.as_cstr(),
20259 buffer: ::std::marker::PhantomData, })?;
20261 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
20262
20263 let res = ::std::panic::AssertUnwindSafe(
20264 self.service.listSnapshots(
20265 _args.req,
20266 )
20267 )
20268 .catch_unwind()
20269 .await;
20270
20271 let res = match res {
20273 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
20274 ::tracing::info!("success");
20275 crate::services::meta_service::ListSnapshotsExn::Success(res)
20276 }
20277 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::ListSnapshotsExn::Success(_))) => {
20278 panic!(
20279 "{} attempted to return success via error",
20280 "listSnapshots",
20281 )
20282 }
20283 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
20284 ::tracing::error!(exception = ?exn);
20285 exn
20286 }
20287 ::std::result::Result::Err(exn) => {
20288 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.listSnapshots", exn);
20289 crate::services::meta_service::ListSnapshotsExn::ApplicationException(aexn)
20290 }
20291 };
20292
20293 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
20294 "listSnapshots",
20295 METHOD_NAME.as_cstr(),
20296 _seqid,
20297 req_ctxt,
20298 &mut ctx_stack,
20299 res
20300 )?;
20301 reply_state.lock().unwrap().send_reply(env);
20302 Ok(())
20303 }
20304
20305 #[::tracing::instrument(skip_all, name = "handler", fields(method = "MetaService.runAdminJob"))]
20306 async fn handle_runAdminJob<'a>(
20307 &'a self,
20308 p: &'a mut P::Deserializer,
20309 req_ctxt: &R,
20310 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
20311 _seqid: ::std::primitive::u32,
20312 ) -> ::anyhow::Result<()> {
20313 use ::const_cstr::const_cstr;
20314 use ::futures::FutureExt as _;
20315
20316 const_cstr! {
20317 SERVICE_NAME = "MetaService";
20318 METHOD_NAME = "MetaService.runAdminJob";
20319 }
20320 let mut ctx_stack = req_ctxt.get_context_stack(
20321 SERVICE_NAME.as_cstr(),
20322 METHOD_NAME.as_cstr(),
20323 )?;
20324 ::fbthrift::ContextStack::pre_read(&mut ctx_stack)?;
20325 let _args: self::Args_MetaService_runAdminJob = ::fbthrift::Deserialize::read(p)?;
20326 ::fbthrift::ContextStack::on_read_data(&mut ctx_stack, &::fbthrift::SerializedMessage {
20327 protocol: P::PROTOCOL_ID,
20328 method_name: METHOD_NAME.as_cstr(),
20329 buffer: ::std::marker::PhantomData, })?;
20331 ::fbthrift::ContextStack::post_read(&mut ctx_stack, 0)?;
20332
20333 let res = ::std::panic::AssertUnwindSafe(
20334 self.service.runAdminJob(
20335 _args.req,
20336 )
20337 )
20338 .catch_unwind()
20339 .await;
20340
20341 let res = match res {
20343 ::std::result::Result::Ok(::std::result::Result::Ok(res)) => {
20344 ::tracing::info!("success");
20345 crate::services::meta_service::RunAdminJobExn::Success(res)
20346 }
20347 ::std::result::Result::Ok(::std::result::Result::Err(crate::services::meta_service::RunAdminJobExn::Success(_))) => {
20348 panic!(
20349 "{} attempted to return success via error",
20350 "runAdminJob",
20351 )
20352 }
20353 ::std::result::Result::Ok(::std::result::Result::Err(exn)) => {
20354 ::tracing::error!(exception = ?exn);
20355 exn
20356 }
20357 ::std::result::Result::Err(exn) => {
20358 let aexn = ::fbthrift::ApplicationException::handler_panic("MetaService.runAdminJob", exn);
20359 crate::services::meta_service::RunAdminJobExn::ApplicationException(aexn)
20360 }
20361 };
20362
20363 let env = ::fbthrift::help::serialize_result_envelope::<P, R, _>(
20364 "runAdminJob",
20365 METHOD_NAME.as_cstr(),
20366 _seqid,
20367 req_ctxt,
20368 &mut ctx_stack,
20369 res
20370 )?;
20371 reply_state.lock().unwrap().send_reply(env);
20372 Ok(())
20373 }
20374 }
20375
20376 #[::async_trait::async_trait]
20377 impl<P, H, R, RS> ::fbthrift::ServiceProcessor<P> for MetaServiceProcessor<P, H, R, RS>
20378 where
20379 P: ::fbthrift::Protocol + ::std::marker::Send + ::std::marker::Sync + 'static,
20380 P::Deserializer: ::std::marker::Send,
20381 H: MetaService,
20382 P::Frame: ::std::marker::Send + 'static,
20383 R: ::fbthrift::RequestContext<Name = ::std::ffi::CStr> + ::std::marker::Send + ::std::marker::Sync + 'static,
20384 <R as ::fbthrift::RequestContext>::ContextStack: ::fbthrift::ContextStack<Name = R::Name, Buffer = ::fbthrift::ProtocolDecoded<P>>
20385 + ::std::marker::Send + ::std::marker::Sync + 'static,
20386 RS: ::fbthrift::ReplyState<P::Frame, RequestContext = R> + ::std::marker::Send + ::std::marker::Sync + 'static
20387 {
20388 type RequestContext = R;
20389 type ReplyState = RS;
20390
20391 #[inline]
20392 fn method_idx(&self, name: &[::std::primitive::u8]) -> ::std::result::Result<::std::primitive::usize, ::fbthrift::ApplicationException> {
20393 match name {
20394 b"createSpace" => ::std::result::Result::Ok(0usize),
20395 b"dropSpace" => ::std::result::Result::Ok(1usize),
20396 b"getSpace" => ::std::result::Result::Ok(2usize),
20397 b"listSpaces" => ::std::result::Result::Ok(3usize),
20398 b"createTag" => ::std::result::Result::Ok(4usize),
20399 b"alterTag" => ::std::result::Result::Ok(5usize),
20400 b"dropTag" => ::std::result::Result::Ok(6usize),
20401 b"getTag" => ::std::result::Result::Ok(7usize),
20402 b"listTags" => ::std::result::Result::Ok(8usize),
20403 b"createEdge" => ::std::result::Result::Ok(9usize),
20404 b"alterEdge" => ::std::result::Result::Ok(10usize),
20405 b"dropEdge" => ::std::result::Result::Ok(11usize),
20406 b"getEdge" => ::std::result::Result::Ok(12usize),
20407 b"listEdges" => ::std::result::Result::Ok(13usize),
20408 b"listHosts" => ::std::result::Result::Ok(14usize),
20409 b"getPartsAlloc" => ::std::result::Result::Ok(15usize),
20410 b"listParts" => ::std::result::Result::Ok(16usize),
20411 b"multiPut" => ::std::result::Result::Ok(17usize),
20412 b"get" => ::std::result::Result::Ok(18usize),
20413 b"multiGet" => ::std::result::Result::Ok(19usize),
20414 b"remove" => ::std::result::Result::Ok(20usize),
20415 b"removeRange" => ::std::result::Result::Ok(21usize),
20416 b"scan" => ::std::result::Result::Ok(22usize),
20417 b"createTagIndex" => ::std::result::Result::Ok(23usize),
20418 b"dropTagIndex" => ::std::result::Result::Ok(24usize),
20419 b"getTagIndex" => ::std::result::Result::Ok(25usize),
20420 b"listTagIndexes" => ::std::result::Result::Ok(26usize),
20421 b"rebuildTagIndex" => ::std::result::Result::Ok(27usize),
20422 b"listTagIndexStatus" => ::std::result::Result::Ok(28usize),
20423 b"createEdgeIndex" => ::std::result::Result::Ok(29usize),
20424 b"dropEdgeIndex" => ::std::result::Result::Ok(30usize),
20425 b"getEdgeIndex" => ::std::result::Result::Ok(31usize),
20426 b"listEdgeIndexes" => ::std::result::Result::Ok(32usize),
20427 b"rebuildEdgeIndex" => ::std::result::Result::Ok(33usize),
20428 b"listEdgeIndexStatus" => ::std::result::Result::Ok(34usize),
20429 b"createUser" => ::std::result::Result::Ok(35usize),
20430 b"dropUser" => ::std::result::Result::Ok(36usize),
20431 b"alterUser" => ::std::result::Result::Ok(37usize),
20432 b"grantRole" => ::std::result::Result::Ok(38usize),
20433 b"revokeRole" => ::std::result::Result::Ok(39usize),
20434 b"listUsers" => ::std::result::Result::Ok(40usize),
20435 b"listRoles" => ::std::result::Result::Ok(41usize),
20436 b"getUserRoles" => ::std::result::Result::Ok(42usize),
20437 b"changePassword" => ::std::result::Result::Ok(43usize),
20438 b"heartBeat" => ::std::result::Result::Ok(44usize),
20439 b"balance" => ::std::result::Result::Ok(45usize),
20440 b"leaderBalance" => ::std::result::Result::Ok(46usize),
20441 b"regConfig" => ::std::result::Result::Ok(47usize),
20442 b"getConfig" => ::std::result::Result::Ok(48usize),
20443 b"setConfig" => ::std::result::Result::Ok(49usize),
20444 b"listConfigs" => ::std::result::Result::Ok(50usize),
20445 b"createSnapshot" => ::std::result::Result::Ok(51usize),
20446 b"dropSnapshot" => ::std::result::Result::Ok(52usize),
20447 b"listSnapshots" => ::std::result::Result::Ok(53usize),
20448 b"runAdminJob" => ::std::result::Result::Ok(54usize),
20449 _ => ::std::result::Result::Err(::fbthrift::ApplicationException::unknown_method()),
20450 }
20451 }
20452
20453 #[allow(clippy::match_single_binding)]
20454 async fn handle_method(
20455 &self,
20456 idx: ::std::primitive::usize,
20457 _p: &mut P::Deserializer,
20458 _r: &R,
20459 _reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
20460 _seqid: ::std::primitive::u32,
20461 ) -> ::anyhow::Result<()> {
20462 match idx {
20463 0usize => {
20464 self.handle_createSpace(_p, _r, _reply_state, _seqid).await
20465 }
20466 1usize => {
20467 self.handle_dropSpace(_p, _r, _reply_state, _seqid).await
20468 }
20469 2usize => {
20470 self.handle_getSpace(_p, _r, _reply_state, _seqid).await
20471 }
20472 3usize => {
20473 self.handle_listSpaces(_p, _r, _reply_state, _seqid).await
20474 }
20475 4usize => {
20476 self.handle_createTag(_p, _r, _reply_state, _seqid).await
20477 }
20478 5usize => {
20479 self.handle_alterTag(_p, _r, _reply_state, _seqid).await
20480 }
20481 6usize => {
20482 self.handle_dropTag(_p, _r, _reply_state, _seqid).await
20483 }
20484 7usize => {
20485 self.handle_getTag(_p, _r, _reply_state, _seqid).await
20486 }
20487 8usize => {
20488 self.handle_listTags(_p, _r, _reply_state, _seqid).await
20489 }
20490 9usize => {
20491 self.handle_createEdge(_p, _r, _reply_state, _seqid).await
20492 }
20493 10usize => {
20494 self.handle_alterEdge(_p, _r, _reply_state, _seqid).await
20495 }
20496 11usize => {
20497 self.handle_dropEdge(_p, _r, _reply_state, _seqid).await
20498 }
20499 12usize => {
20500 self.handle_getEdge(_p, _r, _reply_state, _seqid).await
20501 }
20502 13usize => {
20503 self.handle_listEdges(_p, _r, _reply_state, _seqid).await
20504 }
20505 14usize => {
20506 self.handle_listHosts(_p, _r, _reply_state, _seqid).await
20507 }
20508 15usize => {
20509 self.handle_getPartsAlloc(_p, _r, _reply_state, _seqid).await
20510 }
20511 16usize => {
20512 self.handle_listParts(_p, _r, _reply_state, _seqid).await
20513 }
20514 17usize => {
20515 self.handle_multiPut(_p, _r, _reply_state, _seqid).await
20516 }
20517 18usize => {
20518 self.handle_get(_p, _r, _reply_state, _seqid).await
20519 }
20520 19usize => {
20521 self.handle_multiGet(_p, _r, _reply_state, _seqid).await
20522 }
20523 20usize => {
20524 self.handle_remove(_p, _r, _reply_state, _seqid).await
20525 }
20526 21usize => {
20527 self.handle_removeRange(_p, _r, _reply_state, _seqid).await
20528 }
20529 22usize => {
20530 self.handle_scan(_p, _r, _reply_state, _seqid).await
20531 }
20532 23usize => {
20533 self.handle_createTagIndex(_p, _r, _reply_state, _seqid).await
20534 }
20535 24usize => {
20536 self.handle_dropTagIndex(_p, _r, _reply_state, _seqid).await
20537 }
20538 25usize => {
20539 self.handle_getTagIndex(_p, _r, _reply_state, _seqid).await
20540 }
20541 26usize => {
20542 self.handle_listTagIndexes(_p, _r, _reply_state, _seqid).await
20543 }
20544 27usize => {
20545 self.handle_rebuildTagIndex(_p, _r, _reply_state, _seqid).await
20546 }
20547 28usize => {
20548 self.handle_listTagIndexStatus(_p, _r, _reply_state, _seqid).await
20549 }
20550 29usize => {
20551 self.handle_createEdgeIndex(_p, _r, _reply_state, _seqid).await
20552 }
20553 30usize => {
20554 self.handle_dropEdgeIndex(_p, _r, _reply_state, _seqid).await
20555 }
20556 31usize => {
20557 self.handle_getEdgeIndex(_p, _r, _reply_state, _seqid).await
20558 }
20559 32usize => {
20560 self.handle_listEdgeIndexes(_p, _r, _reply_state, _seqid).await
20561 }
20562 33usize => {
20563 self.handle_rebuildEdgeIndex(_p, _r, _reply_state, _seqid).await
20564 }
20565 34usize => {
20566 self.handle_listEdgeIndexStatus(_p, _r, _reply_state, _seqid).await
20567 }
20568 35usize => {
20569 self.handle_createUser(_p, _r, _reply_state, _seqid).await
20570 }
20571 36usize => {
20572 self.handle_dropUser(_p, _r, _reply_state, _seqid).await
20573 }
20574 37usize => {
20575 self.handle_alterUser(_p, _r, _reply_state, _seqid).await
20576 }
20577 38usize => {
20578 self.handle_grantRole(_p, _r, _reply_state, _seqid).await
20579 }
20580 39usize => {
20581 self.handle_revokeRole(_p, _r, _reply_state, _seqid).await
20582 }
20583 40usize => {
20584 self.handle_listUsers(_p, _r, _reply_state, _seqid).await
20585 }
20586 41usize => {
20587 self.handle_listRoles(_p, _r, _reply_state, _seqid).await
20588 }
20589 42usize => {
20590 self.handle_getUserRoles(_p, _r, _reply_state, _seqid).await
20591 }
20592 43usize => {
20593 self.handle_changePassword(_p, _r, _reply_state, _seqid).await
20594 }
20595 44usize => {
20596 self.handle_heartBeat(_p, _r, _reply_state, _seqid).await
20597 }
20598 45usize => {
20599 self.handle_balance(_p, _r, _reply_state, _seqid).await
20600 }
20601 46usize => {
20602 self.handle_leaderBalance(_p, _r, _reply_state, _seqid).await
20603 }
20604 47usize => {
20605 self.handle_regConfig(_p, _r, _reply_state, _seqid).await
20606 }
20607 48usize => {
20608 self.handle_getConfig(_p, _r, _reply_state, _seqid).await
20609 }
20610 49usize => {
20611 self.handle_setConfig(_p, _r, _reply_state, _seqid).await
20612 }
20613 50usize => {
20614 self.handle_listConfigs(_p, _r, _reply_state, _seqid).await
20615 }
20616 51usize => {
20617 self.handle_createSnapshot(_p, _r, _reply_state, _seqid).await
20618 }
20619 52usize => {
20620 self.handle_dropSnapshot(_p, _r, _reply_state, _seqid).await
20621 }
20622 53usize => {
20623 self.handle_listSnapshots(_p, _r, _reply_state, _seqid).await
20624 }
20625 54usize => {
20626 self.handle_runAdminJob(_p, _r, _reply_state, _seqid).await
20627 }
20628 bad => panic!(
20629 "{}: unexpected method idx {}",
20630 "MetaServiceProcessor",
20631 bad
20632 ),
20633 }
20634 }
20635
20636 #[allow(clippy::match_single_binding)]
20637 #[inline]
20638 fn create_interaction_idx(&self, name: &str) -> ::anyhow::Result<::std::primitive::usize> {
20639 match name {
20640 _ => ::anyhow::bail!("Unknown interaction"),
20641 }
20642 }
20643
20644 #[allow(clippy::match_single_binding)]
20645 fn handle_create_interaction(
20646 &self,
20647 idx: ::std::primitive::usize,
20648 ) -> ::anyhow::Result<
20649 ::std::sync::Arc<dyn ::fbthrift::ThriftService<P::Frame, Handler = (), RequestContext = Self::RequestContext, ReplyState = Self::ReplyState> + ::std::marker::Send + 'static>
20650 > {
20651 match idx {
20652 bad => panic!(
20653 "{}: unexpected method idx {}",
20654 "MetaServiceProcessor",
20655 bad
20656 ),
20657 }
20658 }
20659 }
20660
20661 #[::async_trait::async_trait]
20662 impl<P, H, R, RS> ::fbthrift::ThriftService<P::Frame> for MetaServiceProcessor<P, H, R, RS>
20663 where
20664 P: ::fbthrift::Protocol + ::std::marker::Send + ::std::marker::Sync + 'static,
20665 P::Deserializer: ::std::marker::Send,
20666 P::Frame: ::std::marker::Send + 'static,
20667 H: MetaService,
20668 R: ::fbthrift::RequestContext<Name = ::std::ffi::CStr> + ::std::marker::Send + ::std::marker::Sync + 'static,
20669 <R as ::fbthrift::RequestContext>::ContextStack: ::fbthrift::ContextStack<Name = R::Name, Buffer = ::fbthrift::ProtocolDecoded<P>>
20670 + ::std::marker::Send + ::std::marker::Sync + 'static,
20671 RS: ::fbthrift::ReplyState<P::Frame, RequestContext = R> + ::std::marker::Send + ::std::marker::Sync + 'static
20672 {
20673 type Handler = H;
20674 type RequestContext = R;
20675 type ReplyState = RS;
20676
20677 #[tracing::instrument(level="trace", skip_all, fields(service = "MetaService"))]
20678 async fn call(
20679 &self,
20680 req: ::fbthrift::ProtocolDecoded<P>,
20681 req_ctxt: &R,
20682 reply_state: ::std::sync::Arc<::std::sync::Mutex<RS>>,
20683 ) -> ::anyhow::Result<()> {
20684 use ::fbthrift::{BufExt as _, ProtocolReader as _, ServiceProcessor as _};
20685 let mut p = P::deserializer(req);
20686 let (idx, mty, seqid) = p.read_message_begin(|name| self.method_idx(name))?;
20687 if mty != ::fbthrift::MessageType::Call {
20688 return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
20689 ::fbthrift::ApplicationExceptionErrorCode::InvalidMessageType,
20690 format!("message type {:?} not handled", mty)
20691 )));
20692 }
20693 let idx = match idx {
20694 ::std::result::Result::Ok(idx) => idx,
20695 ::std::result::Result::Err(_) => {
20696 let cur = P::into_buffer(p).reset();
20697 return self.supa.call(cur, req_ctxt, reply_state).await;
20698 }
20699 };
20700 self.handle_method(idx, &mut p, req_ctxt, reply_state, seqid).await?;
20701 p.read_message_end()?;
20702
20703 Ok(())
20704 }
20705
20706 fn create_interaction(
20707 &self,
20708 name: &str,
20709 ) -> ::anyhow::Result<
20710 ::std::sync::Arc<dyn ::fbthrift::ThriftService<P::Frame, Handler = (), RequestContext = R, ReplyState = RS> + ::std::marker::Send + 'static>
20711 > {
20712 use ::fbthrift::{ServiceProcessor as _};
20713 let idx = self.create_interaction_idx(name);
20714 let idx = match idx {
20715 ::anyhow::Result::Ok(idx) => idx,
20716 ::anyhow::Result::Err(_) => {
20717 return self.supa.create_interaction(name);
20718 }
20719 };
20720 self.handle_create_interaction(idx)
20721 }
20722
20723 fn get_method_names(&self) -> &'static [&'static str] {
20724 &[
20725 "createSpace",
20727 "dropSpace",
20728 "getSpace",
20729 "listSpaces",
20730 "createTag",
20731 "alterTag",
20732 "dropTag",
20733 "getTag",
20734 "listTags",
20735 "createEdge",
20736 "alterEdge",
20737 "dropEdge",
20738 "getEdge",
20739 "listEdges",
20740 "listHosts",
20741 "getPartsAlloc",
20742 "listParts",
20743 "multiPut",
20744 "get",
20745 "multiGet",
20746 "remove",
20747 "removeRange",
20748 "scan",
20749 "createTagIndex",
20750 "dropTagIndex",
20751 "getTagIndex",
20752 "listTagIndexes",
20753 "rebuildTagIndex",
20754 "listTagIndexStatus",
20755 "createEdgeIndex",
20756 "dropEdgeIndex",
20757 "getEdgeIndex",
20758 "listEdgeIndexes",
20759 "rebuildEdgeIndex",
20760 "listEdgeIndexStatus",
20761 "createUser",
20762 "dropUser",
20763 "alterUser",
20764 "grantRole",
20765 "revokeRole",
20766 "listUsers",
20767 "listRoles",
20768 "getUserRoles",
20769 "changePassword",
20770 "heartBeat",
20771 "balance",
20772 "leaderBalance",
20773 "regConfig",
20774 "getConfig",
20775 "setConfig",
20776 "listConfigs",
20777 "createSnapshot",
20778 "dropSnapshot",
20779 "listSnapshots",
20780 "runAdminJob",
20781 ]
20782 }
20783 }
20784
20785 #[::tracing::instrument(level="debug", skip_all, fields(proto = ?proto))]
20790 pub fn make_MetaService_server<F, H, R, RS>(
20791 proto: ::fbthrift::ProtocolID,
20792 handler: H,
20793 ) -> ::std::result::Result<::std::boxed::Box<dyn ::fbthrift::ThriftService<F, Handler = H, RequestContext = R, ReplyState = RS> + ::std::marker::Send + 'static>, ::fbthrift::ApplicationException>
20794 where
20795 F: ::fbthrift::Framing + ::std::marker::Send + ::std::marker::Sync + 'static,
20796 H: MetaService,
20797 R: ::fbthrift::RequestContext<Name = ::std::ffi::CStr> + ::std::marker::Send + ::std::marker::Sync + 'static,
20798 <R as ::fbthrift::RequestContext>::ContextStack: ::fbthrift::ContextStack<Name = R::Name, Buffer = F::DecBuf> + ::std::marker::Send + ::std::marker::Sync + 'static,
20799 RS: ::fbthrift::ReplyState<F, RequestContext = R> + ::std::marker::Send + ::std::marker::Sync + 'static
20800 {
20801 match proto {
20802 ::fbthrift::ProtocolID::BinaryProtocol => {
20803 ::std::result::Result::Ok(::std::boxed::Box::new(MetaServiceProcessor::<::fbthrift::BinaryProtocol<F>, H, R, RS>::new(handler)))
20804 }
20805 ::fbthrift::ProtocolID::CompactProtocol => {
20806 ::std::result::Result::Ok(::std::boxed::Box::new(MetaServiceProcessor::<::fbthrift::CompactProtocol<F>, H, R, RS>::new(handler)))
20807 }
20808 bad => {
20809 ::tracing::error!(method = "MetaService.", invalid_protocol = ?bad);
20810 ::std::result::Result::Err(::fbthrift::ApplicationException::invalid_protocol(bad))
20811 }
20812 }
20813 }
20814}
20815
20816pub mod mock {
20910 pub struct MetaService<'mock> {
20911 pub createSpace: r#impl::meta_service::createSpace<'mock>,
20912 pub dropSpace: r#impl::meta_service::dropSpace<'mock>,
20913 pub getSpace: r#impl::meta_service::getSpace<'mock>,
20914 pub listSpaces: r#impl::meta_service::listSpaces<'mock>,
20915 pub createTag: r#impl::meta_service::createTag<'mock>,
20916 pub alterTag: r#impl::meta_service::alterTag<'mock>,
20917 pub dropTag: r#impl::meta_service::dropTag<'mock>,
20918 pub getTag: r#impl::meta_service::getTag<'mock>,
20919 pub listTags: r#impl::meta_service::listTags<'mock>,
20920 pub createEdge: r#impl::meta_service::createEdge<'mock>,
20921 pub alterEdge: r#impl::meta_service::alterEdge<'mock>,
20922 pub dropEdge: r#impl::meta_service::dropEdge<'mock>,
20923 pub getEdge: r#impl::meta_service::getEdge<'mock>,
20924 pub listEdges: r#impl::meta_service::listEdges<'mock>,
20925 pub listHosts: r#impl::meta_service::listHosts<'mock>,
20926 pub getPartsAlloc: r#impl::meta_service::getPartsAlloc<'mock>,
20927 pub listParts: r#impl::meta_service::listParts<'mock>,
20928 pub multiPut: r#impl::meta_service::multiPut<'mock>,
20929 pub get: r#impl::meta_service::get<'mock>,
20930 pub multiGet: r#impl::meta_service::multiGet<'mock>,
20931 pub remove: r#impl::meta_service::remove<'mock>,
20932 pub removeRange: r#impl::meta_service::removeRange<'mock>,
20933 pub scan: r#impl::meta_service::scan<'mock>,
20934 pub createTagIndex: r#impl::meta_service::createTagIndex<'mock>,
20935 pub dropTagIndex: r#impl::meta_service::dropTagIndex<'mock>,
20936 pub getTagIndex: r#impl::meta_service::getTagIndex<'mock>,
20937 pub listTagIndexes: r#impl::meta_service::listTagIndexes<'mock>,
20938 pub rebuildTagIndex: r#impl::meta_service::rebuildTagIndex<'mock>,
20939 pub listTagIndexStatus: r#impl::meta_service::listTagIndexStatus<'mock>,
20940 pub createEdgeIndex: r#impl::meta_service::createEdgeIndex<'mock>,
20941 pub dropEdgeIndex: r#impl::meta_service::dropEdgeIndex<'mock>,
20942 pub getEdgeIndex: r#impl::meta_service::getEdgeIndex<'mock>,
20943 pub listEdgeIndexes: r#impl::meta_service::listEdgeIndexes<'mock>,
20944 pub rebuildEdgeIndex: r#impl::meta_service::rebuildEdgeIndex<'mock>,
20945 pub listEdgeIndexStatus: r#impl::meta_service::listEdgeIndexStatus<'mock>,
20946 pub createUser: r#impl::meta_service::createUser<'mock>,
20947 pub dropUser: r#impl::meta_service::dropUser<'mock>,
20948 pub alterUser: r#impl::meta_service::alterUser<'mock>,
20949 pub grantRole: r#impl::meta_service::grantRole<'mock>,
20950 pub revokeRole: r#impl::meta_service::revokeRole<'mock>,
20951 pub listUsers: r#impl::meta_service::listUsers<'mock>,
20952 pub listRoles: r#impl::meta_service::listRoles<'mock>,
20953 pub getUserRoles: r#impl::meta_service::getUserRoles<'mock>,
20954 pub changePassword: r#impl::meta_service::changePassword<'mock>,
20955 pub heartBeat: r#impl::meta_service::heartBeat<'mock>,
20956 pub balance: r#impl::meta_service::balance<'mock>,
20957 pub leaderBalance: r#impl::meta_service::leaderBalance<'mock>,
20958 pub regConfig: r#impl::meta_service::regConfig<'mock>,
20959 pub getConfig: r#impl::meta_service::getConfig<'mock>,
20960 pub setConfig: r#impl::meta_service::setConfig<'mock>,
20961 pub listConfigs: r#impl::meta_service::listConfigs<'mock>,
20962 pub createSnapshot: r#impl::meta_service::createSnapshot<'mock>,
20963 pub dropSnapshot: r#impl::meta_service::dropSnapshot<'mock>,
20964 pub listSnapshots: r#impl::meta_service::listSnapshots<'mock>,
20965 pub runAdminJob: r#impl::meta_service::runAdminJob<'mock>,
20966 _marker: ::std::marker::PhantomData<&'mock ()>,
20967 }
20968
20969 impl dyn super::client::MetaService {
20970 pub fn mock<'mock>() -> MetaService<'mock> {
20971 MetaService {
20972 createSpace: r#impl::meta_service::createSpace::unimplemented(),
20973 dropSpace: r#impl::meta_service::dropSpace::unimplemented(),
20974 getSpace: r#impl::meta_service::getSpace::unimplemented(),
20975 listSpaces: r#impl::meta_service::listSpaces::unimplemented(),
20976 createTag: r#impl::meta_service::createTag::unimplemented(),
20977 alterTag: r#impl::meta_service::alterTag::unimplemented(),
20978 dropTag: r#impl::meta_service::dropTag::unimplemented(),
20979 getTag: r#impl::meta_service::getTag::unimplemented(),
20980 listTags: r#impl::meta_service::listTags::unimplemented(),
20981 createEdge: r#impl::meta_service::createEdge::unimplemented(),
20982 alterEdge: r#impl::meta_service::alterEdge::unimplemented(),
20983 dropEdge: r#impl::meta_service::dropEdge::unimplemented(),
20984 getEdge: r#impl::meta_service::getEdge::unimplemented(),
20985 listEdges: r#impl::meta_service::listEdges::unimplemented(),
20986 listHosts: r#impl::meta_service::listHosts::unimplemented(),
20987 getPartsAlloc: r#impl::meta_service::getPartsAlloc::unimplemented(),
20988 listParts: r#impl::meta_service::listParts::unimplemented(),
20989 multiPut: r#impl::meta_service::multiPut::unimplemented(),
20990 get: r#impl::meta_service::get::unimplemented(),
20991 multiGet: r#impl::meta_service::multiGet::unimplemented(),
20992 remove: r#impl::meta_service::remove::unimplemented(),
20993 removeRange: r#impl::meta_service::removeRange::unimplemented(),
20994 scan: r#impl::meta_service::scan::unimplemented(),
20995 createTagIndex: r#impl::meta_service::createTagIndex::unimplemented(),
20996 dropTagIndex: r#impl::meta_service::dropTagIndex::unimplemented(),
20997 getTagIndex: r#impl::meta_service::getTagIndex::unimplemented(),
20998 listTagIndexes: r#impl::meta_service::listTagIndexes::unimplemented(),
20999 rebuildTagIndex: r#impl::meta_service::rebuildTagIndex::unimplemented(),
21000 listTagIndexStatus: r#impl::meta_service::listTagIndexStatus::unimplemented(),
21001 createEdgeIndex: r#impl::meta_service::createEdgeIndex::unimplemented(),
21002 dropEdgeIndex: r#impl::meta_service::dropEdgeIndex::unimplemented(),
21003 getEdgeIndex: r#impl::meta_service::getEdgeIndex::unimplemented(),
21004 listEdgeIndexes: r#impl::meta_service::listEdgeIndexes::unimplemented(),
21005 rebuildEdgeIndex: r#impl::meta_service::rebuildEdgeIndex::unimplemented(),
21006 listEdgeIndexStatus: r#impl::meta_service::listEdgeIndexStatus::unimplemented(),
21007 createUser: r#impl::meta_service::createUser::unimplemented(),
21008 dropUser: r#impl::meta_service::dropUser::unimplemented(),
21009 alterUser: r#impl::meta_service::alterUser::unimplemented(),
21010 grantRole: r#impl::meta_service::grantRole::unimplemented(),
21011 revokeRole: r#impl::meta_service::revokeRole::unimplemented(),
21012 listUsers: r#impl::meta_service::listUsers::unimplemented(),
21013 listRoles: r#impl::meta_service::listRoles::unimplemented(),
21014 getUserRoles: r#impl::meta_service::getUserRoles::unimplemented(),
21015 changePassword: r#impl::meta_service::changePassword::unimplemented(),
21016 heartBeat: r#impl::meta_service::heartBeat::unimplemented(),
21017 balance: r#impl::meta_service::balance::unimplemented(),
21018 leaderBalance: r#impl::meta_service::leaderBalance::unimplemented(),
21019 regConfig: r#impl::meta_service::regConfig::unimplemented(),
21020 getConfig: r#impl::meta_service::getConfig::unimplemented(),
21021 setConfig: r#impl::meta_service::setConfig::unimplemented(),
21022 listConfigs: r#impl::meta_service::listConfigs::unimplemented(),
21023 createSnapshot: r#impl::meta_service::createSnapshot::unimplemented(),
21024 dropSnapshot: r#impl::meta_service::dropSnapshot::unimplemented(),
21025 listSnapshots: r#impl::meta_service::listSnapshots::unimplemented(),
21026 runAdminJob: r#impl::meta_service::runAdminJob::unimplemented(),
21027 _marker: ::std::marker::PhantomData,
21028 }
21029 }
21030 }
21031
21032 impl<'mock> super::client::MetaService for MetaService<'mock> {
21033 fn createSpace(
21034 &self,
21035 arg_req: &crate::types::CreateSpaceReq,
21036 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError>> {
21037 let mut closure = self.createSpace.closure.lock().unwrap();
21038 let closure: &mut dyn ::std::ops::FnMut(crate::types::CreateSpaceReq) -> _ = &mut **closure;
21039 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21040 }
21041 fn dropSpace(
21042 &self,
21043 arg_req: &crate::types::DropSpaceReq,
21044 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError>> {
21045 let mut closure = self.dropSpace.closure.lock().unwrap();
21046 let closure: &mut dyn ::std::ops::FnMut(crate::types::DropSpaceReq) -> _ = &mut **closure;
21047 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21048 }
21049 fn getSpace(
21050 &self,
21051 arg_req: &crate::types::GetSpaceReq,
21052 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError>> {
21053 let mut closure = self.getSpace.closure.lock().unwrap();
21054 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetSpaceReq) -> _ = &mut **closure;
21055 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21056 }
21057 fn listSpaces(
21058 &self,
21059 arg_req: &crate::types::ListSpacesReq,
21060 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError>> {
21061 let mut closure = self.listSpaces.closure.lock().unwrap();
21062 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListSpacesReq) -> _ = &mut **closure;
21063 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21064 }
21065 fn createTag(
21066 &self,
21067 arg_req: &crate::types::CreateTagReq,
21068 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError>> {
21069 let mut closure = self.createTag.closure.lock().unwrap();
21070 let closure: &mut dyn ::std::ops::FnMut(crate::types::CreateTagReq) -> _ = &mut **closure;
21071 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21072 }
21073 fn alterTag(
21074 &self,
21075 arg_req: &crate::types::AlterTagReq,
21076 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError>> {
21077 let mut closure = self.alterTag.closure.lock().unwrap();
21078 let closure: &mut dyn ::std::ops::FnMut(crate::types::AlterTagReq) -> _ = &mut **closure;
21079 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21080 }
21081 fn dropTag(
21082 &self,
21083 arg_req: &crate::types::DropTagReq,
21084 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError>> {
21085 let mut closure = self.dropTag.closure.lock().unwrap();
21086 let closure: &mut dyn ::std::ops::FnMut(crate::types::DropTagReq) -> _ = &mut **closure;
21087 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21088 }
21089 fn getTag(
21090 &self,
21091 arg_req: &crate::types::GetTagReq,
21092 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError>> {
21093 let mut closure = self.getTag.closure.lock().unwrap();
21094 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetTagReq) -> _ = &mut **closure;
21095 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21096 }
21097 fn listTags(
21098 &self,
21099 arg_req: &crate::types::ListTagsReq,
21100 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError>> {
21101 let mut closure = self.listTags.closure.lock().unwrap();
21102 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListTagsReq) -> _ = &mut **closure;
21103 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21104 }
21105 fn createEdge(
21106 &self,
21107 arg_req: &crate::types::CreateEdgeReq,
21108 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError>> {
21109 let mut closure = self.createEdge.closure.lock().unwrap();
21110 let closure: &mut dyn ::std::ops::FnMut(crate::types::CreateEdgeReq) -> _ = &mut **closure;
21111 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21112 }
21113 fn alterEdge(
21114 &self,
21115 arg_req: &crate::types::AlterEdgeReq,
21116 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError>> {
21117 let mut closure = self.alterEdge.closure.lock().unwrap();
21118 let closure: &mut dyn ::std::ops::FnMut(crate::types::AlterEdgeReq) -> _ = &mut **closure;
21119 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21120 }
21121 fn dropEdge(
21122 &self,
21123 arg_req: &crate::types::DropEdgeReq,
21124 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError>> {
21125 let mut closure = self.dropEdge.closure.lock().unwrap();
21126 let closure: &mut dyn ::std::ops::FnMut(crate::types::DropEdgeReq) -> _ = &mut **closure;
21127 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21128 }
21129 fn getEdge(
21130 &self,
21131 arg_req: &crate::types::GetEdgeReq,
21132 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError>> {
21133 let mut closure = self.getEdge.closure.lock().unwrap();
21134 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetEdgeReq) -> _ = &mut **closure;
21135 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21136 }
21137 fn listEdges(
21138 &self,
21139 arg_req: &crate::types::ListEdgesReq,
21140 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError>> {
21141 let mut closure = self.listEdges.closure.lock().unwrap();
21142 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListEdgesReq) -> _ = &mut **closure;
21143 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21144 }
21145 fn listHosts(
21146 &self,
21147 arg_req: &crate::types::ListHostsReq,
21148 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError>> {
21149 let mut closure = self.listHosts.closure.lock().unwrap();
21150 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListHostsReq) -> _ = &mut **closure;
21151 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21152 }
21153 fn getPartsAlloc(
21154 &self,
21155 arg_req: &crate::types::GetPartsAllocReq,
21156 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError>> {
21157 let mut closure = self.getPartsAlloc.closure.lock().unwrap();
21158 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetPartsAllocReq) -> _ = &mut **closure;
21159 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21160 }
21161 fn listParts(
21162 &self,
21163 arg_req: &crate::types::ListPartsReq,
21164 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError>> {
21165 let mut closure = self.listParts.closure.lock().unwrap();
21166 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListPartsReq) -> _ = &mut **closure;
21167 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21168 }
21169 fn multiPut(
21170 &self,
21171 arg_req: &crate::types::MultiPutReq,
21172 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError>> {
21173 let mut closure = self.multiPut.closure.lock().unwrap();
21174 let closure: &mut dyn ::std::ops::FnMut(crate::types::MultiPutReq) -> _ = &mut **closure;
21175 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21176 }
21177 fn get(
21178 &self,
21179 arg_req: &crate::types::GetReq,
21180 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError>> {
21181 let mut closure = self.get.closure.lock().unwrap();
21182 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetReq) -> _ = &mut **closure;
21183 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21184 }
21185 fn multiGet(
21186 &self,
21187 arg_req: &crate::types::MultiGetReq,
21188 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError>> {
21189 let mut closure = self.multiGet.closure.lock().unwrap();
21190 let closure: &mut dyn ::std::ops::FnMut(crate::types::MultiGetReq) -> _ = &mut **closure;
21191 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21192 }
21193 fn remove(
21194 &self,
21195 arg_req: &crate::types::RemoveReq,
21196 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError>> {
21197 let mut closure = self.remove.closure.lock().unwrap();
21198 let closure: &mut dyn ::std::ops::FnMut(crate::types::RemoveReq) -> _ = &mut **closure;
21199 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21200 }
21201 fn removeRange(
21202 &self,
21203 arg_req: &crate::types::RemoveRangeReq,
21204 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError>> {
21205 let mut closure = self.removeRange.closure.lock().unwrap();
21206 let closure: &mut dyn ::std::ops::FnMut(crate::types::RemoveRangeReq) -> _ = &mut **closure;
21207 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21208 }
21209 fn scan(
21210 &self,
21211 arg_req: &crate::types::ScanReq,
21212 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError>> {
21213 let mut closure = self.scan.closure.lock().unwrap();
21214 let closure: &mut dyn ::std::ops::FnMut(crate::types::ScanReq) -> _ = &mut **closure;
21215 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21216 }
21217 fn createTagIndex(
21218 &self,
21219 arg_req: &crate::types::CreateTagIndexReq,
21220 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError>> {
21221 let mut closure = self.createTagIndex.closure.lock().unwrap();
21222 let closure: &mut dyn ::std::ops::FnMut(crate::types::CreateTagIndexReq) -> _ = &mut **closure;
21223 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21224 }
21225 fn dropTagIndex(
21226 &self,
21227 arg_req: &crate::types::DropTagIndexReq,
21228 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError>> {
21229 let mut closure = self.dropTagIndex.closure.lock().unwrap();
21230 let closure: &mut dyn ::std::ops::FnMut(crate::types::DropTagIndexReq) -> _ = &mut **closure;
21231 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21232 }
21233 fn getTagIndex(
21234 &self,
21235 arg_req: &crate::types::GetTagIndexReq,
21236 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError>> {
21237 let mut closure = self.getTagIndex.closure.lock().unwrap();
21238 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetTagIndexReq) -> _ = &mut **closure;
21239 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21240 }
21241 fn listTagIndexes(
21242 &self,
21243 arg_req: &crate::types::ListTagIndexesReq,
21244 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError>> {
21245 let mut closure = self.listTagIndexes.closure.lock().unwrap();
21246 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListTagIndexesReq) -> _ = &mut **closure;
21247 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21248 }
21249 fn rebuildTagIndex(
21250 &self,
21251 arg_req: &crate::types::RebuildIndexReq,
21252 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError>> {
21253 let mut closure = self.rebuildTagIndex.closure.lock().unwrap();
21254 let closure: &mut dyn ::std::ops::FnMut(crate::types::RebuildIndexReq) -> _ = &mut **closure;
21255 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21256 }
21257 fn listTagIndexStatus(
21258 &self,
21259 arg_req: &crate::types::ListIndexStatusReq,
21260 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError>> {
21261 let mut closure = self.listTagIndexStatus.closure.lock().unwrap();
21262 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> _ = &mut **closure;
21263 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21264 }
21265 fn createEdgeIndex(
21266 &self,
21267 arg_req: &crate::types::CreateEdgeIndexReq,
21268 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError>> {
21269 let mut closure = self.createEdgeIndex.closure.lock().unwrap();
21270 let closure: &mut dyn ::std::ops::FnMut(crate::types::CreateEdgeIndexReq) -> _ = &mut **closure;
21271 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21272 }
21273 fn dropEdgeIndex(
21274 &self,
21275 arg_req: &crate::types::DropEdgeIndexReq,
21276 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError>> {
21277 let mut closure = self.dropEdgeIndex.closure.lock().unwrap();
21278 let closure: &mut dyn ::std::ops::FnMut(crate::types::DropEdgeIndexReq) -> _ = &mut **closure;
21279 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21280 }
21281 fn getEdgeIndex(
21282 &self,
21283 arg_req: &crate::types::GetEdgeIndexReq,
21284 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError>> {
21285 let mut closure = self.getEdgeIndex.closure.lock().unwrap();
21286 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetEdgeIndexReq) -> _ = &mut **closure;
21287 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21288 }
21289 fn listEdgeIndexes(
21290 &self,
21291 arg_req: &crate::types::ListEdgeIndexesReq,
21292 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError>> {
21293 let mut closure = self.listEdgeIndexes.closure.lock().unwrap();
21294 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListEdgeIndexesReq) -> _ = &mut **closure;
21295 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21296 }
21297 fn rebuildEdgeIndex(
21298 &self,
21299 arg_req: &crate::types::RebuildIndexReq,
21300 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError>> {
21301 let mut closure = self.rebuildEdgeIndex.closure.lock().unwrap();
21302 let closure: &mut dyn ::std::ops::FnMut(crate::types::RebuildIndexReq) -> _ = &mut **closure;
21303 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21304 }
21305 fn listEdgeIndexStatus(
21306 &self,
21307 arg_req: &crate::types::ListIndexStatusReq,
21308 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError>> {
21309 let mut closure = self.listEdgeIndexStatus.closure.lock().unwrap();
21310 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> _ = &mut **closure;
21311 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21312 }
21313 fn createUser(
21314 &self,
21315 arg_req: &crate::types::CreateUserReq,
21316 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError>> {
21317 let mut closure = self.createUser.closure.lock().unwrap();
21318 let closure: &mut dyn ::std::ops::FnMut(crate::types::CreateUserReq) -> _ = &mut **closure;
21319 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21320 }
21321 fn dropUser(
21322 &self,
21323 arg_req: &crate::types::DropUserReq,
21324 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError>> {
21325 let mut closure = self.dropUser.closure.lock().unwrap();
21326 let closure: &mut dyn ::std::ops::FnMut(crate::types::DropUserReq) -> _ = &mut **closure;
21327 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21328 }
21329 fn alterUser(
21330 &self,
21331 arg_req: &crate::types::AlterUserReq,
21332 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError>> {
21333 let mut closure = self.alterUser.closure.lock().unwrap();
21334 let closure: &mut dyn ::std::ops::FnMut(crate::types::AlterUserReq) -> _ = &mut **closure;
21335 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21336 }
21337 fn grantRole(
21338 &self,
21339 arg_req: &crate::types::GrantRoleReq,
21340 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError>> {
21341 let mut closure = self.grantRole.closure.lock().unwrap();
21342 let closure: &mut dyn ::std::ops::FnMut(crate::types::GrantRoleReq) -> _ = &mut **closure;
21343 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21344 }
21345 fn revokeRole(
21346 &self,
21347 arg_req: &crate::types::RevokeRoleReq,
21348 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError>> {
21349 let mut closure = self.revokeRole.closure.lock().unwrap();
21350 let closure: &mut dyn ::std::ops::FnMut(crate::types::RevokeRoleReq) -> _ = &mut **closure;
21351 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21352 }
21353 fn listUsers(
21354 &self,
21355 arg_req: &crate::types::ListUsersReq,
21356 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError>> {
21357 let mut closure = self.listUsers.closure.lock().unwrap();
21358 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListUsersReq) -> _ = &mut **closure;
21359 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21360 }
21361 fn listRoles(
21362 &self,
21363 arg_req: &crate::types::ListRolesReq,
21364 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError>> {
21365 let mut closure = self.listRoles.closure.lock().unwrap();
21366 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListRolesReq) -> _ = &mut **closure;
21367 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21368 }
21369 fn getUserRoles(
21370 &self,
21371 arg_req: &crate::types::GetUserRolesReq,
21372 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError>> {
21373 let mut closure = self.getUserRoles.closure.lock().unwrap();
21374 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetUserRolesReq) -> _ = &mut **closure;
21375 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21376 }
21377 fn changePassword(
21378 &self,
21379 arg_req: &crate::types::ChangePasswordReq,
21380 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError>> {
21381 let mut closure = self.changePassword.closure.lock().unwrap();
21382 let closure: &mut dyn ::std::ops::FnMut(crate::types::ChangePasswordReq) -> _ = &mut **closure;
21383 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21384 }
21385 fn heartBeat(
21386 &self,
21387 arg_req: &crate::types::HBReq,
21388 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError>> {
21389 let mut closure = self.heartBeat.closure.lock().unwrap();
21390 let closure: &mut dyn ::std::ops::FnMut(crate::types::HBReq) -> _ = &mut **closure;
21391 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21392 }
21393 fn balance(
21394 &self,
21395 arg_req: &crate::types::BalanceReq,
21396 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError>> {
21397 let mut closure = self.balance.closure.lock().unwrap();
21398 let closure: &mut dyn ::std::ops::FnMut(crate::types::BalanceReq) -> _ = &mut **closure;
21399 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21400 }
21401 fn leaderBalance(
21402 &self,
21403 arg_req: &crate::types::LeaderBalanceReq,
21404 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError>> {
21405 let mut closure = self.leaderBalance.closure.lock().unwrap();
21406 let closure: &mut dyn ::std::ops::FnMut(crate::types::LeaderBalanceReq) -> _ = &mut **closure;
21407 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21408 }
21409 fn regConfig(
21410 &self,
21411 arg_req: &crate::types::RegConfigReq,
21412 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError>> {
21413 let mut closure = self.regConfig.closure.lock().unwrap();
21414 let closure: &mut dyn ::std::ops::FnMut(crate::types::RegConfigReq) -> _ = &mut **closure;
21415 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21416 }
21417 fn getConfig(
21418 &self,
21419 arg_req: &crate::types::GetConfigReq,
21420 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError>> {
21421 let mut closure = self.getConfig.closure.lock().unwrap();
21422 let closure: &mut dyn ::std::ops::FnMut(crate::types::GetConfigReq) -> _ = &mut **closure;
21423 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21424 }
21425 fn setConfig(
21426 &self,
21427 arg_req: &crate::types::SetConfigReq,
21428 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError>> {
21429 let mut closure = self.setConfig.closure.lock().unwrap();
21430 let closure: &mut dyn ::std::ops::FnMut(crate::types::SetConfigReq) -> _ = &mut **closure;
21431 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21432 }
21433 fn listConfigs(
21434 &self,
21435 arg_req: &crate::types::ListConfigsReq,
21436 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError>> {
21437 let mut closure = self.listConfigs.closure.lock().unwrap();
21438 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListConfigsReq) -> _ = &mut **closure;
21439 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21440 }
21441 fn createSnapshot(
21442 &self,
21443 arg_req: &crate::types::CreateSnapshotReq,
21444 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError>> {
21445 let mut closure = self.createSnapshot.closure.lock().unwrap();
21446 let closure: &mut dyn ::std::ops::FnMut(crate::types::CreateSnapshotReq) -> _ = &mut **closure;
21447 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21448 }
21449 fn dropSnapshot(
21450 &self,
21451 arg_req: &crate::types::DropSnapshotReq,
21452 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError>> {
21453 let mut closure = self.dropSnapshot.closure.lock().unwrap();
21454 let closure: &mut dyn ::std::ops::FnMut(crate::types::DropSnapshotReq) -> _ = &mut **closure;
21455 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21456 }
21457 fn listSnapshots(
21458 &self,
21459 arg_req: &crate::types::ListSnapshotsReq,
21460 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError>> {
21461 let mut closure = self.listSnapshots.closure.lock().unwrap();
21462 let closure: &mut dyn ::std::ops::FnMut(crate::types::ListSnapshotsReq) -> _ = &mut **closure;
21463 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21464 }
21465 fn runAdminJob(
21466 &self,
21467 arg_req: &crate::types::AdminJobReq,
21468 ) -> ::futures::future::BoxFuture<'static, ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError>> {
21469 let mut closure = self.runAdminJob.closure.lock().unwrap();
21470 let closure: &mut dyn ::std::ops::FnMut(crate::types::AdminJobReq) -> _ = &mut **closure;
21471 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
21472 }
21473 }
21474
21475 mod r#impl {
21476 pub mod meta_service {
21477
21478 pub struct createSpace<'mock> {
21479 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21480 dyn ::std::ops::FnMut(crate::types::CreateSpaceReq) -> ::std::result::Result<
21481 crate::types::ExecResp,
21482 crate::errors::meta_service::CreateSpaceError,
21483 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21484 >>,
21485 }
21486
21487 #[allow(clippy::redundant_closure)]
21488 impl<'mock> createSpace<'mock> {
21489 pub fn unimplemented() -> Self {
21490 Self {
21491 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::CreateSpaceReq| panic!(
21492 "{}::{} is not mocked",
21493 "MetaService",
21494 "createSpace",
21495 ))),
21496 }
21497 }
21498
21499 pub fn ret(&self, value: crate::types::ExecResp) {
21500 self.mock(move |_: crate::types::CreateSpaceReq| value.clone());
21501 }
21502
21503 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateSpaceReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21504 let mut closure = self.closure.lock().unwrap();
21505 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21506 }
21507
21508 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateSpaceReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSpaceError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21509 let mut closure = self.closure.lock().unwrap();
21510 *closure = ::std::boxed::Box::new(move |req| mock(req));
21511 }
21512
21513 pub fn throw<E>(&self, exception: E)
21514 where
21515 E: ::std::convert::Into<crate::errors::meta_service::CreateSpaceError>,
21516 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21517 {
21518 let mut closure = self.closure.lock().unwrap();
21519 *closure = ::std::boxed::Box::new(move |_: crate::types::CreateSpaceReq| ::std::result::Result::Err(exception.clone().into()));
21520 }
21521 }
21522
21523 pub struct dropSpace<'mock> {
21524 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21525 dyn ::std::ops::FnMut(crate::types::DropSpaceReq) -> ::std::result::Result<
21526 crate::types::ExecResp,
21527 crate::errors::meta_service::DropSpaceError,
21528 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21529 >>,
21530 }
21531
21532 #[allow(clippy::redundant_closure)]
21533 impl<'mock> dropSpace<'mock> {
21534 pub fn unimplemented() -> Self {
21535 Self {
21536 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::DropSpaceReq| panic!(
21537 "{}::{} is not mocked",
21538 "MetaService",
21539 "dropSpace",
21540 ))),
21541 }
21542 }
21543
21544 pub fn ret(&self, value: crate::types::ExecResp) {
21545 self.mock(move |_: crate::types::DropSpaceReq| value.clone());
21546 }
21547
21548 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropSpaceReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21549 let mut closure = self.closure.lock().unwrap();
21550 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21551 }
21552
21553 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropSpaceReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSpaceError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21554 let mut closure = self.closure.lock().unwrap();
21555 *closure = ::std::boxed::Box::new(move |req| mock(req));
21556 }
21557
21558 pub fn throw<E>(&self, exception: E)
21559 where
21560 E: ::std::convert::Into<crate::errors::meta_service::DropSpaceError>,
21561 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21562 {
21563 let mut closure = self.closure.lock().unwrap();
21564 *closure = ::std::boxed::Box::new(move |_: crate::types::DropSpaceReq| ::std::result::Result::Err(exception.clone().into()));
21565 }
21566 }
21567
21568 pub struct getSpace<'mock> {
21569 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21570 dyn ::std::ops::FnMut(crate::types::GetSpaceReq) -> ::std::result::Result<
21571 crate::types::GetSpaceResp,
21572 crate::errors::meta_service::GetSpaceError,
21573 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21574 >>,
21575 }
21576
21577 #[allow(clippy::redundant_closure)]
21578 impl<'mock> getSpace<'mock> {
21579 pub fn unimplemented() -> Self {
21580 Self {
21581 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetSpaceReq| panic!(
21582 "{}::{} is not mocked",
21583 "MetaService",
21584 "getSpace",
21585 ))),
21586 }
21587 }
21588
21589 pub fn ret(&self, value: crate::types::GetSpaceResp) {
21590 self.mock(move |_: crate::types::GetSpaceReq| value.clone());
21591 }
21592
21593 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetSpaceReq) -> crate::types::GetSpaceResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21594 let mut closure = self.closure.lock().unwrap();
21595 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21596 }
21597
21598 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetSpaceReq) -> ::std::result::Result<crate::types::GetSpaceResp, crate::errors::meta_service::GetSpaceError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21599 let mut closure = self.closure.lock().unwrap();
21600 *closure = ::std::boxed::Box::new(move |req| mock(req));
21601 }
21602
21603 pub fn throw<E>(&self, exception: E)
21604 where
21605 E: ::std::convert::Into<crate::errors::meta_service::GetSpaceError>,
21606 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21607 {
21608 let mut closure = self.closure.lock().unwrap();
21609 *closure = ::std::boxed::Box::new(move |_: crate::types::GetSpaceReq| ::std::result::Result::Err(exception.clone().into()));
21610 }
21611 }
21612
21613 pub struct listSpaces<'mock> {
21614 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21615 dyn ::std::ops::FnMut(crate::types::ListSpacesReq) -> ::std::result::Result<
21616 crate::types::ListSpacesResp,
21617 crate::errors::meta_service::ListSpacesError,
21618 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21619 >>,
21620 }
21621
21622 #[allow(clippy::redundant_closure)]
21623 impl<'mock> listSpaces<'mock> {
21624 pub fn unimplemented() -> Self {
21625 Self {
21626 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListSpacesReq| panic!(
21627 "{}::{} is not mocked",
21628 "MetaService",
21629 "listSpaces",
21630 ))),
21631 }
21632 }
21633
21634 pub fn ret(&self, value: crate::types::ListSpacesResp) {
21635 self.mock(move |_: crate::types::ListSpacesReq| value.clone());
21636 }
21637
21638 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListSpacesReq) -> crate::types::ListSpacesResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21639 let mut closure = self.closure.lock().unwrap();
21640 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21641 }
21642
21643 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListSpacesReq) -> ::std::result::Result<crate::types::ListSpacesResp, crate::errors::meta_service::ListSpacesError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21644 let mut closure = self.closure.lock().unwrap();
21645 *closure = ::std::boxed::Box::new(move |req| mock(req));
21646 }
21647
21648 pub fn throw<E>(&self, exception: E)
21649 where
21650 E: ::std::convert::Into<crate::errors::meta_service::ListSpacesError>,
21651 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21652 {
21653 let mut closure = self.closure.lock().unwrap();
21654 *closure = ::std::boxed::Box::new(move |_: crate::types::ListSpacesReq| ::std::result::Result::Err(exception.clone().into()));
21655 }
21656 }
21657
21658 pub struct createTag<'mock> {
21659 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21660 dyn ::std::ops::FnMut(crate::types::CreateTagReq) -> ::std::result::Result<
21661 crate::types::ExecResp,
21662 crate::errors::meta_service::CreateTagError,
21663 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21664 >>,
21665 }
21666
21667 #[allow(clippy::redundant_closure)]
21668 impl<'mock> createTag<'mock> {
21669 pub fn unimplemented() -> Self {
21670 Self {
21671 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::CreateTagReq| panic!(
21672 "{}::{} is not mocked",
21673 "MetaService",
21674 "createTag",
21675 ))),
21676 }
21677 }
21678
21679 pub fn ret(&self, value: crate::types::ExecResp) {
21680 self.mock(move |_: crate::types::CreateTagReq| value.clone());
21681 }
21682
21683 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateTagReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21684 let mut closure = self.closure.lock().unwrap();
21685 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21686 }
21687
21688 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateTagReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21689 let mut closure = self.closure.lock().unwrap();
21690 *closure = ::std::boxed::Box::new(move |req| mock(req));
21691 }
21692
21693 pub fn throw<E>(&self, exception: E)
21694 where
21695 E: ::std::convert::Into<crate::errors::meta_service::CreateTagError>,
21696 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21697 {
21698 let mut closure = self.closure.lock().unwrap();
21699 *closure = ::std::boxed::Box::new(move |_: crate::types::CreateTagReq| ::std::result::Result::Err(exception.clone().into()));
21700 }
21701 }
21702
21703 pub struct alterTag<'mock> {
21704 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21705 dyn ::std::ops::FnMut(crate::types::AlterTagReq) -> ::std::result::Result<
21706 crate::types::ExecResp,
21707 crate::errors::meta_service::AlterTagError,
21708 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21709 >>,
21710 }
21711
21712 #[allow(clippy::redundant_closure)]
21713 impl<'mock> alterTag<'mock> {
21714 pub fn unimplemented() -> Self {
21715 Self {
21716 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::AlterTagReq| panic!(
21717 "{}::{} is not mocked",
21718 "MetaService",
21719 "alterTag",
21720 ))),
21721 }
21722 }
21723
21724 pub fn ret(&self, value: crate::types::ExecResp) {
21725 self.mock(move |_: crate::types::AlterTagReq| value.clone());
21726 }
21727
21728 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::AlterTagReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21729 let mut closure = self.closure.lock().unwrap();
21730 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21731 }
21732
21733 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::AlterTagReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterTagError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21734 let mut closure = self.closure.lock().unwrap();
21735 *closure = ::std::boxed::Box::new(move |req| mock(req));
21736 }
21737
21738 pub fn throw<E>(&self, exception: E)
21739 where
21740 E: ::std::convert::Into<crate::errors::meta_service::AlterTagError>,
21741 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21742 {
21743 let mut closure = self.closure.lock().unwrap();
21744 *closure = ::std::boxed::Box::new(move |_: crate::types::AlterTagReq| ::std::result::Result::Err(exception.clone().into()));
21745 }
21746 }
21747
21748 pub struct dropTag<'mock> {
21749 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21750 dyn ::std::ops::FnMut(crate::types::DropTagReq) -> ::std::result::Result<
21751 crate::types::ExecResp,
21752 crate::errors::meta_service::DropTagError,
21753 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21754 >>,
21755 }
21756
21757 #[allow(clippy::redundant_closure)]
21758 impl<'mock> dropTag<'mock> {
21759 pub fn unimplemented() -> Self {
21760 Self {
21761 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::DropTagReq| panic!(
21762 "{}::{} is not mocked",
21763 "MetaService",
21764 "dropTag",
21765 ))),
21766 }
21767 }
21768
21769 pub fn ret(&self, value: crate::types::ExecResp) {
21770 self.mock(move |_: crate::types::DropTagReq| value.clone());
21771 }
21772
21773 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropTagReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21774 let mut closure = self.closure.lock().unwrap();
21775 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21776 }
21777
21778 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropTagReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21779 let mut closure = self.closure.lock().unwrap();
21780 *closure = ::std::boxed::Box::new(move |req| mock(req));
21781 }
21782
21783 pub fn throw<E>(&self, exception: E)
21784 where
21785 E: ::std::convert::Into<crate::errors::meta_service::DropTagError>,
21786 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21787 {
21788 let mut closure = self.closure.lock().unwrap();
21789 *closure = ::std::boxed::Box::new(move |_: crate::types::DropTagReq| ::std::result::Result::Err(exception.clone().into()));
21790 }
21791 }
21792
21793 pub struct getTag<'mock> {
21794 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21795 dyn ::std::ops::FnMut(crate::types::GetTagReq) -> ::std::result::Result<
21796 crate::types::GetTagResp,
21797 crate::errors::meta_service::GetTagError,
21798 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21799 >>,
21800 }
21801
21802 #[allow(clippy::redundant_closure)]
21803 impl<'mock> getTag<'mock> {
21804 pub fn unimplemented() -> Self {
21805 Self {
21806 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetTagReq| panic!(
21807 "{}::{} is not mocked",
21808 "MetaService",
21809 "getTag",
21810 ))),
21811 }
21812 }
21813
21814 pub fn ret(&self, value: crate::types::GetTagResp) {
21815 self.mock(move |_: crate::types::GetTagReq| value.clone());
21816 }
21817
21818 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetTagReq) -> crate::types::GetTagResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21819 let mut closure = self.closure.lock().unwrap();
21820 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21821 }
21822
21823 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetTagReq) -> ::std::result::Result<crate::types::GetTagResp, crate::errors::meta_service::GetTagError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21824 let mut closure = self.closure.lock().unwrap();
21825 *closure = ::std::boxed::Box::new(move |req| mock(req));
21826 }
21827
21828 pub fn throw<E>(&self, exception: E)
21829 where
21830 E: ::std::convert::Into<crate::errors::meta_service::GetTagError>,
21831 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21832 {
21833 let mut closure = self.closure.lock().unwrap();
21834 *closure = ::std::boxed::Box::new(move |_: crate::types::GetTagReq| ::std::result::Result::Err(exception.clone().into()));
21835 }
21836 }
21837
21838 pub struct listTags<'mock> {
21839 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21840 dyn ::std::ops::FnMut(crate::types::ListTagsReq) -> ::std::result::Result<
21841 crate::types::ListTagsResp,
21842 crate::errors::meta_service::ListTagsError,
21843 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21844 >>,
21845 }
21846
21847 #[allow(clippy::redundant_closure)]
21848 impl<'mock> listTags<'mock> {
21849 pub fn unimplemented() -> Self {
21850 Self {
21851 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListTagsReq| panic!(
21852 "{}::{} is not mocked",
21853 "MetaService",
21854 "listTags",
21855 ))),
21856 }
21857 }
21858
21859 pub fn ret(&self, value: crate::types::ListTagsResp) {
21860 self.mock(move |_: crate::types::ListTagsReq| value.clone());
21861 }
21862
21863 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListTagsReq) -> crate::types::ListTagsResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21864 let mut closure = self.closure.lock().unwrap();
21865 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21866 }
21867
21868 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListTagsReq) -> ::std::result::Result<crate::types::ListTagsResp, crate::errors::meta_service::ListTagsError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21869 let mut closure = self.closure.lock().unwrap();
21870 *closure = ::std::boxed::Box::new(move |req| mock(req));
21871 }
21872
21873 pub fn throw<E>(&self, exception: E)
21874 where
21875 E: ::std::convert::Into<crate::errors::meta_service::ListTagsError>,
21876 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21877 {
21878 let mut closure = self.closure.lock().unwrap();
21879 *closure = ::std::boxed::Box::new(move |_: crate::types::ListTagsReq| ::std::result::Result::Err(exception.clone().into()));
21880 }
21881 }
21882
21883 pub struct createEdge<'mock> {
21884 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21885 dyn ::std::ops::FnMut(crate::types::CreateEdgeReq) -> ::std::result::Result<
21886 crate::types::ExecResp,
21887 crate::errors::meta_service::CreateEdgeError,
21888 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21889 >>,
21890 }
21891
21892 #[allow(clippy::redundant_closure)]
21893 impl<'mock> createEdge<'mock> {
21894 pub fn unimplemented() -> Self {
21895 Self {
21896 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::CreateEdgeReq| panic!(
21897 "{}::{} is not mocked",
21898 "MetaService",
21899 "createEdge",
21900 ))),
21901 }
21902 }
21903
21904 pub fn ret(&self, value: crate::types::ExecResp) {
21905 self.mock(move |_: crate::types::CreateEdgeReq| value.clone());
21906 }
21907
21908 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateEdgeReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21909 let mut closure = self.closure.lock().unwrap();
21910 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21911 }
21912
21913 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateEdgeReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21914 let mut closure = self.closure.lock().unwrap();
21915 *closure = ::std::boxed::Box::new(move |req| mock(req));
21916 }
21917
21918 pub fn throw<E>(&self, exception: E)
21919 where
21920 E: ::std::convert::Into<crate::errors::meta_service::CreateEdgeError>,
21921 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21922 {
21923 let mut closure = self.closure.lock().unwrap();
21924 *closure = ::std::boxed::Box::new(move |_: crate::types::CreateEdgeReq| ::std::result::Result::Err(exception.clone().into()));
21925 }
21926 }
21927
21928 pub struct alterEdge<'mock> {
21929 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21930 dyn ::std::ops::FnMut(crate::types::AlterEdgeReq) -> ::std::result::Result<
21931 crate::types::ExecResp,
21932 crate::errors::meta_service::AlterEdgeError,
21933 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21934 >>,
21935 }
21936
21937 #[allow(clippy::redundant_closure)]
21938 impl<'mock> alterEdge<'mock> {
21939 pub fn unimplemented() -> Self {
21940 Self {
21941 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::AlterEdgeReq| panic!(
21942 "{}::{} is not mocked",
21943 "MetaService",
21944 "alterEdge",
21945 ))),
21946 }
21947 }
21948
21949 pub fn ret(&self, value: crate::types::ExecResp) {
21950 self.mock(move |_: crate::types::AlterEdgeReq| value.clone());
21951 }
21952
21953 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::AlterEdgeReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21954 let mut closure = self.closure.lock().unwrap();
21955 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
21956 }
21957
21958 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::AlterEdgeReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterEdgeError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21959 let mut closure = self.closure.lock().unwrap();
21960 *closure = ::std::boxed::Box::new(move |req| mock(req));
21961 }
21962
21963 pub fn throw<E>(&self, exception: E)
21964 where
21965 E: ::std::convert::Into<crate::errors::meta_service::AlterEdgeError>,
21966 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
21967 {
21968 let mut closure = self.closure.lock().unwrap();
21969 *closure = ::std::boxed::Box::new(move |_: crate::types::AlterEdgeReq| ::std::result::Result::Err(exception.clone().into()));
21970 }
21971 }
21972
21973 pub struct dropEdge<'mock> {
21974 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
21975 dyn ::std::ops::FnMut(crate::types::DropEdgeReq) -> ::std::result::Result<
21976 crate::types::ExecResp,
21977 crate::errors::meta_service::DropEdgeError,
21978 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
21979 >>,
21980 }
21981
21982 #[allow(clippy::redundant_closure)]
21983 impl<'mock> dropEdge<'mock> {
21984 pub fn unimplemented() -> Self {
21985 Self {
21986 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::DropEdgeReq| panic!(
21987 "{}::{} is not mocked",
21988 "MetaService",
21989 "dropEdge",
21990 ))),
21991 }
21992 }
21993
21994 pub fn ret(&self, value: crate::types::ExecResp) {
21995 self.mock(move |_: crate::types::DropEdgeReq| value.clone());
21996 }
21997
21998 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropEdgeReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
21999 let mut closure = self.closure.lock().unwrap();
22000 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22001 }
22002
22003 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropEdgeReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22004 let mut closure = self.closure.lock().unwrap();
22005 *closure = ::std::boxed::Box::new(move |req| mock(req));
22006 }
22007
22008 pub fn throw<E>(&self, exception: E)
22009 where
22010 E: ::std::convert::Into<crate::errors::meta_service::DropEdgeError>,
22011 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22012 {
22013 let mut closure = self.closure.lock().unwrap();
22014 *closure = ::std::boxed::Box::new(move |_: crate::types::DropEdgeReq| ::std::result::Result::Err(exception.clone().into()));
22015 }
22016 }
22017
22018 pub struct getEdge<'mock> {
22019 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22020 dyn ::std::ops::FnMut(crate::types::GetEdgeReq) -> ::std::result::Result<
22021 crate::types::GetEdgeResp,
22022 crate::errors::meta_service::GetEdgeError,
22023 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22024 >>,
22025 }
22026
22027 #[allow(clippy::redundant_closure)]
22028 impl<'mock> getEdge<'mock> {
22029 pub fn unimplemented() -> Self {
22030 Self {
22031 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetEdgeReq| panic!(
22032 "{}::{} is not mocked",
22033 "MetaService",
22034 "getEdge",
22035 ))),
22036 }
22037 }
22038
22039 pub fn ret(&self, value: crate::types::GetEdgeResp) {
22040 self.mock(move |_: crate::types::GetEdgeReq| value.clone());
22041 }
22042
22043 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetEdgeReq) -> crate::types::GetEdgeResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22044 let mut closure = self.closure.lock().unwrap();
22045 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22046 }
22047
22048 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetEdgeReq) -> ::std::result::Result<crate::types::GetEdgeResp, crate::errors::meta_service::GetEdgeError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22049 let mut closure = self.closure.lock().unwrap();
22050 *closure = ::std::boxed::Box::new(move |req| mock(req));
22051 }
22052
22053 pub fn throw<E>(&self, exception: E)
22054 where
22055 E: ::std::convert::Into<crate::errors::meta_service::GetEdgeError>,
22056 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22057 {
22058 let mut closure = self.closure.lock().unwrap();
22059 *closure = ::std::boxed::Box::new(move |_: crate::types::GetEdgeReq| ::std::result::Result::Err(exception.clone().into()));
22060 }
22061 }
22062
22063 pub struct listEdges<'mock> {
22064 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22065 dyn ::std::ops::FnMut(crate::types::ListEdgesReq) -> ::std::result::Result<
22066 crate::types::ListEdgesResp,
22067 crate::errors::meta_service::ListEdgesError,
22068 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22069 >>,
22070 }
22071
22072 #[allow(clippy::redundant_closure)]
22073 impl<'mock> listEdges<'mock> {
22074 pub fn unimplemented() -> Self {
22075 Self {
22076 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListEdgesReq| panic!(
22077 "{}::{} is not mocked",
22078 "MetaService",
22079 "listEdges",
22080 ))),
22081 }
22082 }
22083
22084 pub fn ret(&self, value: crate::types::ListEdgesResp) {
22085 self.mock(move |_: crate::types::ListEdgesReq| value.clone());
22086 }
22087
22088 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListEdgesReq) -> crate::types::ListEdgesResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22089 let mut closure = self.closure.lock().unwrap();
22090 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22091 }
22092
22093 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListEdgesReq) -> ::std::result::Result<crate::types::ListEdgesResp, crate::errors::meta_service::ListEdgesError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22094 let mut closure = self.closure.lock().unwrap();
22095 *closure = ::std::boxed::Box::new(move |req| mock(req));
22096 }
22097
22098 pub fn throw<E>(&self, exception: E)
22099 where
22100 E: ::std::convert::Into<crate::errors::meta_service::ListEdgesError>,
22101 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22102 {
22103 let mut closure = self.closure.lock().unwrap();
22104 *closure = ::std::boxed::Box::new(move |_: crate::types::ListEdgesReq| ::std::result::Result::Err(exception.clone().into()));
22105 }
22106 }
22107
22108 pub struct listHosts<'mock> {
22109 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22110 dyn ::std::ops::FnMut(crate::types::ListHostsReq) -> ::std::result::Result<
22111 crate::types::ListHostsResp,
22112 crate::errors::meta_service::ListHostsError,
22113 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22114 >>,
22115 }
22116
22117 #[allow(clippy::redundant_closure)]
22118 impl<'mock> listHosts<'mock> {
22119 pub fn unimplemented() -> Self {
22120 Self {
22121 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListHostsReq| panic!(
22122 "{}::{} is not mocked",
22123 "MetaService",
22124 "listHosts",
22125 ))),
22126 }
22127 }
22128
22129 pub fn ret(&self, value: crate::types::ListHostsResp) {
22130 self.mock(move |_: crate::types::ListHostsReq| value.clone());
22131 }
22132
22133 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListHostsReq) -> crate::types::ListHostsResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22134 let mut closure = self.closure.lock().unwrap();
22135 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22136 }
22137
22138 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListHostsReq) -> ::std::result::Result<crate::types::ListHostsResp, crate::errors::meta_service::ListHostsError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22139 let mut closure = self.closure.lock().unwrap();
22140 *closure = ::std::boxed::Box::new(move |req| mock(req));
22141 }
22142
22143 pub fn throw<E>(&self, exception: E)
22144 where
22145 E: ::std::convert::Into<crate::errors::meta_service::ListHostsError>,
22146 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22147 {
22148 let mut closure = self.closure.lock().unwrap();
22149 *closure = ::std::boxed::Box::new(move |_: crate::types::ListHostsReq| ::std::result::Result::Err(exception.clone().into()));
22150 }
22151 }
22152
22153 pub struct getPartsAlloc<'mock> {
22154 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22155 dyn ::std::ops::FnMut(crate::types::GetPartsAllocReq) -> ::std::result::Result<
22156 crate::types::GetPartsAllocResp,
22157 crate::errors::meta_service::GetPartsAllocError,
22158 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22159 >>,
22160 }
22161
22162 #[allow(clippy::redundant_closure)]
22163 impl<'mock> getPartsAlloc<'mock> {
22164 pub fn unimplemented() -> Self {
22165 Self {
22166 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetPartsAllocReq| panic!(
22167 "{}::{} is not mocked",
22168 "MetaService",
22169 "getPartsAlloc",
22170 ))),
22171 }
22172 }
22173
22174 pub fn ret(&self, value: crate::types::GetPartsAllocResp) {
22175 self.mock(move |_: crate::types::GetPartsAllocReq| value.clone());
22176 }
22177
22178 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetPartsAllocReq) -> crate::types::GetPartsAllocResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22179 let mut closure = self.closure.lock().unwrap();
22180 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22181 }
22182
22183 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetPartsAllocReq) -> ::std::result::Result<crate::types::GetPartsAllocResp, crate::errors::meta_service::GetPartsAllocError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22184 let mut closure = self.closure.lock().unwrap();
22185 *closure = ::std::boxed::Box::new(move |req| mock(req));
22186 }
22187
22188 pub fn throw<E>(&self, exception: E)
22189 where
22190 E: ::std::convert::Into<crate::errors::meta_service::GetPartsAllocError>,
22191 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22192 {
22193 let mut closure = self.closure.lock().unwrap();
22194 *closure = ::std::boxed::Box::new(move |_: crate::types::GetPartsAllocReq| ::std::result::Result::Err(exception.clone().into()));
22195 }
22196 }
22197
22198 pub struct listParts<'mock> {
22199 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22200 dyn ::std::ops::FnMut(crate::types::ListPartsReq) -> ::std::result::Result<
22201 crate::types::ListPartsResp,
22202 crate::errors::meta_service::ListPartsError,
22203 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22204 >>,
22205 }
22206
22207 #[allow(clippy::redundant_closure)]
22208 impl<'mock> listParts<'mock> {
22209 pub fn unimplemented() -> Self {
22210 Self {
22211 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListPartsReq| panic!(
22212 "{}::{} is not mocked",
22213 "MetaService",
22214 "listParts",
22215 ))),
22216 }
22217 }
22218
22219 pub fn ret(&self, value: crate::types::ListPartsResp) {
22220 self.mock(move |_: crate::types::ListPartsReq| value.clone());
22221 }
22222
22223 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListPartsReq) -> crate::types::ListPartsResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22224 let mut closure = self.closure.lock().unwrap();
22225 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22226 }
22227
22228 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListPartsReq) -> ::std::result::Result<crate::types::ListPartsResp, crate::errors::meta_service::ListPartsError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22229 let mut closure = self.closure.lock().unwrap();
22230 *closure = ::std::boxed::Box::new(move |req| mock(req));
22231 }
22232
22233 pub fn throw<E>(&self, exception: E)
22234 where
22235 E: ::std::convert::Into<crate::errors::meta_service::ListPartsError>,
22236 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22237 {
22238 let mut closure = self.closure.lock().unwrap();
22239 *closure = ::std::boxed::Box::new(move |_: crate::types::ListPartsReq| ::std::result::Result::Err(exception.clone().into()));
22240 }
22241 }
22242
22243 pub struct multiPut<'mock> {
22244 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22245 dyn ::std::ops::FnMut(crate::types::MultiPutReq) -> ::std::result::Result<
22246 crate::types::ExecResp,
22247 crate::errors::meta_service::MultiPutError,
22248 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22249 >>,
22250 }
22251
22252 #[allow(clippy::redundant_closure)]
22253 impl<'mock> multiPut<'mock> {
22254 pub fn unimplemented() -> Self {
22255 Self {
22256 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::MultiPutReq| panic!(
22257 "{}::{} is not mocked",
22258 "MetaService",
22259 "multiPut",
22260 ))),
22261 }
22262 }
22263
22264 pub fn ret(&self, value: crate::types::ExecResp) {
22265 self.mock(move |_: crate::types::MultiPutReq| value.clone());
22266 }
22267
22268 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::MultiPutReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22269 let mut closure = self.closure.lock().unwrap();
22270 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22271 }
22272
22273 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::MultiPutReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::MultiPutError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22274 let mut closure = self.closure.lock().unwrap();
22275 *closure = ::std::boxed::Box::new(move |req| mock(req));
22276 }
22277
22278 pub fn throw<E>(&self, exception: E)
22279 where
22280 E: ::std::convert::Into<crate::errors::meta_service::MultiPutError>,
22281 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22282 {
22283 let mut closure = self.closure.lock().unwrap();
22284 *closure = ::std::boxed::Box::new(move |_: crate::types::MultiPutReq| ::std::result::Result::Err(exception.clone().into()));
22285 }
22286 }
22287
22288 pub struct get<'mock> {
22289 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22290 dyn ::std::ops::FnMut(crate::types::GetReq) -> ::std::result::Result<
22291 crate::types::GetResp,
22292 crate::errors::meta_service::GetError,
22293 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22294 >>,
22295 }
22296
22297 #[allow(clippy::redundant_closure)]
22298 impl<'mock> get<'mock> {
22299 pub fn unimplemented() -> Self {
22300 Self {
22301 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetReq| panic!(
22302 "{}::{} is not mocked",
22303 "MetaService",
22304 "get",
22305 ))),
22306 }
22307 }
22308
22309 pub fn ret(&self, value: crate::types::GetResp) {
22310 self.mock(move |_: crate::types::GetReq| value.clone());
22311 }
22312
22313 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetReq) -> crate::types::GetResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22314 let mut closure = self.closure.lock().unwrap();
22315 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22316 }
22317
22318 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetReq) -> ::std::result::Result<crate::types::GetResp, crate::errors::meta_service::GetError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22319 let mut closure = self.closure.lock().unwrap();
22320 *closure = ::std::boxed::Box::new(move |req| mock(req));
22321 }
22322
22323 pub fn throw<E>(&self, exception: E)
22324 where
22325 E: ::std::convert::Into<crate::errors::meta_service::GetError>,
22326 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22327 {
22328 let mut closure = self.closure.lock().unwrap();
22329 *closure = ::std::boxed::Box::new(move |_: crate::types::GetReq| ::std::result::Result::Err(exception.clone().into()));
22330 }
22331 }
22332
22333 pub struct multiGet<'mock> {
22334 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22335 dyn ::std::ops::FnMut(crate::types::MultiGetReq) -> ::std::result::Result<
22336 crate::types::MultiGetResp,
22337 crate::errors::meta_service::MultiGetError,
22338 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22339 >>,
22340 }
22341
22342 #[allow(clippy::redundant_closure)]
22343 impl<'mock> multiGet<'mock> {
22344 pub fn unimplemented() -> Self {
22345 Self {
22346 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::MultiGetReq| panic!(
22347 "{}::{} is not mocked",
22348 "MetaService",
22349 "multiGet",
22350 ))),
22351 }
22352 }
22353
22354 pub fn ret(&self, value: crate::types::MultiGetResp) {
22355 self.mock(move |_: crate::types::MultiGetReq| value.clone());
22356 }
22357
22358 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::MultiGetReq) -> crate::types::MultiGetResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22359 let mut closure = self.closure.lock().unwrap();
22360 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22361 }
22362
22363 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::MultiGetReq) -> ::std::result::Result<crate::types::MultiGetResp, crate::errors::meta_service::MultiGetError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22364 let mut closure = self.closure.lock().unwrap();
22365 *closure = ::std::boxed::Box::new(move |req| mock(req));
22366 }
22367
22368 pub fn throw<E>(&self, exception: E)
22369 where
22370 E: ::std::convert::Into<crate::errors::meta_service::MultiGetError>,
22371 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22372 {
22373 let mut closure = self.closure.lock().unwrap();
22374 *closure = ::std::boxed::Box::new(move |_: crate::types::MultiGetReq| ::std::result::Result::Err(exception.clone().into()));
22375 }
22376 }
22377
22378 pub struct remove<'mock> {
22379 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22380 dyn ::std::ops::FnMut(crate::types::RemoveReq) -> ::std::result::Result<
22381 crate::types::ExecResp,
22382 crate::errors::meta_service::RemoveError,
22383 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22384 >>,
22385 }
22386
22387 #[allow(clippy::redundant_closure)]
22388 impl<'mock> remove<'mock> {
22389 pub fn unimplemented() -> Self {
22390 Self {
22391 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::RemoveReq| panic!(
22392 "{}::{} is not mocked",
22393 "MetaService",
22394 "remove",
22395 ))),
22396 }
22397 }
22398
22399 pub fn ret(&self, value: crate::types::ExecResp) {
22400 self.mock(move |_: crate::types::RemoveReq| value.clone());
22401 }
22402
22403 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::RemoveReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22404 let mut closure = self.closure.lock().unwrap();
22405 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22406 }
22407
22408 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::RemoveReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22409 let mut closure = self.closure.lock().unwrap();
22410 *closure = ::std::boxed::Box::new(move |req| mock(req));
22411 }
22412
22413 pub fn throw<E>(&self, exception: E)
22414 where
22415 E: ::std::convert::Into<crate::errors::meta_service::RemoveError>,
22416 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22417 {
22418 let mut closure = self.closure.lock().unwrap();
22419 *closure = ::std::boxed::Box::new(move |_: crate::types::RemoveReq| ::std::result::Result::Err(exception.clone().into()));
22420 }
22421 }
22422
22423 pub struct removeRange<'mock> {
22424 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22425 dyn ::std::ops::FnMut(crate::types::RemoveRangeReq) -> ::std::result::Result<
22426 crate::types::ExecResp,
22427 crate::errors::meta_service::RemoveRangeError,
22428 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22429 >>,
22430 }
22431
22432 #[allow(clippy::redundant_closure)]
22433 impl<'mock> removeRange<'mock> {
22434 pub fn unimplemented() -> Self {
22435 Self {
22436 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::RemoveRangeReq| panic!(
22437 "{}::{} is not mocked",
22438 "MetaService",
22439 "removeRange",
22440 ))),
22441 }
22442 }
22443
22444 pub fn ret(&self, value: crate::types::ExecResp) {
22445 self.mock(move |_: crate::types::RemoveRangeReq| value.clone());
22446 }
22447
22448 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::RemoveRangeReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22449 let mut closure = self.closure.lock().unwrap();
22450 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22451 }
22452
22453 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::RemoveRangeReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RemoveRangeError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22454 let mut closure = self.closure.lock().unwrap();
22455 *closure = ::std::boxed::Box::new(move |req| mock(req));
22456 }
22457
22458 pub fn throw<E>(&self, exception: E)
22459 where
22460 E: ::std::convert::Into<crate::errors::meta_service::RemoveRangeError>,
22461 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22462 {
22463 let mut closure = self.closure.lock().unwrap();
22464 *closure = ::std::boxed::Box::new(move |_: crate::types::RemoveRangeReq| ::std::result::Result::Err(exception.clone().into()));
22465 }
22466 }
22467
22468 pub struct scan<'mock> {
22469 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22470 dyn ::std::ops::FnMut(crate::types::ScanReq) -> ::std::result::Result<
22471 crate::types::ScanResp,
22472 crate::errors::meta_service::ScanError,
22473 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22474 >>,
22475 }
22476
22477 #[allow(clippy::redundant_closure)]
22478 impl<'mock> scan<'mock> {
22479 pub fn unimplemented() -> Self {
22480 Self {
22481 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ScanReq| panic!(
22482 "{}::{} is not mocked",
22483 "MetaService",
22484 "scan",
22485 ))),
22486 }
22487 }
22488
22489 pub fn ret(&self, value: crate::types::ScanResp) {
22490 self.mock(move |_: crate::types::ScanReq| value.clone());
22491 }
22492
22493 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ScanReq) -> crate::types::ScanResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22494 let mut closure = self.closure.lock().unwrap();
22495 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22496 }
22497
22498 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ScanReq) -> ::std::result::Result<crate::types::ScanResp, crate::errors::meta_service::ScanError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22499 let mut closure = self.closure.lock().unwrap();
22500 *closure = ::std::boxed::Box::new(move |req| mock(req));
22501 }
22502
22503 pub fn throw<E>(&self, exception: E)
22504 where
22505 E: ::std::convert::Into<crate::errors::meta_service::ScanError>,
22506 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22507 {
22508 let mut closure = self.closure.lock().unwrap();
22509 *closure = ::std::boxed::Box::new(move |_: crate::types::ScanReq| ::std::result::Result::Err(exception.clone().into()));
22510 }
22511 }
22512
22513 pub struct createTagIndex<'mock> {
22514 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22515 dyn ::std::ops::FnMut(crate::types::CreateTagIndexReq) -> ::std::result::Result<
22516 crate::types::ExecResp,
22517 crate::errors::meta_service::CreateTagIndexError,
22518 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22519 >>,
22520 }
22521
22522 #[allow(clippy::redundant_closure)]
22523 impl<'mock> createTagIndex<'mock> {
22524 pub fn unimplemented() -> Self {
22525 Self {
22526 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::CreateTagIndexReq| panic!(
22527 "{}::{} is not mocked",
22528 "MetaService",
22529 "createTagIndex",
22530 ))),
22531 }
22532 }
22533
22534 pub fn ret(&self, value: crate::types::ExecResp) {
22535 self.mock(move |_: crate::types::CreateTagIndexReq| value.clone());
22536 }
22537
22538 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateTagIndexReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22539 let mut closure = self.closure.lock().unwrap();
22540 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22541 }
22542
22543 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateTagIndexReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateTagIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22544 let mut closure = self.closure.lock().unwrap();
22545 *closure = ::std::boxed::Box::new(move |req| mock(req));
22546 }
22547
22548 pub fn throw<E>(&self, exception: E)
22549 where
22550 E: ::std::convert::Into<crate::errors::meta_service::CreateTagIndexError>,
22551 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22552 {
22553 let mut closure = self.closure.lock().unwrap();
22554 *closure = ::std::boxed::Box::new(move |_: crate::types::CreateTagIndexReq| ::std::result::Result::Err(exception.clone().into()));
22555 }
22556 }
22557
22558 pub struct dropTagIndex<'mock> {
22559 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22560 dyn ::std::ops::FnMut(crate::types::DropTagIndexReq) -> ::std::result::Result<
22561 crate::types::ExecResp,
22562 crate::errors::meta_service::DropTagIndexError,
22563 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22564 >>,
22565 }
22566
22567 #[allow(clippy::redundant_closure)]
22568 impl<'mock> dropTagIndex<'mock> {
22569 pub fn unimplemented() -> Self {
22570 Self {
22571 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::DropTagIndexReq| panic!(
22572 "{}::{} is not mocked",
22573 "MetaService",
22574 "dropTagIndex",
22575 ))),
22576 }
22577 }
22578
22579 pub fn ret(&self, value: crate::types::ExecResp) {
22580 self.mock(move |_: crate::types::DropTagIndexReq| value.clone());
22581 }
22582
22583 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropTagIndexReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22584 let mut closure = self.closure.lock().unwrap();
22585 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22586 }
22587
22588 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropTagIndexReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropTagIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22589 let mut closure = self.closure.lock().unwrap();
22590 *closure = ::std::boxed::Box::new(move |req| mock(req));
22591 }
22592
22593 pub fn throw<E>(&self, exception: E)
22594 where
22595 E: ::std::convert::Into<crate::errors::meta_service::DropTagIndexError>,
22596 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22597 {
22598 let mut closure = self.closure.lock().unwrap();
22599 *closure = ::std::boxed::Box::new(move |_: crate::types::DropTagIndexReq| ::std::result::Result::Err(exception.clone().into()));
22600 }
22601 }
22602
22603 pub struct getTagIndex<'mock> {
22604 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22605 dyn ::std::ops::FnMut(crate::types::GetTagIndexReq) -> ::std::result::Result<
22606 crate::types::GetTagIndexResp,
22607 crate::errors::meta_service::GetTagIndexError,
22608 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22609 >>,
22610 }
22611
22612 #[allow(clippy::redundant_closure)]
22613 impl<'mock> getTagIndex<'mock> {
22614 pub fn unimplemented() -> Self {
22615 Self {
22616 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetTagIndexReq| panic!(
22617 "{}::{} is not mocked",
22618 "MetaService",
22619 "getTagIndex",
22620 ))),
22621 }
22622 }
22623
22624 pub fn ret(&self, value: crate::types::GetTagIndexResp) {
22625 self.mock(move |_: crate::types::GetTagIndexReq| value.clone());
22626 }
22627
22628 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetTagIndexReq) -> crate::types::GetTagIndexResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22629 let mut closure = self.closure.lock().unwrap();
22630 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22631 }
22632
22633 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetTagIndexReq) -> ::std::result::Result<crate::types::GetTagIndexResp, crate::errors::meta_service::GetTagIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22634 let mut closure = self.closure.lock().unwrap();
22635 *closure = ::std::boxed::Box::new(move |req| mock(req));
22636 }
22637
22638 pub fn throw<E>(&self, exception: E)
22639 where
22640 E: ::std::convert::Into<crate::errors::meta_service::GetTagIndexError>,
22641 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22642 {
22643 let mut closure = self.closure.lock().unwrap();
22644 *closure = ::std::boxed::Box::new(move |_: crate::types::GetTagIndexReq| ::std::result::Result::Err(exception.clone().into()));
22645 }
22646 }
22647
22648 pub struct listTagIndexes<'mock> {
22649 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22650 dyn ::std::ops::FnMut(crate::types::ListTagIndexesReq) -> ::std::result::Result<
22651 crate::types::ListTagIndexesResp,
22652 crate::errors::meta_service::ListTagIndexesError,
22653 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22654 >>,
22655 }
22656
22657 #[allow(clippy::redundant_closure)]
22658 impl<'mock> listTagIndexes<'mock> {
22659 pub fn unimplemented() -> Self {
22660 Self {
22661 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListTagIndexesReq| panic!(
22662 "{}::{} is not mocked",
22663 "MetaService",
22664 "listTagIndexes",
22665 ))),
22666 }
22667 }
22668
22669 pub fn ret(&self, value: crate::types::ListTagIndexesResp) {
22670 self.mock(move |_: crate::types::ListTagIndexesReq| value.clone());
22671 }
22672
22673 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListTagIndexesReq) -> crate::types::ListTagIndexesResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22674 let mut closure = self.closure.lock().unwrap();
22675 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22676 }
22677
22678 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListTagIndexesReq) -> ::std::result::Result<crate::types::ListTagIndexesResp, crate::errors::meta_service::ListTagIndexesError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22679 let mut closure = self.closure.lock().unwrap();
22680 *closure = ::std::boxed::Box::new(move |req| mock(req));
22681 }
22682
22683 pub fn throw<E>(&self, exception: E)
22684 where
22685 E: ::std::convert::Into<crate::errors::meta_service::ListTagIndexesError>,
22686 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22687 {
22688 let mut closure = self.closure.lock().unwrap();
22689 *closure = ::std::boxed::Box::new(move |_: crate::types::ListTagIndexesReq| ::std::result::Result::Err(exception.clone().into()));
22690 }
22691 }
22692
22693 pub struct rebuildTagIndex<'mock> {
22694 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22695 dyn ::std::ops::FnMut(crate::types::RebuildIndexReq) -> ::std::result::Result<
22696 crate::types::ExecResp,
22697 crate::errors::meta_service::RebuildTagIndexError,
22698 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22699 >>,
22700 }
22701
22702 #[allow(clippy::redundant_closure)]
22703 impl<'mock> rebuildTagIndex<'mock> {
22704 pub fn unimplemented() -> Self {
22705 Self {
22706 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::RebuildIndexReq| panic!(
22707 "{}::{} is not mocked",
22708 "MetaService",
22709 "rebuildTagIndex",
22710 ))),
22711 }
22712 }
22713
22714 pub fn ret(&self, value: crate::types::ExecResp) {
22715 self.mock(move |_: crate::types::RebuildIndexReq| value.clone());
22716 }
22717
22718 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::RebuildIndexReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22719 let mut closure = self.closure.lock().unwrap();
22720 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22721 }
22722
22723 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::RebuildIndexReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildTagIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22724 let mut closure = self.closure.lock().unwrap();
22725 *closure = ::std::boxed::Box::new(move |req| mock(req));
22726 }
22727
22728 pub fn throw<E>(&self, exception: E)
22729 where
22730 E: ::std::convert::Into<crate::errors::meta_service::RebuildTagIndexError>,
22731 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22732 {
22733 let mut closure = self.closure.lock().unwrap();
22734 *closure = ::std::boxed::Box::new(move |_: crate::types::RebuildIndexReq| ::std::result::Result::Err(exception.clone().into()));
22735 }
22736 }
22737
22738 pub struct listTagIndexStatus<'mock> {
22739 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22740 dyn ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> ::std::result::Result<
22741 crate::types::ListIndexStatusResp,
22742 crate::errors::meta_service::ListTagIndexStatusError,
22743 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22744 >>,
22745 }
22746
22747 #[allow(clippy::redundant_closure)]
22748 impl<'mock> listTagIndexStatus<'mock> {
22749 pub fn unimplemented() -> Self {
22750 Self {
22751 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListIndexStatusReq| panic!(
22752 "{}::{} is not mocked",
22753 "MetaService",
22754 "listTagIndexStatus",
22755 ))),
22756 }
22757 }
22758
22759 pub fn ret(&self, value: crate::types::ListIndexStatusResp) {
22760 self.mock(move |_: crate::types::ListIndexStatusReq| value.clone());
22761 }
22762
22763 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> crate::types::ListIndexStatusResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22764 let mut closure = self.closure.lock().unwrap();
22765 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22766 }
22767
22768 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListTagIndexStatusError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22769 let mut closure = self.closure.lock().unwrap();
22770 *closure = ::std::boxed::Box::new(move |req| mock(req));
22771 }
22772
22773 pub fn throw<E>(&self, exception: E)
22774 where
22775 E: ::std::convert::Into<crate::errors::meta_service::ListTagIndexStatusError>,
22776 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22777 {
22778 let mut closure = self.closure.lock().unwrap();
22779 *closure = ::std::boxed::Box::new(move |_: crate::types::ListIndexStatusReq| ::std::result::Result::Err(exception.clone().into()));
22780 }
22781 }
22782
22783 pub struct createEdgeIndex<'mock> {
22784 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22785 dyn ::std::ops::FnMut(crate::types::CreateEdgeIndexReq) -> ::std::result::Result<
22786 crate::types::ExecResp,
22787 crate::errors::meta_service::CreateEdgeIndexError,
22788 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22789 >>,
22790 }
22791
22792 #[allow(clippy::redundant_closure)]
22793 impl<'mock> createEdgeIndex<'mock> {
22794 pub fn unimplemented() -> Self {
22795 Self {
22796 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::CreateEdgeIndexReq| panic!(
22797 "{}::{} is not mocked",
22798 "MetaService",
22799 "createEdgeIndex",
22800 ))),
22801 }
22802 }
22803
22804 pub fn ret(&self, value: crate::types::ExecResp) {
22805 self.mock(move |_: crate::types::CreateEdgeIndexReq| value.clone());
22806 }
22807
22808 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateEdgeIndexReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22809 let mut closure = self.closure.lock().unwrap();
22810 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22811 }
22812
22813 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateEdgeIndexReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateEdgeIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22814 let mut closure = self.closure.lock().unwrap();
22815 *closure = ::std::boxed::Box::new(move |req| mock(req));
22816 }
22817
22818 pub fn throw<E>(&self, exception: E)
22819 where
22820 E: ::std::convert::Into<crate::errors::meta_service::CreateEdgeIndexError>,
22821 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22822 {
22823 let mut closure = self.closure.lock().unwrap();
22824 *closure = ::std::boxed::Box::new(move |_: crate::types::CreateEdgeIndexReq| ::std::result::Result::Err(exception.clone().into()));
22825 }
22826 }
22827
22828 pub struct dropEdgeIndex<'mock> {
22829 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22830 dyn ::std::ops::FnMut(crate::types::DropEdgeIndexReq) -> ::std::result::Result<
22831 crate::types::ExecResp,
22832 crate::errors::meta_service::DropEdgeIndexError,
22833 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22834 >>,
22835 }
22836
22837 #[allow(clippy::redundant_closure)]
22838 impl<'mock> dropEdgeIndex<'mock> {
22839 pub fn unimplemented() -> Self {
22840 Self {
22841 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::DropEdgeIndexReq| panic!(
22842 "{}::{} is not mocked",
22843 "MetaService",
22844 "dropEdgeIndex",
22845 ))),
22846 }
22847 }
22848
22849 pub fn ret(&self, value: crate::types::ExecResp) {
22850 self.mock(move |_: crate::types::DropEdgeIndexReq| value.clone());
22851 }
22852
22853 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropEdgeIndexReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22854 let mut closure = self.closure.lock().unwrap();
22855 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22856 }
22857
22858 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropEdgeIndexReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropEdgeIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22859 let mut closure = self.closure.lock().unwrap();
22860 *closure = ::std::boxed::Box::new(move |req| mock(req));
22861 }
22862
22863 pub fn throw<E>(&self, exception: E)
22864 where
22865 E: ::std::convert::Into<crate::errors::meta_service::DropEdgeIndexError>,
22866 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22867 {
22868 let mut closure = self.closure.lock().unwrap();
22869 *closure = ::std::boxed::Box::new(move |_: crate::types::DropEdgeIndexReq| ::std::result::Result::Err(exception.clone().into()));
22870 }
22871 }
22872
22873 pub struct getEdgeIndex<'mock> {
22874 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22875 dyn ::std::ops::FnMut(crate::types::GetEdgeIndexReq) -> ::std::result::Result<
22876 crate::types::GetEdgeIndexResp,
22877 crate::errors::meta_service::GetEdgeIndexError,
22878 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22879 >>,
22880 }
22881
22882 #[allow(clippy::redundant_closure)]
22883 impl<'mock> getEdgeIndex<'mock> {
22884 pub fn unimplemented() -> Self {
22885 Self {
22886 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetEdgeIndexReq| panic!(
22887 "{}::{} is not mocked",
22888 "MetaService",
22889 "getEdgeIndex",
22890 ))),
22891 }
22892 }
22893
22894 pub fn ret(&self, value: crate::types::GetEdgeIndexResp) {
22895 self.mock(move |_: crate::types::GetEdgeIndexReq| value.clone());
22896 }
22897
22898 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetEdgeIndexReq) -> crate::types::GetEdgeIndexResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22899 let mut closure = self.closure.lock().unwrap();
22900 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22901 }
22902
22903 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetEdgeIndexReq) -> ::std::result::Result<crate::types::GetEdgeIndexResp, crate::errors::meta_service::GetEdgeIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22904 let mut closure = self.closure.lock().unwrap();
22905 *closure = ::std::boxed::Box::new(move |req| mock(req));
22906 }
22907
22908 pub fn throw<E>(&self, exception: E)
22909 where
22910 E: ::std::convert::Into<crate::errors::meta_service::GetEdgeIndexError>,
22911 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22912 {
22913 let mut closure = self.closure.lock().unwrap();
22914 *closure = ::std::boxed::Box::new(move |_: crate::types::GetEdgeIndexReq| ::std::result::Result::Err(exception.clone().into()));
22915 }
22916 }
22917
22918 pub struct listEdgeIndexes<'mock> {
22919 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22920 dyn ::std::ops::FnMut(crate::types::ListEdgeIndexesReq) -> ::std::result::Result<
22921 crate::types::ListEdgeIndexesResp,
22922 crate::errors::meta_service::ListEdgeIndexesError,
22923 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22924 >>,
22925 }
22926
22927 #[allow(clippy::redundant_closure)]
22928 impl<'mock> listEdgeIndexes<'mock> {
22929 pub fn unimplemented() -> Self {
22930 Self {
22931 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListEdgeIndexesReq| panic!(
22932 "{}::{} is not mocked",
22933 "MetaService",
22934 "listEdgeIndexes",
22935 ))),
22936 }
22937 }
22938
22939 pub fn ret(&self, value: crate::types::ListEdgeIndexesResp) {
22940 self.mock(move |_: crate::types::ListEdgeIndexesReq| value.clone());
22941 }
22942
22943 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListEdgeIndexesReq) -> crate::types::ListEdgeIndexesResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22944 let mut closure = self.closure.lock().unwrap();
22945 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22946 }
22947
22948 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListEdgeIndexesReq) -> ::std::result::Result<crate::types::ListEdgeIndexesResp, crate::errors::meta_service::ListEdgeIndexesError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22949 let mut closure = self.closure.lock().unwrap();
22950 *closure = ::std::boxed::Box::new(move |req| mock(req));
22951 }
22952
22953 pub fn throw<E>(&self, exception: E)
22954 where
22955 E: ::std::convert::Into<crate::errors::meta_service::ListEdgeIndexesError>,
22956 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
22957 {
22958 let mut closure = self.closure.lock().unwrap();
22959 *closure = ::std::boxed::Box::new(move |_: crate::types::ListEdgeIndexesReq| ::std::result::Result::Err(exception.clone().into()));
22960 }
22961 }
22962
22963 pub struct rebuildEdgeIndex<'mock> {
22964 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
22965 dyn ::std::ops::FnMut(crate::types::RebuildIndexReq) -> ::std::result::Result<
22966 crate::types::ExecResp,
22967 crate::errors::meta_service::RebuildEdgeIndexError,
22968 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
22969 >>,
22970 }
22971
22972 #[allow(clippy::redundant_closure)]
22973 impl<'mock> rebuildEdgeIndex<'mock> {
22974 pub fn unimplemented() -> Self {
22975 Self {
22976 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::RebuildIndexReq| panic!(
22977 "{}::{} is not mocked",
22978 "MetaService",
22979 "rebuildEdgeIndex",
22980 ))),
22981 }
22982 }
22983
22984 pub fn ret(&self, value: crate::types::ExecResp) {
22985 self.mock(move |_: crate::types::RebuildIndexReq| value.clone());
22986 }
22987
22988 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::RebuildIndexReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22989 let mut closure = self.closure.lock().unwrap();
22990 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
22991 }
22992
22993 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::RebuildIndexReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RebuildEdgeIndexError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
22994 let mut closure = self.closure.lock().unwrap();
22995 *closure = ::std::boxed::Box::new(move |req| mock(req));
22996 }
22997
22998 pub fn throw<E>(&self, exception: E)
22999 where
23000 E: ::std::convert::Into<crate::errors::meta_service::RebuildEdgeIndexError>,
23001 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23002 {
23003 let mut closure = self.closure.lock().unwrap();
23004 *closure = ::std::boxed::Box::new(move |_: crate::types::RebuildIndexReq| ::std::result::Result::Err(exception.clone().into()));
23005 }
23006 }
23007
23008 pub struct listEdgeIndexStatus<'mock> {
23009 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23010 dyn ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> ::std::result::Result<
23011 crate::types::ListIndexStatusResp,
23012 crate::errors::meta_service::ListEdgeIndexStatusError,
23013 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23014 >>,
23015 }
23016
23017 #[allow(clippy::redundant_closure)]
23018 impl<'mock> listEdgeIndexStatus<'mock> {
23019 pub fn unimplemented() -> Self {
23020 Self {
23021 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListIndexStatusReq| panic!(
23022 "{}::{} is not mocked",
23023 "MetaService",
23024 "listEdgeIndexStatus",
23025 ))),
23026 }
23027 }
23028
23029 pub fn ret(&self, value: crate::types::ListIndexStatusResp) {
23030 self.mock(move |_: crate::types::ListIndexStatusReq| value.clone());
23031 }
23032
23033 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> crate::types::ListIndexStatusResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23034 let mut closure = self.closure.lock().unwrap();
23035 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23036 }
23037
23038 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListIndexStatusReq) -> ::std::result::Result<crate::types::ListIndexStatusResp, crate::errors::meta_service::ListEdgeIndexStatusError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23039 let mut closure = self.closure.lock().unwrap();
23040 *closure = ::std::boxed::Box::new(move |req| mock(req));
23041 }
23042
23043 pub fn throw<E>(&self, exception: E)
23044 where
23045 E: ::std::convert::Into<crate::errors::meta_service::ListEdgeIndexStatusError>,
23046 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23047 {
23048 let mut closure = self.closure.lock().unwrap();
23049 *closure = ::std::boxed::Box::new(move |_: crate::types::ListIndexStatusReq| ::std::result::Result::Err(exception.clone().into()));
23050 }
23051 }
23052
23053 pub struct createUser<'mock> {
23054 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23055 dyn ::std::ops::FnMut(crate::types::CreateUserReq) -> ::std::result::Result<
23056 crate::types::ExecResp,
23057 crate::errors::meta_service::CreateUserError,
23058 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23059 >>,
23060 }
23061
23062 #[allow(clippy::redundant_closure)]
23063 impl<'mock> createUser<'mock> {
23064 pub fn unimplemented() -> Self {
23065 Self {
23066 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::CreateUserReq| panic!(
23067 "{}::{} is not mocked",
23068 "MetaService",
23069 "createUser",
23070 ))),
23071 }
23072 }
23073
23074 pub fn ret(&self, value: crate::types::ExecResp) {
23075 self.mock(move |_: crate::types::CreateUserReq| value.clone());
23076 }
23077
23078 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateUserReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23079 let mut closure = self.closure.lock().unwrap();
23080 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23081 }
23082
23083 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateUserReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateUserError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23084 let mut closure = self.closure.lock().unwrap();
23085 *closure = ::std::boxed::Box::new(move |req| mock(req));
23086 }
23087
23088 pub fn throw<E>(&self, exception: E)
23089 where
23090 E: ::std::convert::Into<crate::errors::meta_service::CreateUserError>,
23091 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23092 {
23093 let mut closure = self.closure.lock().unwrap();
23094 *closure = ::std::boxed::Box::new(move |_: crate::types::CreateUserReq| ::std::result::Result::Err(exception.clone().into()));
23095 }
23096 }
23097
23098 pub struct dropUser<'mock> {
23099 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23100 dyn ::std::ops::FnMut(crate::types::DropUserReq) -> ::std::result::Result<
23101 crate::types::ExecResp,
23102 crate::errors::meta_service::DropUserError,
23103 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23104 >>,
23105 }
23106
23107 #[allow(clippy::redundant_closure)]
23108 impl<'mock> dropUser<'mock> {
23109 pub fn unimplemented() -> Self {
23110 Self {
23111 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::DropUserReq| panic!(
23112 "{}::{} is not mocked",
23113 "MetaService",
23114 "dropUser",
23115 ))),
23116 }
23117 }
23118
23119 pub fn ret(&self, value: crate::types::ExecResp) {
23120 self.mock(move |_: crate::types::DropUserReq| value.clone());
23121 }
23122
23123 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropUserReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23124 let mut closure = self.closure.lock().unwrap();
23125 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23126 }
23127
23128 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropUserReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropUserError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23129 let mut closure = self.closure.lock().unwrap();
23130 *closure = ::std::boxed::Box::new(move |req| mock(req));
23131 }
23132
23133 pub fn throw<E>(&self, exception: E)
23134 where
23135 E: ::std::convert::Into<crate::errors::meta_service::DropUserError>,
23136 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23137 {
23138 let mut closure = self.closure.lock().unwrap();
23139 *closure = ::std::boxed::Box::new(move |_: crate::types::DropUserReq| ::std::result::Result::Err(exception.clone().into()));
23140 }
23141 }
23142
23143 pub struct alterUser<'mock> {
23144 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23145 dyn ::std::ops::FnMut(crate::types::AlterUserReq) -> ::std::result::Result<
23146 crate::types::ExecResp,
23147 crate::errors::meta_service::AlterUserError,
23148 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23149 >>,
23150 }
23151
23152 #[allow(clippy::redundant_closure)]
23153 impl<'mock> alterUser<'mock> {
23154 pub fn unimplemented() -> Self {
23155 Self {
23156 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::AlterUserReq| panic!(
23157 "{}::{} is not mocked",
23158 "MetaService",
23159 "alterUser",
23160 ))),
23161 }
23162 }
23163
23164 pub fn ret(&self, value: crate::types::ExecResp) {
23165 self.mock(move |_: crate::types::AlterUserReq| value.clone());
23166 }
23167
23168 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::AlterUserReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23169 let mut closure = self.closure.lock().unwrap();
23170 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23171 }
23172
23173 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::AlterUserReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::AlterUserError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23174 let mut closure = self.closure.lock().unwrap();
23175 *closure = ::std::boxed::Box::new(move |req| mock(req));
23176 }
23177
23178 pub fn throw<E>(&self, exception: E)
23179 where
23180 E: ::std::convert::Into<crate::errors::meta_service::AlterUserError>,
23181 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23182 {
23183 let mut closure = self.closure.lock().unwrap();
23184 *closure = ::std::boxed::Box::new(move |_: crate::types::AlterUserReq| ::std::result::Result::Err(exception.clone().into()));
23185 }
23186 }
23187
23188 pub struct grantRole<'mock> {
23189 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23190 dyn ::std::ops::FnMut(crate::types::GrantRoleReq) -> ::std::result::Result<
23191 crate::types::ExecResp,
23192 crate::errors::meta_service::GrantRoleError,
23193 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23194 >>,
23195 }
23196
23197 #[allow(clippy::redundant_closure)]
23198 impl<'mock> grantRole<'mock> {
23199 pub fn unimplemented() -> Self {
23200 Self {
23201 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GrantRoleReq| panic!(
23202 "{}::{} is not mocked",
23203 "MetaService",
23204 "grantRole",
23205 ))),
23206 }
23207 }
23208
23209 pub fn ret(&self, value: crate::types::ExecResp) {
23210 self.mock(move |_: crate::types::GrantRoleReq| value.clone());
23211 }
23212
23213 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GrantRoleReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23214 let mut closure = self.closure.lock().unwrap();
23215 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23216 }
23217
23218 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GrantRoleReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::GrantRoleError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23219 let mut closure = self.closure.lock().unwrap();
23220 *closure = ::std::boxed::Box::new(move |req| mock(req));
23221 }
23222
23223 pub fn throw<E>(&self, exception: E)
23224 where
23225 E: ::std::convert::Into<crate::errors::meta_service::GrantRoleError>,
23226 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23227 {
23228 let mut closure = self.closure.lock().unwrap();
23229 *closure = ::std::boxed::Box::new(move |_: crate::types::GrantRoleReq| ::std::result::Result::Err(exception.clone().into()));
23230 }
23231 }
23232
23233 pub struct revokeRole<'mock> {
23234 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23235 dyn ::std::ops::FnMut(crate::types::RevokeRoleReq) -> ::std::result::Result<
23236 crate::types::ExecResp,
23237 crate::errors::meta_service::RevokeRoleError,
23238 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23239 >>,
23240 }
23241
23242 #[allow(clippy::redundant_closure)]
23243 impl<'mock> revokeRole<'mock> {
23244 pub fn unimplemented() -> Self {
23245 Self {
23246 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::RevokeRoleReq| panic!(
23247 "{}::{} is not mocked",
23248 "MetaService",
23249 "revokeRole",
23250 ))),
23251 }
23252 }
23253
23254 pub fn ret(&self, value: crate::types::ExecResp) {
23255 self.mock(move |_: crate::types::RevokeRoleReq| value.clone());
23256 }
23257
23258 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::RevokeRoleReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23259 let mut closure = self.closure.lock().unwrap();
23260 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23261 }
23262
23263 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::RevokeRoleReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RevokeRoleError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23264 let mut closure = self.closure.lock().unwrap();
23265 *closure = ::std::boxed::Box::new(move |req| mock(req));
23266 }
23267
23268 pub fn throw<E>(&self, exception: E)
23269 where
23270 E: ::std::convert::Into<crate::errors::meta_service::RevokeRoleError>,
23271 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23272 {
23273 let mut closure = self.closure.lock().unwrap();
23274 *closure = ::std::boxed::Box::new(move |_: crate::types::RevokeRoleReq| ::std::result::Result::Err(exception.clone().into()));
23275 }
23276 }
23277
23278 pub struct listUsers<'mock> {
23279 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23280 dyn ::std::ops::FnMut(crate::types::ListUsersReq) -> ::std::result::Result<
23281 crate::types::ListUsersResp,
23282 crate::errors::meta_service::ListUsersError,
23283 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23284 >>,
23285 }
23286
23287 #[allow(clippy::redundant_closure)]
23288 impl<'mock> listUsers<'mock> {
23289 pub fn unimplemented() -> Self {
23290 Self {
23291 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListUsersReq| panic!(
23292 "{}::{} is not mocked",
23293 "MetaService",
23294 "listUsers",
23295 ))),
23296 }
23297 }
23298
23299 pub fn ret(&self, value: crate::types::ListUsersResp) {
23300 self.mock(move |_: crate::types::ListUsersReq| value.clone());
23301 }
23302
23303 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListUsersReq) -> crate::types::ListUsersResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23304 let mut closure = self.closure.lock().unwrap();
23305 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23306 }
23307
23308 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListUsersReq) -> ::std::result::Result<crate::types::ListUsersResp, crate::errors::meta_service::ListUsersError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23309 let mut closure = self.closure.lock().unwrap();
23310 *closure = ::std::boxed::Box::new(move |req| mock(req));
23311 }
23312
23313 pub fn throw<E>(&self, exception: E)
23314 where
23315 E: ::std::convert::Into<crate::errors::meta_service::ListUsersError>,
23316 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23317 {
23318 let mut closure = self.closure.lock().unwrap();
23319 *closure = ::std::boxed::Box::new(move |_: crate::types::ListUsersReq| ::std::result::Result::Err(exception.clone().into()));
23320 }
23321 }
23322
23323 pub struct listRoles<'mock> {
23324 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23325 dyn ::std::ops::FnMut(crate::types::ListRolesReq) -> ::std::result::Result<
23326 crate::types::ListRolesResp,
23327 crate::errors::meta_service::ListRolesError,
23328 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23329 >>,
23330 }
23331
23332 #[allow(clippy::redundant_closure)]
23333 impl<'mock> listRoles<'mock> {
23334 pub fn unimplemented() -> Self {
23335 Self {
23336 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListRolesReq| panic!(
23337 "{}::{} is not mocked",
23338 "MetaService",
23339 "listRoles",
23340 ))),
23341 }
23342 }
23343
23344 pub fn ret(&self, value: crate::types::ListRolesResp) {
23345 self.mock(move |_: crate::types::ListRolesReq| value.clone());
23346 }
23347
23348 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListRolesReq) -> crate::types::ListRolesResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23349 let mut closure = self.closure.lock().unwrap();
23350 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23351 }
23352
23353 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListRolesReq) -> ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::ListRolesError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23354 let mut closure = self.closure.lock().unwrap();
23355 *closure = ::std::boxed::Box::new(move |req| mock(req));
23356 }
23357
23358 pub fn throw<E>(&self, exception: E)
23359 where
23360 E: ::std::convert::Into<crate::errors::meta_service::ListRolesError>,
23361 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23362 {
23363 let mut closure = self.closure.lock().unwrap();
23364 *closure = ::std::boxed::Box::new(move |_: crate::types::ListRolesReq| ::std::result::Result::Err(exception.clone().into()));
23365 }
23366 }
23367
23368 pub struct getUserRoles<'mock> {
23369 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23370 dyn ::std::ops::FnMut(crate::types::GetUserRolesReq) -> ::std::result::Result<
23371 crate::types::ListRolesResp,
23372 crate::errors::meta_service::GetUserRolesError,
23373 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23374 >>,
23375 }
23376
23377 #[allow(clippy::redundant_closure)]
23378 impl<'mock> getUserRoles<'mock> {
23379 pub fn unimplemented() -> Self {
23380 Self {
23381 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetUserRolesReq| panic!(
23382 "{}::{} is not mocked",
23383 "MetaService",
23384 "getUserRoles",
23385 ))),
23386 }
23387 }
23388
23389 pub fn ret(&self, value: crate::types::ListRolesResp) {
23390 self.mock(move |_: crate::types::GetUserRolesReq| value.clone());
23391 }
23392
23393 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetUserRolesReq) -> crate::types::ListRolesResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23394 let mut closure = self.closure.lock().unwrap();
23395 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23396 }
23397
23398 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetUserRolesReq) -> ::std::result::Result<crate::types::ListRolesResp, crate::errors::meta_service::GetUserRolesError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23399 let mut closure = self.closure.lock().unwrap();
23400 *closure = ::std::boxed::Box::new(move |req| mock(req));
23401 }
23402
23403 pub fn throw<E>(&self, exception: E)
23404 where
23405 E: ::std::convert::Into<crate::errors::meta_service::GetUserRolesError>,
23406 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23407 {
23408 let mut closure = self.closure.lock().unwrap();
23409 *closure = ::std::boxed::Box::new(move |_: crate::types::GetUserRolesReq| ::std::result::Result::Err(exception.clone().into()));
23410 }
23411 }
23412
23413 pub struct changePassword<'mock> {
23414 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23415 dyn ::std::ops::FnMut(crate::types::ChangePasswordReq) -> ::std::result::Result<
23416 crate::types::ExecResp,
23417 crate::errors::meta_service::ChangePasswordError,
23418 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23419 >>,
23420 }
23421
23422 #[allow(clippy::redundant_closure)]
23423 impl<'mock> changePassword<'mock> {
23424 pub fn unimplemented() -> Self {
23425 Self {
23426 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ChangePasswordReq| panic!(
23427 "{}::{} is not mocked",
23428 "MetaService",
23429 "changePassword",
23430 ))),
23431 }
23432 }
23433
23434 pub fn ret(&self, value: crate::types::ExecResp) {
23435 self.mock(move |_: crate::types::ChangePasswordReq| value.clone());
23436 }
23437
23438 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ChangePasswordReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23439 let mut closure = self.closure.lock().unwrap();
23440 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23441 }
23442
23443 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ChangePasswordReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::ChangePasswordError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23444 let mut closure = self.closure.lock().unwrap();
23445 *closure = ::std::boxed::Box::new(move |req| mock(req));
23446 }
23447
23448 pub fn throw<E>(&self, exception: E)
23449 where
23450 E: ::std::convert::Into<crate::errors::meta_service::ChangePasswordError>,
23451 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23452 {
23453 let mut closure = self.closure.lock().unwrap();
23454 *closure = ::std::boxed::Box::new(move |_: crate::types::ChangePasswordReq| ::std::result::Result::Err(exception.clone().into()));
23455 }
23456 }
23457
23458 pub struct heartBeat<'mock> {
23459 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23460 dyn ::std::ops::FnMut(crate::types::HBReq) -> ::std::result::Result<
23461 crate::types::HBResp,
23462 crate::errors::meta_service::HeartBeatError,
23463 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23464 >>,
23465 }
23466
23467 #[allow(clippy::redundant_closure)]
23468 impl<'mock> heartBeat<'mock> {
23469 pub fn unimplemented() -> Self {
23470 Self {
23471 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::HBReq| panic!(
23472 "{}::{} is not mocked",
23473 "MetaService",
23474 "heartBeat",
23475 ))),
23476 }
23477 }
23478
23479 pub fn ret(&self, value: crate::types::HBResp) {
23480 self.mock(move |_: crate::types::HBReq| value.clone());
23481 }
23482
23483 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::HBReq) -> crate::types::HBResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23484 let mut closure = self.closure.lock().unwrap();
23485 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23486 }
23487
23488 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::HBReq) -> ::std::result::Result<crate::types::HBResp, crate::errors::meta_service::HeartBeatError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23489 let mut closure = self.closure.lock().unwrap();
23490 *closure = ::std::boxed::Box::new(move |req| mock(req));
23491 }
23492
23493 pub fn throw<E>(&self, exception: E)
23494 where
23495 E: ::std::convert::Into<crate::errors::meta_service::HeartBeatError>,
23496 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23497 {
23498 let mut closure = self.closure.lock().unwrap();
23499 *closure = ::std::boxed::Box::new(move |_: crate::types::HBReq| ::std::result::Result::Err(exception.clone().into()));
23500 }
23501 }
23502
23503 pub struct balance<'mock> {
23504 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23505 dyn ::std::ops::FnMut(crate::types::BalanceReq) -> ::std::result::Result<
23506 crate::types::BalanceResp,
23507 crate::errors::meta_service::BalanceError,
23508 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23509 >>,
23510 }
23511
23512 #[allow(clippy::redundant_closure)]
23513 impl<'mock> balance<'mock> {
23514 pub fn unimplemented() -> Self {
23515 Self {
23516 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::BalanceReq| panic!(
23517 "{}::{} is not mocked",
23518 "MetaService",
23519 "balance",
23520 ))),
23521 }
23522 }
23523
23524 pub fn ret(&self, value: crate::types::BalanceResp) {
23525 self.mock(move |_: crate::types::BalanceReq| value.clone());
23526 }
23527
23528 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::BalanceReq) -> crate::types::BalanceResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23529 let mut closure = self.closure.lock().unwrap();
23530 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23531 }
23532
23533 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::BalanceReq) -> ::std::result::Result<crate::types::BalanceResp, crate::errors::meta_service::BalanceError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23534 let mut closure = self.closure.lock().unwrap();
23535 *closure = ::std::boxed::Box::new(move |req| mock(req));
23536 }
23537
23538 pub fn throw<E>(&self, exception: E)
23539 where
23540 E: ::std::convert::Into<crate::errors::meta_service::BalanceError>,
23541 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23542 {
23543 let mut closure = self.closure.lock().unwrap();
23544 *closure = ::std::boxed::Box::new(move |_: crate::types::BalanceReq| ::std::result::Result::Err(exception.clone().into()));
23545 }
23546 }
23547
23548 pub struct leaderBalance<'mock> {
23549 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23550 dyn ::std::ops::FnMut(crate::types::LeaderBalanceReq) -> ::std::result::Result<
23551 crate::types::ExecResp,
23552 crate::errors::meta_service::LeaderBalanceError,
23553 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23554 >>,
23555 }
23556
23557 #[allow(clippy::redundant_closure)]
23558 impl<'mock> leaderBalance<'mock> {
23559 pub fn unimplemented() -> Self {
23560 Self {
23561 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::LeaderBalanceReq| panic!(
23562 "{}::{} is not mocked",
23563 "MetaService",
23564 "leaderBalance",
23565 ))),
23566 }
23567 }
23568
23569 pub fn ret(&self, value: crate::types::ExecResp) {
23570 self.mock(move |_: crate::types::LeaderBalanceReq| value.clone());
23571 }
23572
23573 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::LeaderBalanceReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23574 let mut closure = self.closure.lock().unwrap();
23575 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23576 }
23577
23578 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::LeaderBalanceReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::LeaderBalanceError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23579 let mut closure = self.closure.lock().unwrap();
23580 *closure = ::std::boxed::Box::new(move |req| mock(req));
23581 }
23582
23583 pub fn throw<E>(&self, exception: E)
23584 where
23585 E: ::std::convert::Into<crate::errors::meta_service::LeaderBalanceError>,
23586 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23587 {
23588 let mut closure = self.closure.lock().unwrap();
23589 *closure = ::std::boxed::Box::new(move |_: crate::types::LeaderBalanceReq| ::std::result::Result::Err(exception.clone().into()));
23590 }
23591 }
23592
23593 pub struct regConfig<'mock> {
23594 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23595 dyn ::std::ops::FnMut(crate::types::RegConfigReq) -> ::std::result::Result<
23596 crate::types::ExecResp,
23597 crate::errors::meta_service::RegConfigError,
23598 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23599 >>,
23600 }
23601
23602 #[allow(clippy::redundant_closure)]
23603 impl<'mock> regConfig<'mock> {
23604 pub fn unimplemented() -> Self {
23605 Self {
23606 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::RegConfigReq| panic!(
23607 "{}::{} is not mocked",
23608 "MetaService",
23609 "regConfig",
23610 ))),
23611 }
23612 }
23613
23614 pub fn ret(&self, value: crate::types::ExecResp) {
23615 self.mock(move |_: crate::types::RegConfigReq| value.clone());
23616 }
23617
23618 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::RegConfigReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23619 let mut closure = self.closure.lock().unwrap();
23620 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23621 }
23622
23623 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::RegConfigReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::RegConfigError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23624 let mut closure = self.closure.lock().unwrap();
23625 *closure = ::std::boxed::Box::new(move |req| mock(req));
23626 }
23627
23628 pub fn throw<E>(&self, exception: E)
23629 where
23630 E: ::std::convert::Into<crate::errors::meta_service::RegConfigError>,
23631 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23632 {
23633 let mut closure = self.closure.lock().unwrap();
23634 *closure = ::std::boxed::Box::new(move |_: crate::types::RegConfigReq| ::std::result::Result::Err(exception.clone().into()));
23635 }
23636 }
23637
23638 pub struct getConfig<'mock> {
23639 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23640 dyn ::std::ops::FnMut(crate::types::GetConfigReq) -> ::std::result::Result<
23641 crate::types::GetConfigResp,
23642 crate::errors::meta_service::GetConfigError,
23643 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23644 >>,
23645 }
23646
23647 #[allow(clippy::redundant_closure)]
23648 impl<'mock> getConfig<'mock> {
23649 pub fn unimplemented() -> Self {
23650 Self {
23651 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::GetConfigReq| panic!(
23652 "{}::{} is not mocked",
23653 "MetaService",
23654 "getConfig",
23655 ))),
23656 }
23657 }
23658
23659 pub fn ret(&self, value: crate::types::GetConfigResp) {
23660 self.mock(move |_: crate::types::GetConfigReq| value.clone());
23661 }
23662
23663 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetConfigReq) -> crate::types::GetConfigResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23664 let mut closure = self.closure.lock().unwrap();
23665 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23666 }
23667
23668 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::GetConfigReq) -> ::std::result::Result<crate::types::GetConfigResp, crate::errors::meta_service::GetConfigError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23669 let mut closure = self.closure.lock().unwrap();
23670 *closure = ::std::boxed::Box::new(move |req| mock(req));
23671 }
23672
23673 pub fn throw<E>(&self, exception: E)
23674 where
23675 E: ::std::convert::Into<crate::errors::meta_service::GetConfigError>,
23676 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23677 {
23678 let mut closure = self.closure.lock().unwrap();
23679 *closure = ::std::boxed::Box::new(move |_: crate::types::GetConfigReq| ::std::result::Result::Err(exception.clone().into()));
23680 }
23681 }
23682
23683 pub struct setConfig<'mock> {
23684 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23685 dyn ::std::ops::FnMut(crate::types::SetConfigReq) -> ::std::result::Result<
23686 crate::types::ExecResp,
23687 crate::errors::meta_service::SetConfigError,
23688 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23689 >>,
23690 }
23691
23692 #[allow(clippy::redundant_closure)]
23693 impl<'mock> setConfig<'mock> {
23694 pub fn unimplemented() -> Self {
23695 Self {
23696 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::SetConfigReq| panic!(
23697 "{}::{} is not mocked",
23698 "MetaService",
23699 "setConfig",
23700 ))),
23701 }
23702 }
23703
23704 pub fn ret(&self, value: crate::types::ExecResp) {
23705 self.mock(move |_: crate::types::SetConfigReq| value.clone());
23706 }
23707
23708 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::SetConfigReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23709 let mut closure = self.closure.lock().unwrap();
23710 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23711 }
23712
23713 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::SetConfigReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::SetConfigError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23714 let mut closure = self.closure.lock().unwrap();
23715 *closure = ::std::boxed::Box::new(move |req| mock(req));
23716 }
23717
23718 pub fn throw<E>(&self, exception: E)
23719 where
23720 E: ::std::convert::Into<crate::errors::meta_service::SetConfigError>,
23721 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23722 {
23723 let mut closure = self.closure.lock().unwrap();
23724 *closure = ::std::boxed::Box::new(move |_: crate::types::SetConfigReq| ::std::result::Result::Err(exception.clone().into()));
23725 }
23726 }
23727
23728 pub struct listConfigs<'mock> {
23729 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23730 dyn ::std::ops::FnMut(crate::types::ListConfigsReq) -> ::std::result::Result<
23731 crate::types::ListConfigsResp,
23732 crate::errors::meta_service::ListConfigsError,
23733 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23734 >>,
23735 }
23736
23737 #[allow(clippy::redundant_closure)]
23738 impl<'mock> listConfigs<'mock> {
23739 pub fn unimplemented() -> Self {
23740 Self {
23741 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListConfigsReq| panic!(
23742 "{}::{} is not mocked",
23743 "MetaService",
23744 "listConfigs",
23745 ))),
23746 }
23747 }
23748
23749 pub fn ret(&self, value: crate::types::ListConfigsResp) {
23750 self.mock(move |_: crate::types::ListConfigsReq| value.clone());
23751 }
23752
23753 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListConfigsReq) -> crate::types::ListConfigsResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23754 let mut closure = self.closure.lock().unwrap();
23755 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23756 }
23757
23758 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListConfigsReq) -> ::std::result::Result<crate::types::ListConfigsResp, crate::errors::meta_service::ListConfigsError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23759 let mut closure = self.closure.lock().unwrap();
23760 *closure = ::std::boxed::Box::new(move |req| mock(req));
23761 }
23762
23763 pub fn throw<E>(&self, exception: E)
23764 where
23765 E: ::std::convert::Into<crate::errors::meta_service::ListConfigsError>,
23766 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23767 {
23768 let mut closure = self.closure.lock().unwrap();
23769 *closure = ::std::boxed::Box::new(move |_: crate::types::ListConfigsReq| ::std::result::Result::Err(exception.clone().into()));
23770 }
23771 }
23772
23773 pub struct createSnapshot<'mock> {
23774 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23775 dyn ::std::ops::FnMut(crate::types::CreateSnapshotReq) -> ::std::result::Result<
23776 crate::types::ExecResp,
23777 crate::errors::meta_service::CreateSnapshotError,
23778 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23779 >>,
23780 }
23781
23782 #[allow(clippy::redundant_closure)]
23783 impl<'mock> createSnapshot<'mock> {
23784 pub fn unimplemented() -> Self {
23785 Self {
23786 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::CreateSnapshotReq| panic!(
23787 "{}::{} is not mocked",
23788 "MetaService",
23789 "createSnapshot",
23790 ))),
23791 }
23792 }
23793
23794 pub fn ret(&self, value: crate::types::ExecResp) {
23795 self.mock(move |_: crate::types::CreateSnapshotReq| value.clone());
23796 }
23797
23798 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateSnapshotReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23799 let mut closure = self.closure.lock().unwrap();
23800 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23801 }
23802
23803 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::CreateSnapshotReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::CreateSnapshotError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23804 let mut closure = self.closure.lock().unwrap();
23805 *closure = ::std::boxed::Box::new(move |req| mock(req));
23806 }
23807
23808 pub fn throw<E>(&self, exception: E)
23809 where
23810 E: ::std::convert::Into<crate::errors::meta_service::CreateSnapshotError>,
23811 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23812 {
23813 let mut closure = self.closure.lock().unwrap();
23814 *closure = ::std::boxed::Box::new(move |_: crate::types::CreateSnapshotReq| ::std::result::Result::Err(exception.clone().into()));
23815 }
23816 }
23817
23818 pub struct dropSnapshot<'mock> {
23819 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23820 dyn ::std::ops::FnMut(crate::types::DropSnapshotReq) -> ::std::result::Result<
23821 crate::types::ExecResp,
23822 crate::errors::meta_service::DropSnapshotError,
23823 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23824 >>,
23825 }
23826
23827 #[allow(clippy::redundant_closure)]
23828 impl<'mock> dropSnapshot<'mock> {
23829 pub fn unimplemented() -> Self {
23830 Self {
23831 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::DropSnapshotReq| panic!(
23832 "{}::{} is not mocked",
23833 "MetaService",
23834 "dropSnapshot",
23835 ))),
23836 }
23837 }
23838
23839 pub fn ret(&self, value: crate::types::ExecResp) {
23840 self.mock(move |_: crate::types::DropSnapshotReq| value.clone());
23841 }
23842
23843 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropSnapshotReq) -> crate::types::ExecResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23844 let mut closure = self.closure.lock().unwrap();
23845 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23846 }
23847
23848 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::DropSnapshotReq) -> ::std::result::Result<crate::types::ExecResp, crate::errors::meta_service::DropSnapshotError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23849 let mut closure = self.closure.lock().unwrap();
23850 *closure = ::std::boxed::Box::new(move |req| mock(req));
23851 }
23852
23853 pub fn throw<E>(&self, exception: E)
23854 where
23855 E: ::std::convert::Into<crate::errors::meta_service::DropSnapshotError>,
23856 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23857 {
23858 let mut closure = self.closure.lock().unwrap();
23859 *closure = ::std::boxed::Box::new(move |_: crate::types::DropSnapshotReq| ::std::result::Result::Err(exception.clone().into()));
23860 }
23861 }
23862
23863 pub struct listSnapshots<'mock> {
23864 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23865 dyn ::std::ops::FnMut(crate::types::ListSnapshotsReq) -> ::std::result::Result<
23866 crate::types::ListSnapshotsResp,
23867 crate::errors::meta_service::ListSnapshotsError,
23868 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23869 >>,
23870 }
23871
23872 #[allow(clippy::redundant_closure)]
23873 impl<'mock> listSnapshots<'mock> {
23874 pub fn unimplemented() -> Self {
23875 Self {
23876 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::ListSnapshotsReq| panic!(
23877 "{}::{} is not mocked",
23878 "MetaService",
23879 "listSnapshots",
23880 ))),
23881 }
23882 }
23883
23884 pub fn ret(&self, value: crate::types::ListSnapshotsResp) {
23885 self.mock(move |_: crate::types::ListSnapshotsReq| value.clone());
23886 }
23887
23888 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListSnapshotsReq) -> crate::types::ListSnapshotsResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23889 let mut closure = self.closure.lock().unwrap();
23890 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23891 }
23892
23893 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::ListSnapshotsReq) -> ::std::result::Result<crate::types::ListSnapshotsResp, crate::errors::meta_service::ListSnapshotsError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23894 let mut closure = self.closure.lock().unwrap();
23895 *closure = ::std::boxed::Box::new(move |req| mock(req));
23896 }
23897
23898 pub fn throw<E>(&self, exception: E)
23899 where
23900 E: ::std::convert::Into<crate::errors::meta_service::ListSnapshotsError>,
23901 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23902 {
23903 let mut closure = self.closure.lock().unwrap();
23904 *closure = ::std::boxed::Box::new(move |_: crate::types::ListSnapshotsReq| ::std::result::Result::Err(exception.clone().into()));
23905 }
23906 }
23907
23908 pub struct runAdminJob<'mock> {
23909 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
23910 dyn ::std::ops::FnMut(crate::types::AdminJobReq) -> ::std::result::Result<
23911 crate::types::AdminJobResp,
23912 crate::errors::meta_service::RunAdminJobError,
23913 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
23914 >>,
23915 }
23916
23917 #[allow(clippy::redundant_closure)]
23918 impl<'mock> runAdminJob<'mock> {
23919 pub fn unimplemented() -> Self {
23920 Self {
23921 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::AdminJobReq| panic!(
23922 "{}::{} is not mocked",
23923 "MetaService",
23924 "runAdminJob",
23925 ))),
23926 }
23927 }
23928
23929 pub fn ret(&self, value: crate::types::AdminJobResp) {
23930 self.mock(move |_: crate::types::AdminJobReq| value.clone());
23931 }
23932
23933 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::AdminJobReq) -> crate::types::AdminJobResp + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23934 let mut closure = self.closure.lock().unwrap();
23935 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
23936 }
23937
23938 pub fn mock_result(&self, mut mock: impl ::std::ops::FnMut(crate::types::AdminJobReq) -> ::std::result::Result<crate::types::AdminJobResp, crate::errors::meta_service::RunAdminJobError> + ::std::marker::Send + ::std::marker::Sync + 'mock) {
23939 let mut closure = self.closure.lock().unwrap();
23940 *closure = ::std::boxed::Box::new(move |req| mock(req));
23941 }
23942
23943 pub fn throw<E>(&self, exception: E)
23944 where
23945 E: ::std::convert::Into<crate::errors::meta_service::RunAdminJobError>,
23946 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
23947 {
23948 let mut closure = self.closure.lock().unwrap();
23949 *closure = ::std::boxed::Box::new(move |_: crate::types::AdminJobReq| ::std::result::Result::Err(exception.clone().into()));
23950 }
23951 }
23952 }
23953 }
23954}
23955
23956pub mod errors {
23958 pub mod meta_service {
23960
23961 pub type CreateSpaceError = ::fbthrift::NonthrowingFunctionError;
23962
23963 impl ::std::convert::From<crate::services::meta_service::CreateSpaceExn> for
23964 ::std::result::Result<crate::types::ExecResp, CreateSpaceError>
23965 {
23966 fn from(e: crate::services::meta_service::CreateSpaceExn) -> Self {
23967 match e {
23968 crate::services::meta_service::CreateSpaceExn::Success(res) => {
23969 ::std::result::Result::Ok(res)
23970 }
23971 crate::services::meta_service::CreateSpaceExn::ApplicationException(aexn) =>
23972 ::std::result::Result::Err(CreateSpaceError::ApplicationException(aexn)),
23973 }
23974 }
23975 }
23976
23977 pub type DropSpaceError = ::fbthrift::NonthrowingFunctionError;
23978
23979 impl ::std::convert::From<crate::services::meta_service::DropSpaceExn> for
23980 ::std::result::Result<crate::types::ExecResp, DropSpaceError>
23981 {
23982 fn from(e: crate::services::meta_service::DropSpaceExn) -> Self {
23983 match e {
23984 crate::services::meta_service::DropSpaceExn::Success(res) => {
23985 ::std::result::Result::Ok(res)
23986 }
23987 crate::services::meta_service::DropSpaceExn::ApplicationException(aexn) =>
23988 ::std::result::Result::Err(DropSpaceError::ApplicationException(aexn)),
23989 }
23990 }
23991 }
23992
23993 pub type GetSpaceError = ::fbthrift::NonthrowingFunctionError;
23994
23995 impl ::std::convert::From<crate::services::meta_service::GetSpaceExn> for
23996 ::std::result::Result<crate::types::GetSpaceResp, GetSpaceError>
23997 {
23998 fn from(e: crate::services::meta_service::GetSpaceExn) -> Self {
23999 match e {
24000 crate::services::meta_service::GetSpaceExn::Success(res) => {
24001 ::std::result::Result::Ok(res)
24002 }
24003 crate::services::meta_service::GetSpaceExn::ApplicationException(aexn) =>
24004 ::std::result::Result::Err(GetSpaceError::ApplicationException(aexn)),
24005 }
24006 }
24007 }
24008
24009 pub type ListSpacesError = ::fbthrift::NonthrowingFunctionError;
24010
24011 impl ::std::convert::From<crate::services::meta_service::ListSpacesExn> for
24012 ::std::result::Result<crate::types::ListSpacesResp, ListSpacesError>
24013 {
24014 fn from(e: crate::services::meta_service::ListSpacesExn) -> Self {
24015 match e {
24016 crate::services::meta_service::ListSpacesExn::Success(res) => {
24017 ::std::result::Result::Ok(res)
24018 }
24019 crate::services::meta_service::ListSpacesExn::ApplicationException(aexn) =>
24020 ::std::result::Result::Err(ListSpacesError::ApplicationException(aexn)),
24021 }
24022 }
24023 }
24024
24025 pub type CreateTagError = ::fbthrift::NonthrowingFunctionError;
24026
24027 impl ::std::convert::From<crate::services::meta_service::CreateTagExn> for
24028 ::std::result::Result<crate::types::ExecResp, CreateTagError>
24029 {
24030 fn from(e: crate::services::meta_service::CreateTagExn) -> Self {
24031 match e {
24032 crate::services::meta_service::CreateTagExn::Success(res) => {
24033 ::std::result::Result::Ok(res)
24034 }
24035 crate::services::meta_service::CreateTagExn::ApplicationException(aexn) =>
24036 ::std::result::Result::Err(CreateTagError::ApplicationException(aexn)),
24037 }
24038 }
24039 }
24040
24041 pub type AlterTagError = ::fbthrift::NonthrowingFunctionError;
24042
24043 impl ::std::convert::From<crate::services::meta_service::AlterTagExn> for
24044 ::std::result::Result<crate::types::ExecResp, AlterTagError>
24045 {
24046 fn from(e: crate::services::meta_service::AlterTagExn) -> Self {
24047 match e {
24048 crate::services::meta_service::AlterTagExn::Success(res) => {
24049 ::std::result::Result::Ok(res)
24050 }
24051 crate::services::meta_service::AlterTagExn::ApplicationException(aexn) =>
24052 ::std::result::Result::Err(AlterTagError::ApplicationException(aexn)),
24053 }
24054 }
24055 }
24056
24057 pub type DropTagError = ::fbthrift::NonthrowingFunctionError;
24058
24059 impl ::std::convert::From<crate::services::meta_service::DropTagExn> for
24060 ::std::result::Result<crate::types::ExecResp, DropTagError>
24061 {
24062 fn from(e: crate::services::meta_service::DropTagExn) -> Self {
24063 match e {
24064 crate::services::meta_service::DropTagExn::Success(res) => {
24065 ::std::result::Result::Ok(res)
24066 }
24067 crate::services::meta_service::DropTagExn::ApplicationException(aexn) =>
24068 ::std::result::Result::Err(DropTagError::ApplicationException(aexn)),
24069 }
24070 }
24071 }
24072
24073 pub type GetTagError = ::fbthrift::NonthrowingFunctionError;
24074
24075 impl ::std::convert::From<crate::services::meta_service::GetTagExn> for
24076 ::std::result::Result<crate::types::GetTagResp, GetTagError>
24077 {
24078 fn from(e: crate::services::meta_service::GetTagExn) -> Self {
24079 match e {
24080 crate::services::meta_service::GetTagExn::Success(res) => {
24081 ::std::result::Result::Ok(res)
24082 }
24083 crate::services::meta_service::GetTagExn::ApplicationException(aexn) =>
24084 ::std::result::Result::Err(GetTagError::ApplicationException(aexn)),
24085 }
24086 }
24087 }
24088
24089 pub type ListTagsError = ::fbthrift::NonthrowingFunctionError;
24090
24091 impl ::std::convert::From<crate::services::meta_service::ListTagsExn> for
24092 ::std::result::Result<crate::types::ListTagsResp, ListTagsError>
24093 {
24094 fn from(e: crate::services::meta_service::ListTagsExn) -> Self {
24095 match e {
24096 crate::services::meta_service::ListTagsExn::Success(res) => {
24097 ::std::result::Result::Ok(res)
24098 }
24099 crate::services::meta_service::ListTagsExn::ApplicationException(aexn) =>
24100 ::std::result::Result::Err(ListTagsError::ApplicationException(aexn)),
24101 }
24102 }
24103 }
24104
24105 pub type CreateEdgeError = ::fbthrift::NonthrowingFunctionError;
24106
24107 impl ::std::convert::From<crate::services::meta_service::CreateEdgeExn> for
24108 ::std::result::Result<crate::types::ExecResp, CreateEdgeError>
24109 {
24110 fn from(e: crate::services::meta_service::CreateEdgeExn) -> Self {
24111 match e {
24112 crate::services::meta_service::CreateEdgeExn::Success(res) => {
24113 ::std::result::Result::Ok(res)
24114 }
24115 crate::services::meta_service::CreateEdgeExn::ApplicationException(aexn) =>
24116 ::std::result::Result::Err(CreateEdgeError::ApplicationException(aexn)),
24117 }
24118 }
24119 }
24120
24121 pub type AlterEdgeError = ::fbthrift::NonthrowingFunctionError;
24122
24123 impl ::std::convert::From<crate::services::meta_service::AlterEdgeExn> for
24124 ::std::result::Result<crate::types::ExecResp, AlterEdgeError>
24125 {
24126 fn from(e: crate::services::meta_service::AlterEdgeExn) -> Self {
24127 match e {
24128 crate::services::meta_service::AlterEdgeExn::Success(res) => {
24129 ::std::result::Result::Ok(res)
24130 }
24131 crate::services::meta_service::AlterEdgeExn::ApplicationException(aexn) =>
24132 ::std::result::Result::Err(AlterEdgeError::ApplicationException(aexn)),
24133 }
24134 }
24135 }
24136
24137 pub type DropEdgeError = ::fbthrift::NonthrowingFunctionError;
24138
24139 impl ::std::convert::From<crate::services::meta_service::DropEdgeExn> for
24140 ::std::result::Result<crate::types::ExecResp, DropEdgeError>
24141 {
24142 fn from(e: crate::services::meta_service::DropEdgeExn) -> Self {
24143 match e {
24144 crate::services::meta_service::DropEdgeExn::Success(res) => {
24145 ::std::result::Result::Ok(res)
24146 }
24147 crate::services::meta_service::DropEdgeExn::ApplicationException(aexn) =>
24148 ::std::result::Result::Err(DropEdgeError::ApplicationException(aexn)),
24149 }
24150 }
24151 }
24152
24153 pub type GetEdgeError = ::fbthrift::NonthrowingFunctionError;
24154
24155 impl ::std::convert::From<crate::services::meta_service::GetEdgeExn> for
24156 ::std::result::Result<crate::types::GetEdgeResp, GetEdgeError>
24157 {
24158 fn from(e: crate::services::meta_service::GetEdgeExn) -> Self {
24159 match e {
24160 crate::services::meta_service::GetEdgeExn::Success(res) => {
24161 ::std::result::Result::Ok(res)
24162 }
24163 crate::services::meta_service::GetEdgeExn::ApplicationException(aexn) =>
24164 ::std::result::Result::Err(GetEdgeError::ApplicationException(aexn)),
24165 }
24166 }
24167 }
24168
24169 pub type ListEdgesError = ::fbthrift::NonthrowingFunctionError;
24170
24171 impl ::std::convert::From<crate::services::meta_service::ListEdgesExn> for
24172 ::std::result::Result<crate::types::ListEdgesResp, ListEdgesError>
24173 {
24174 fn from(e: crate::services::meta_service::ListEdgesExn) -> Self {
24175 match e {
24176 crate::services::meta_service::ListEdgesExn::Success(res) => {
24177 ::std::result::Result::Ok(res)
24178 }
24179 crate::services::meta_service::ListEdgesExn::ApplicationException(aexn) =>
24180 ::std::result::Result::Err(ListEdgesError::ApplicationException(aexn)),
24181 }
24182 }
24183 }
24184
24185 pub type ListHostsError = ::fbthrift::NonthrowingFunctionError;
24186
24187 impl ::std::convert::From<crate::services::meta_service::ListHostsExn> for
24188 ::std::result::Result<crate::types::ListHostsResp, ListHostsError>
24189 {
24190 fn from(e: crate::services::meta_service::ListHostsExn) -> Self {
24191 match e {
24192 crate::services::meta_service::ListHostsExn::Success(res) => {
24193 ::std::result::Result::Ok(res)
24194 }
24195 crate::services::meta_service::ListHostsExn::ApplicationException(aexn) =>
24196 ::std::result::Result::Err(ListHostsError::ApplicationException(aexn)),
24197 }
24198 }
24199 }
24200
24201 pub type GetPartsAllocError = ::fbthrift::NonthrowingFunctionError;
24202
24203 impl ::std::convert::From<crate::services::meta_service::GetPartsAllocExn> for
24204 ::std::result::Result<crate::types::GetPartsAllocResp, GetPartsAllocError>
24205 {
24206 fn from(e: crate::services::meta_service::GetPartsAllocExn) -> Self {
24207 match e {
24208 crate::services::meta_service::GetPartsAllocExn::Success(res) => {
24209 ::std::result::Result::Ok(res)
24210 }
24211 crate::services::meta_service::GetPartsAllocExn::ApplicationException(aexn) =>
24212 ::std::result::Result::Err(GetPartsAllocError::ApplicationException(aexn)),
24213 }
24214 }
24215 }
24216
24217 pub type ListPartsError = ::fbthrift::NonthrowingFunctionError;
24218
24219 impl ::std::convert::From<crate::services::meta_service::ListPartsExn> for
24220 ::std::result::Result<crate::types::ListPartsResp, ListPartsError>
24221 {
24222 fn from(e: crate::services::meta_service::ListPartsExn) -> Self {
24223 match e {
24224 crate::services::meta_service::ListPartsExn::Success(res) => {
24225 ::std::result::Result::Ok(res)
24226 }
24227 crate::services::meta_service::ListPartsExn::ApplicationException(aexn) =>
24228 ::std::result::Result::Err(ListPartsError::ApplicationException(aexn)),
24229 }
24230 }
24231 }
24232
24233 pub type MultiPutError = ::fbthrift::NonthrowingFunctionError;
24234
24235 impl ::std::convert::From<crate::services::meta_service::MultiPutExn> for
24236 ::std::result::Result<crate::types::ExecResp, MultiPutError>
24237 {
24238 fn from(e: crate::services::meta_service::MultiPutExn) -> Self {
24239 match e {
24240 crate::services::meta_service::MultiPutExn::Success(res) => {
24241 ::std::result::Result::Ok(res)
24242 }
24243 crate::services::meta_service::MultiPutExn::ApplicationException(aexn) =>
24244 ::std::result::Result::Err(MultiPutError::ApplicationException(aexn)),
24245 }
24246 }
24247 }
24248
24249 pub type GetError = ::fbthrift::NonthrowingFunctionError;
24250
24251 impl ::std::convert::From<crate::services::meta_service::GetExn> for
24252 ::std::result::Result<crate::types::GetResp, GetError>
24253 {
24254 fn from(e: crate::services::meta_service::GetExn) -> Self {
24255 match e {
24256 crate::services::meta_service::GetExn::Success(res) => {
24257 ::std::result::Result::Ok(res)
24258 }
24259 crate::services::meta_service::GetExn::ApplicationException(aexn) =>
24260 ::std::result::Result::Err(GetError::ApplicationException(aexn)),
24261 }
24262 }
24263 }
24264
24265 pub type MultiGetError = ::fbthrift::NonthrowingFunctionError;
24266
24267 impl ::std::convert::From<crate::services::meta_service::MultiGetExn> for
24268 ::std::result::Result<crate::types::MultiGetResp, MultiGetError>
24269 {
24270 fn from(e: crate::services::meta_service::MultiGetExn) -> Self {
24271 match e {
24272 crate::services::meta_service::MultiGetExn::Success(res) => {
24273 ::std::result::Result::Ok(res)
24274 }
24275 crate::services::meta_service::MultiGetExn::ApplicationException(aexn) =>
24276 ::std::result::Result::Err(MultiGetError::ApplicationException(aexn)),
24277 }
24278 }
24279 }
24280
24281 pub type RemoveError = ::fbthrift::NonthrowingFunctionError;
24282
24283 impl ::std::convert::From<crate::services::meta_service::RemoveExn> for
24284 ::std::result::Result<crate::types::ExecResp, RemoveError>
24285 {
24286 fn from(e: crate::services::meta_service::RemoveExn) -> Self {
24287 match e {
24288 crate::services::meta_service::RemoveExn::Success(res) => {
24289 ::std::result::Result::Ok(res)
24290 }
24291 crate::services::meta_service::RemoveExn::ApplicationException(aexn) =>
24292 ::std::result::Result::Err(RemoveError::ApplicationException(aexn)),
24293 }
24294 }
24295 }
24296
24297 pub type RemoveRangeError = ::fbthrift::NonthrowingFunctionError;
24298
24299 impl ::std::convert::From<crate::services::meta_service::RemoveRangeExn> for
24300 ::std::result::Result<crate::types::ExecResp, RemoveRangeError>
24301 {
24302 fn from(e: crate::services::meta_service::RemoveRangeExn) -> Self {
24303 match e {
24304 crate::services::meta_service::RemoveRangeExn::Success(res) => {
24305 ::std::result::Result::Ok(res)
24306 }
24307 crate::services::meta_service::RemoveRangeExn::ApplicationException(aexn) =>
24308 ::std::result::Result::Err(RemoveRangeError::ApplicationException(aexn)),
24309 }
24310 }
24311 }
24312
24313 pub type ScanError = ::fbthrift::NonthrowingFunctionError;
24314
24315 impl ::std::convert::From<crate::services::meta_service::ScanExn> for
24316 ::std::result::Result<crate::types::ScanResp, ScanError>
24317 {
24318 fn from(e: crate::services::meta_service::ScanExn) -> Self {
24319 match e {
24320 crate::services::meta_service::ScanExn::Success(res) => {
24321 ::std::result::Result::Ok(res)
24322 }
24323 crate::services::meta_service::ScanExn::ApplicationException(aexn) =>
24324 ::std::result::Result::Err(ScanError::ApplicationException(aexn)),
24325 }
24326 }
24327 }
24328
24329 pub type CreateTagIndexError = ::fbthrift::NonthrowingFunctionError;
24330
24331 impl ::std::convert::From<crate::services::meta_service::CreateTagIndexExn> for
24332 ::std::result::Result<crate::types::ExecResp, CreateTagIndexError>
24333 {
24334 fn from(e: crate::services::meta_service::CreateTagIndexExn) -> Self {
24335 match e {
24336 crate::services::meta_service::CreateTagIndexExn::Success(res) => {
24337 ::std::result::Result::Ok(res)
24338 }
24339 crate::services::meta_service::CreateTagIndexExn::ApplicationException(aexn) =>
24340 ::std::result::Result::Err(CreateTagIndexError::ApplicationException(aexn)),
24341 }
24342 }
24343 }
24344
24345 pub type DropTagIndexError = ::fbthrift::NonthrowingFunctionError;
24346
24347 impl ::std::convert::From<crate::services::meta_service::DropTagIndexExn> for
24348 ::std::result::Result<crate::types::ExecResp, DropTagIndexError>
24349 {
24350 fn from(e: crate::services::meta_service::DropTagIndexExn) -> Self {
24351 match e {
24352 crate::services::meta_service::DropTagIndexExn::Success(res) => {
24353 ::std::result::Result::Ok(res)
24354 }
24355 crate::services::meta_service::DropTagIndexExn::ApplicationException(aexn) =>
24356 ::std::result::Result::Err(DropTagIndexError::ApplicationException(aexn)),
24357 }
24358 }
24359 }
24360
24361 pub type GetTagIndexError = ::fbthrift::NonthrowingFunctionError;
24362
24363 impl ::std::convert::From<crate::services::meta_service::GetTagIndexExn> for
24364 ::std::result::Result<crate::types::GetTagIndexResp, GetTagIndexError>
24365 {
24366 fn from(e: crate::services::meta_service::GetTagIndexExn) -> Self {
24367 match e {
24368 crate::services::meta_service::GetTagIndexExn::Success(res) => {
24369 ::std::result::Result::Ok(res)
24370 }
24371 crate::services::meta_service::GetTagIndexExn::ApplicationException(aexn) =>
24372 ::std::result::Result::Err(GetTagIndexError::ApplicationException(aexn)),
24373 }
24374 }
24375 }
24376
24377 pub type ListTagIndexesError = ::fbthrift::NonthrowingFunctionError;
24378
24379 impl ::std::convert::From<crate::services::meta_service::ListTagIndexesExn> for
24380 ::std::result::Result<crate::types::ListTagIndexesResp, ListTagIndexesError>
24381 {
24382 fn from(e: crate::services::meta_service::ListTagIndexesExn) -> Self {
24383 match e {
24384 crate::services::meta_service::ListTagIndexesExn::Success(res) => {
24385 ::std::result::Result::Ok(res)
24386 }
24387 crate::services::meta_service::ListTagIndexesExn::ApplicationException(aexn) =>
24388 ::std::result::Result::Err(ListTagIndexesError::ApplicationException(aexn)),
24389 }
24390 }
24391 }
24392
24393 pub type RebuildTagIndexError = ::fbthrift::NonthrowingFunctionError;
24394
24395 impl ::std::convert::From<crate::services::meta_service::RebuildTagIndexExn> for
24396 ::std::result::Result<crate::types::ExecResp, RebuildTagIndexError>
24397 {
24398 fn from(e: crate::services::meta_service::RebuildTagIndexExn) -> Self {
24399 match e {
24400 crate::services::meta_service::RebuildTagIndexExn::Success(res) => {
24401 ::std::result::Result::Ok(res)
24402 }
24403 crate::services::meta_service::RebuildTagIndexExn::ApplicationException(aexn) =>
24404 ::std::result::Result::Err(RebuildTagIndexError::ApplicationException(aexn)),
24405 }
24406 }
24407 }
24408
24409 pub type ListTagIndexStatusError = ::fbthrift::NonthrowingFunctionError;
24410
24411 impl ::std::convert::From<crate::services::meta_service::ListTagIndexStatusExn> for
24412 ::std::result::Result<crate::types::ListIndexStatusResp, ListTagIndexStatusError>
24413 {
24414 fn from(e: crate::services::meta_service::ListTagIndexStatusExn) -> Self {
24415 match e {
24416 crate::services::meta_service::ListTagIndexStatusExn::Success(res) => {
24417 ::std::result::Result::Ok(res)
24418 }
24419 crate::services::meta_service::ListTagIndexStatusExn::ApplicationException(aexn) =>
24420 ::std::result::Result::Err(ListTagIndexStatusError::ApplicationException(aexn)),
24421 }
24422 }
24423 }
24424
24425 pub type CreateEdgeIndexError = ::fbthrift::NonthrowingFunctionError;
24426
24427 impl ::std::convert::From<crate::services::meta_service::CreateEdgeIndexExn> for
24428 ::std::result::Result<crate::types::ExecResp, CreateEdgeIndexError>
24429 {
24430 fn from(e: crate::services::meta_service::CreateEdgeIndexExn) -> Self {
24431 match e {
24432 crate::services::meta_service::CreateEdgeIndexExn::Success(res) => {
24433 ::std::result::Result::Ok(res)
24434 }
24435 crate::services::meta_service::CreateEdgeIndexExn::ApplicationException(aexn) =>
24436 ::std::result::Result::Err(CreateEdgeIndexError::ApplicationException(aexn)),
24437 }
24438 }
24439 }
24440
24441 pub type DropEdgeIndexError = ::fbthrift::NonthrowingFunctionError;
24442
24443 impl ::std::convert::From<crate::services::meta_service::DropEdgeIndexExn> for
24444 ::std::result::Result<crate::types::ExecResp, DropEdgeIndexError>
24445 {
24446 fn from(e: crate::services::meta_service::DropEdgeIndexExn) -> Self {
24447 match e {
24448 crate::services::meta_service::DropEdgeIndexExn::Success(res) => {
24449 ::std::result::Result::Ok(res)
24450 }
24451 crate::services::meta_service::DropEdgeIndexExn::ApplicationException(aexn) =>
24452 ::std::result::Result::Err(DropEdgeIndexError::ApplicationException(aexn)),
24453 }
24454 }
24455 }
24456
24457 pub type GetEdgeIndexError = ::fbthrift::NonthrowingFunctionError;
24458
24459 impl ::std::convert::From<crate::services::meta_service::GetEdgeIndexExn> for
24460 ::std::result::Result<crate::types::GetEdgeIndexResp, GetEdgeIndexError>
24461 {
24462 fn from(e: crate::services::meta_service::GetEdgeIndexExn) -> Self {
24463 match e {
24464 crate::services::meta_service::GetEdgeIndexExn::Success(res) => {
24465 ::std::result::Result::Ok(res)
24466 }
24467 crate::services::meta_service::GetEdgeIndexExn::ApplicationException(aexn) =>
24468 ::std::result::Result::Err(GetEdgeIndexError::ApplicationException(aexn)),
24469 }
24470 }
24471 }
24472
24473 pub type ListEdgeIndexesError = ::fbthrift::NonthrowingFunctionError;
24474
24475 impl ::std::convert::From<crate::services::meta_service::ListEdgeIndexesExn> for
24476 ::std::result::Result<crate::types::ListEdgeIndexesResp, ListEdgeIndexesError>
24477 {
24478 fn from(e: crate::services::meta_service::ListEdgeIndexesExn) -> Self {
24479 match e {
24480 crate::services::meta_service::ListEdgeIndexesExn::Success(res) => {
24481 ::std::result::Result::Ok(res)
24482 }
24483 crate::services::meta_service::ListEdgeIndexesExn::ApplicationException(aexn) =>
24484 ::std::result::Result::Err(ListEdgeIndexesError::ApplicationException(aexn)),
24485 }
24486 }
24487 }
24488
24489 pub type RebuildEdgeIndexError = ::fbthrift::NonthrowingFunctionError;
24490
24491 impl ::std::convert::From<crate::services::meta_service::RebuildEdgeIndexExn> for
24492 ::std::result::Result<crate::types::ExecResp, RebuildEdgeIndexError>
24493 {
24494 fn from(e: crate::services::meta_service::RebuildEdgeIndexExn) -> Self {
24495 match e {
24496 crate::services::meta_service::RebuildEdgeIndexExn::Success(res) => {
24497 ::std::result::Result::Ok(res)
24498 }
24499 crate::services::meta_service::RebuildEdgeIndexExn::ApplicationException(aexn) =>
24500 ::std::result::Result::Err(RebuildEdgeIndexError::ApplicationException(aexn)),
24501 }
24502 }
24503 }
24504
24505 pub type ListEdgeIndexStatusError = ::fbthrift::NonthrowingFunctionError;
24506
24507 impl ::std::convert::From<crate::services::meta_service::ListEdgeIndexStatusExn> for
24508 ::std::result::Result<crate::types::ListIndexStatusResp, ListEdgeIndexStatusError>
24509 {
24510 fn from(e: crate::services::meta_service::ListEdgeIndexStatusExn) -> Self {
24511 match e {
24512 crate::services::meta_service::ListEdgeIndexStatusExn::Success(res) => {
24513 ::std::result::Result::Ok(res)
24514 }
24515 crate::services::meta_service::ListEdgeIndexStatusExn::ApplicationException(aexn) =>
24516 ::std::result::Result::Err(ListEdgeIndexStatusError::ApplicationException(aexn)),
24517 }
24518 }
24519 }
24520
24521 pub type CreateUserError = ::fbthrift::NonthrowingFunctionError;
24522
24523 impl ::std::convert::From<crate::services::meta_service::CreateUserExn> for
24524 ::std::result::Result<crate::types::ExecResp, CreateUserError>
24525 {
24526 fn from(e: crate::services::meta_service::CreateUserExn) -> Self {
24527 match e {
24528 crate::services::meta_service::CreateUserExn::Success(res) => {
24529 ::std::result::Result::Ok(res)
24530 }
24531 crate::services::meta_service::CreateUserExn::ApplicationException(aexn) =>
24532 ::std::result::Result::Err(CreateUserError::ApplicationException(aexn)),
24533 }
24534 }
24535 }
24536
24537 pub type DropUserError = ::fbthrift::NonthrowingFunctionError;
24538
24539 impl ::std::convert::From<crate::services::meta_service::DropUserExn> for
24540 ::std::result::Result<crate::types::ExecResp, DropUserError>
24541 {
24542 fn from(e: crate::services::meta_service::DropUserExn) -> Self {
24543 match e {
24544 crate::services::meta_service::DropUserExn::Success(res) => {
24545 ::std::result::Result::Ok(res)
24546 }
24547 crate::services::meta_service::DropUserExn::ApplicationException(aexn) =>
24548 ::std::result::Result::Err(DropUserError::ApplicationException(aexn)),
24549 }
24550 }
24551 }
24552
24553 pub type AlterUserError = ::fbthrift::NonthrowingFunctionError;
24554
24555 impl ::std::convert::From<crate::services::meta_service::AlterUserExn> for
24556 ::std::result::Result<crate::types::ExecResp, AlterUserError>
24557 {
24558 fn from(e: crate::services::meta_service::AlterUserExn) -> Self {
24559 match e {
24560 crate::services::meta_service::AlterUserExn::Success(res) => {
24561 ::std::result::Result::Ok(res)
24562 }
24563 crate::services::meta_service::AlterUserExn::ApplicationException(aexn) =>
24564 ::std::result::Result::Err(AlterUserError::ApplicationException(aexn)),
24565 }
24566 }
24567 }
24568
24569 pub type GrantRoleError = ::fbthrift::NonthrowingFunctionError;
24570
24571 impl ::std::convert::From<crate::services::meta_service::GrantRoleExn> for
24572 ::std::result::Result<crate::types::ExecResp, GrantRoleError>
24573 {
24574 fn from(e: crate::services::meta_service::GrantRoleExn) -> Self {
24575 match e {
24576 crate::services::meta_service::GrantRoleExn::Success(res) => {
24577 ::std::result::Result::Ok(res)
24578 }
24579 crate::services::meta_service::GrantRoleExn::ApplicationException(aexn) =>
24580 ::std::result::Result::Err(GrantRoleError::ApplicationException(aexn)),
24581 }
24582 }
24583 }
24584
24585 pub type RevokeRoleError = ::fbthrift::NonthrowingFunctionError;
24586
24587 impl ::std::convert::From<crate::services::meta_service::RevokeRoleExn> for
24588 ::std::result::Result<crate::types::ExecResp, RevokeRoleError>
24589 {
24590 fn from(e: crate::services::meta_service::RevokeRoleExn) -> Self {
24591 match e {
24592 crate::services::meta_service::RevokeRoleExn::Success(res) => {
24593 ::std::result::Result::Ok(res)
24594 }
24595 crate::services::meta_service::RevokeRoleExn::ApplicationException(aexn) =>
24596 ::std::result::Result::Err(RevokeRoleError::ApplicationException(aexn)),
24597 }
24598 }
24599 }
24600
24601 pub type ListUsersError = ::fbthrift::NonthrowingFunctionError;
24602
24603 impl ::std::convert::From<crate::services::meta_service::ListUsersExn> for
24604 ::std::result::Result<crate::types::ListUsersResp, ListUsersError>
24605 {
24606 fn from(e: crate::services::meta_service::ListUsersExn) -> Self {
24607 match e {
24608 crate::services::meta_service::ListUsersExn::Success(res) => {
24609 ::std::result::Result::Ok(res)
24610 }
24611 crate::services::meta_service::ListUsersExn::ApplicationException(aexn) =>
24612 ::std::result::Result::Err(ListUsersError::ApplicationException(aexn)),
24613 }
24614 }
24615 }
24616
24617 pub type ListRolesError = ::fbthrift::NonthrowingFunctionError;
24618
24619 impl ::std::convert::From<crate::services::meta_service::ListRolesExn> for
24620 ::std::result::Result<crate::types::ListRolesResp, ListRolesError>
24621 {
24622 fn from(e: crate::services::meta_service::ListRolesExn) -> Self {
24623 match e {
24624 crate::services::meta_service::ListRolesExn::Success(res) => {
24625 ::std::result::Result::Ok(res)
24626 }
24627 crate::services::meta_service::ListRolesExn::ApplicationException(aexn) =>
24628 ::std::result::Result::Err(ListRolesError::ApplicationException(aexn)),
24629 }
24630 }
24631 }
24632
24633 pub type GetUserRolesError = ::fbthrift::NonthrowingFunctionError;
24634
24635 impl ::std::convert::From<crate::services::meta_service::GetUserRolesExn> for
24636 ::std::result::Result<crate::types::ListRolesResp, GetUserRolesError>
24637 {
24638 fn from(e: crate::services::meta_service::GetUserRolesExn) -> Self {
24639 match e {
24640 crate::services::meta_service::GetUserRolesExn::Success(res) => {
24641 ::std::result::Result::Ok(res)
24642 }
24643 crate::services::meta_service::GetUserRolesExn::ApplicationException(aexn) =>
24644 ::std::result::Result::Err(GetUserRolesError::ApplicationException(aexn)),
24645 }
24646 }
24647 }
24648
24649 pub type ChangePasswordError = ::fbthrift::NonthrowingFunctionError;
24650
24651 impl ::std::convert::From<crate::services::meta_service::ChangePasswordExn> for
24652 ::std::result::Result<crate::types::ExecResp, ChangePasswordError>
24653 {
24654 fn from(e: crate::services::meta_service::ChangePasswordExn) -> Self {
24655 match e {
24656 crate::services::meta_service::ChangePasswordExn::Success(res) => {
24657 ::std::result::Result::Ok(res)
24658 }
24659 crate::services::meta_service::ChangePasswordExn::ApplicationException(aexn) =>
24660 ::std::result::Result::Err(ChangePasswordError::ApplicationException(aexn)),
24661 }
24662 }
24663 }
24664
24665 pub type HeartBeatError = ::fbthrift::NonthrowingFunctionError;
24666
24667 impl ::std::convert::From<crate::services::meta_service::HeartBeatExn> for
24668 ::std::result::Result<crate::types::HBResp, HeartBeatError>
24669 {
24670 fn from(e: crate::services::meta_service::HeartBeatExn) -> Self {
24671 match e {
24672 crate::services::meta_service::HeartBeatExn::Success(res) => {
24673 ::std::result::Result::Ok(res)
24674 }
24675 crate::services::meta_service::HeartBeatExn::ApplicationException(aexn) =>
24676 ::std::result::Result::Err(HeartBeatError::ApplicationException(aexn)),
24677 }
24678 }
24679 }
24680
24681 pub type BalanceError = ::fbthrift::NonthrowingFunctionError;
24682
24683 impl ::std::convert::From<crate::services::meta_service::BalanceExn> for
24684 ::std::result::Result<crate::types::BalanceResp, BalanceError>
24685 {
24686 fn from(e: crate::services::meta_service::BalanceExn) -> Self {
24687 match e {
24688 crate::services::meta_service::BalanceExn::Success(res) => {
24689 ::std::result::Result::Ok(res)
24690 }
24691 crate::services::meta_service::BalanceExn::ApplicationException(aexn) =>
24692 ::std::result::Result::Err(BalanceError::ApplicationException(aexn)),
24693 }
24694 }
24695 }
24696
24697 pub type LeaderBalanceError = ::fbthrift::NonthrowingFunctionError;
24698
24699 impl ::std::convert::From<crate::services::meta_service::LeaderBalanceExn> for
24700 ::std::result::Result<crate::types::ExecResp, LeaderBalanceError>
24701 {
24702 fn from(e: crate::services::meta_service::LeaderBalanceExn) -> Self {
24703 match e {
24704 crate::services::meta_service::LeaderBalanceExn::Success(res) => {
24705 ::std::result::Result::Ok(res)
24706 }
24707 crate::services::meta_service::LeaderBalanceExn::ApplicationException(aexn) =>
24708 ::std::result::Result::Err(LeaderBalanceError::ApplicationException(aexn)),
24709 }
24710 }
24711 }
24712
24713 pub type RegConfigError = ::fbthrift::NonthrowingFunctionError;
24714
24715 impl ::std::convert::From<crate::services::meta_service::RegConfigExn> for
24716 ::std::result::Result<crate::types::ExecResp, RegConfigError>
24717 {
24718 fn from(e: crate::services::meta_service::RegConfigExn) -> Self {
24719 match e {
24720 crate::services::meta_service::RegConfigExn::Success(res) => {
24721 ::std::result::Result::Ok(res)
24722 }
24723 crate::services::meta_service::RegConfigExn::ApplicationException(aexn) =>
24724 ::std::result::Result::Err(RegConfigError::ApplicationException(aexn)),
24725 }
24726 }
24727 }
24728
24729 pub type GetConfigError = ::fbthrift::NonthrowingFunctionError;
24730
24731 impl ::std::convert::From<crate::services::meta_service::GetConfigExn> for
24732 ::std::result::Result<crate::types::GetConfigResp, GetConfigError>
24733 {
24734 fn from(e: crate::services::meta_service::GetConfigExn) -> Self {
24735 match e {
24736 crate::services::meta_service::GetConfigExn::Success(res) => {
24737 ::std::result::Result::Ok(res)
24738 }
24739 crate::services::meta_service::GetConfigExn::ApplicationException(aexn) =>
24740 ::std::result::Result::Err(GetConfigError::ApplicationException(aexn)),
24741 }
24742 }
24743 }
24744
24745 pub type SetConfigError = ::fbthrift::NonthrowingFunctionError;
24746
24747 impl ::std::convert::From<crate::services::meta_service::SetConfigExn> for
24748 ::std::result::Result<crate::types::ExecResp, SetConfigError>
24749 {
24750 fn from(e: crate::services::meta_service::SetConfigExn) -> Self {
24751 match e {
24752 crate::services::meta_service::SetConfigExn::Success(res) => {
24753 ::std::result::Result::Ok(res)
24754 }
24755 crate::services::meta_service::SetConfigExn::ApplicationException(aexn) =>
24756 ::std::result::Result::Err(SetConfigError::ApplicationException(aexn)),
24757 }
24758 }
24759 }
24760
24761 pub type ListConfigsError = ::fbthrift::NonthrowingFunctionError;
24762
24763 impl ::std::convert::From<crate::services::meta_service::ListConfigsExn> for
24764 ::std::result::Result<crate::types::ListConfigsResp, ListConfigsError>
24765 {
24766 fn from(e: crate::services::meta_service::ListConfigsExn) -> Self {
24767 match e {
24768 crate::services::meta_service::ListConfigsExn::Success(res) => {
24769 ::std::result::Result::Ok(res)
24770 }
24771 crate::services::meta_service::ListConfigsExn::ApplicationException(aexn) =>
24772 ::std::result::Result::Err(ListConfigsError::ApplicationException(aexn)),
24773 }
24774 }
24775 }
24776
24777 pub type CreateSnapshotError = ::fbthrift::NonthrowingFunctionError;
24778
24779 impl ::std::convert::From<crate::services::meta_service::CreateSnapshotExn> for
24780 ::std::result::Result<crate::types::ExecResp, CreateSnapshotError>
24781 {
24782 fn from(e: crate::services::meta_service::CreateSnapshotExn) -> Self {
24783 match e {
24784 crate::services::meta_service::CreateSnapshotExn::Success(res) => {
24785 ::std::result::Result::Ok(res)
24786 }
24787 crate::services::meta_service::CreateSnapshotExn::ApplicationException(aexn) =>
24788 ::std::result::Result::Err(CreateSnapshotError::ApplicationException(aexn)),
24789 }
24790 }
24791 }
24792
24793 pub type DropSnapshotError = ::fbthrift::NonthrowingFunctionError;
24794
24795 impl ::std::convert::From<crate::services::meta_service::DropSnapshotExn> for
24796 ::std::result::Result<crate::types::ExecResp, DropSnapshotError>
24797 {
24798 fn from(e: crate::services::meta_service::DropSnapshotExn) -> Self {
24799 match e {
24800 crate::services::meta_service::DropSnapshotExn::Success(res) => {
24801 ::std::result::Result::Ok(res)
24802 }
24803 crate::services::meta_service::DropSnapshotExn::ApplicationException(aexn) =>
24804 ::std::result::Result::Err(DropSnapshotError::ApplicationException(aexn)),
24805 }
24806 }
24807 }
24808
24809 pub type ListSnapshotsError = ::fbthrift::NonthrowingFunctionError;
24810
24811 impl ::std::convert::From<crate::services::meta_service::ListSnapshotsExn> for
24812 ::std::result::Result<crate::types::ListSnapshotsResp, ListSnapshotsError>
24813 {
24814 fn from(e: crate::services::meta_service::ListSnapshotsExn) -> Self {
24815 match e {
24816 crate::services::meta_service::ListSnapshotsExn::Success(res) => {
24817 ::std::result::Result::Ok(res)
24818 }
24819 crate::services::meta_service::ListSnapshotsExn::ApplicationException(aexn) =>
24820 ::std::result::Result::Err(ListSnapshotsError::ApplicationException(aexn)),
24821 }
24822 }
24823 }
24824
24825 pub type RunAdminJobError = ::fbthrift::NonthrowingFunctionError;
24826
24827 impl ::std::convert::From<crate::services::meta_service::RunAdminJobExn> for
24828 ::std::result::Result<crate::types::AdminJobResp, RunAdminJobError>
24829 {
24830 fn from(e: crate::services::meta_service::RunAdminJobExn) -> Self {
24831 match e {
24832 crate::services::meta_service::RunAdminJobExn::Success(res) => {
24833 ::std::result::Result::Ok(res)
24834 }
24835 crate::services::meta_service::RunAdminJobExn::ApplicationException(aexn) =>
24836 ::std::result::Result::Err(RunAdminJobError::ApplicationException(aexn)),
24837 }
24838 }
24839 }
24840
24841 }
24842
24843}