1#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals, unused_crate_dependencies)]
4
5pub use self::errors::*;
6pub use self::types::*;
7
8pub mod types {
9 #![allow(clippy::redundant_closure)]
10
11
12 pub type TermID = ::std::primitive::i64;
13
14 pub type LogID = ::std::primitive::i64;
15
16 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
17 pub struct AskForVoteRequest {
18 pub space: common::types::GraphSpaceID,
19 pub part: common::types::PartitionID,
20 pub candidate_ip: common::types::IPv4,
21 pub candidate_port: common::types::Port,
22 pub term: crate::types::TermID,
23 pub last_log_id: crate::types::LogID,
24 pub last_log_term: crate::types::TermID,
25 }
26
27 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
28 pub struct AskForVoteResponse {
29 pub error_code: crate::types::ErrorCode,
30 }
31
32 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
33 pub struct LogEntry {
34 pub cluster: common::types::ClusterID,
35 pub log_str: ::std::vec::Vec<::std::primitive::u8>,
36 }
37
38 #[derive(Clone, Debug, PartialEq)]
39 pub struct AppendLogRequest {
40 pub space: common::types::GraphSpaceID,
41 pub part: common::types::PartitionID,
42 pub current_term: crate::types::TermID,
43 pub last_log_id: crate::types::LogID,
44 pub committed_log_id: crate::types::LogID,
45 pub leader_ip: common::types::IPv4,
46 pub leader_port: common::types::Port,
47 pub last_log_term_sent: crate::types::TermID,
48 pub last_log_id_sent: crate::types::LogID,
49 pub log_term: crate::types::TermID,
50 pub log_str_list: ::std::vec::Vec<crate::types::LogEntry>,
51 pub sending_snapshot: ::std::primitive::bool,
52 }
53
54 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
55 pub struct AppendLogResponse {
56 pub error_code: crate::types::ErrorCode,
57 pub current_term: crate::types::TermID,
58 pub leader_ip: common::types::IPv4,
59 pub leader_port: common::types::Port,
60 pub committed_log_id: crate::types::LogID,
61 pub last_log_id: crate::types::LogID,
62 pub last_log_term: crate::types::TermID,
63 }
64
65 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
66 pub struct SendSnapshotRequest {
67 pub space: common::types::GraphSpaceID,
68 pub part: common::types::PartitionID,
69 pub term: crate::types::TermID,
70 pub committed_log_id: crate::types::LogID,
71 pub committed_log_term: crate::types::TermID,
72 pub leader_ip: common::types::IPv4,
73 pub leader_port: common::types::Port,
74 pub rows: ::std::vec::Vec<::std::vec::Vec<::std::primitive::u8>>,
75 pub total_size: ::std::primitive::i64,
76 pub total_count: ::std::primitive::i64,
77 pub done: ::std::primitive::bool,
78 }
79
80 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
81 pub struct SendSnapshotResponse {
82 pub error_code: crate::types::ErrorCode,
83 }
84
85 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
86 pub struct ErrorCode(pub ::std::primitive::i32);
87
88 impl ErrorCode {
89 pub const SUCCEEDED: Self = ErrorCode(0i32);
90 pub const E_LOG_GAP: Self = ErrorCode(-1i32);
91 pub const E_LOG_STALE: Self = ErrorCode(-2i32);
92 pub const E_MISSING_COMMIT: Self = ErrorCode(-3i32);
93 pub const E_WAITING_SNAPSHOT: Self = ErrorCode(-4i32);
94 pub const E_UNKNOWN_PART: Self = ErrorCode(-5i32);
95 pub const E_TERM_OUT_OF_DATE: Self = ErrorCode(-6i32);
96 pub const E_LAST_LOG_TERM_TOO_OLD: Self = ErrorCode(-7i32);
97 pub const E_BAD_STATE: Self = ErrorCode(-8i32);
98 pub const E_WRONG_LEADER: Self = ErrorCode(-9i32);
99 pub const E_WAL_FAIL: Self = ErrorCode(-10i32);
100 pub const E_NOT_READY: Self = ErrorCode(-11i32);
101 pub const E_HOST_STOPPED: Self = ErrorCode(-12i32);
102 pub const E_NOT_A_LEADER: Self = ErrorCode(-13i32);
103 pub const E_HOST_DISCONNECTED: Self = ErrorCode(-14i32);
104 pub const E_TOO_MANY_REQUESTS: Self = ErrorCode(-15i32);
105 pub const E_PERSIST_SNAPSHOT_FAILED: Self = ErrorCode(-16i32);
106 pub const E_BAD_ROLE: Self = ErrorCode(-17i32);
107 pub const E_EXCEPTION: Self = ErrorCode(-20i32);
108
109 pub fn variants() -> &'static [&'static str] {
110 &[
111 "SUCCEEDED",
112 "E_LOG_GAP",
113 "E_LOG_STALE",
114 "E_MISSING_COMMIT",
115 "E_WAITING_SNAPSHOT",
116 "E_UNKNOWN_PART",
117 "E_TERM_OUT_OF_DATE",
118 "E_LAST_LOG_TERM_TOO_OLD",
119 "E_BAD_STATE",
120 "E_WRONG_LEADER",
121 "E_WAL_FAIL",
122 "E_NOT_READY",
123 "E_HOST_STOPPED",
124 "E_NOT_A_LEADER",
125 "E_HOST_DISCONNECTED",
126 "E_TOO_MANY_REQUESTS",
127 "E_PERSIST_SNAPSHOT_FAILED",
128 "E_BAD_ROLE",
129 "E_EXCEPTION",
130 ]
131 }
132 }
133
134 impl ::std::default::Default for ErrorCode {
135 fn default() -> Self {
136 ErrorCode(::fbthrift::__UNKNOWN_ID)
137 }
138 }
139
140 impl<'a> ::std::convert::From<&'a ErrorCode> for ::std::primitive::i32 {
141 #[inline]
142 fn from(x: &'a ErrorCode) -> Self {
143 x.0
144 }
145 }
146
147 impl ::std::convert::From<ErrorCode> for ::std::primitive::i32 {
148 #[inline]
149 fn from(x: ErrorCode) -> Self {
150 x.0
151 }
152 }
153
154 impl ::std::convert::From<::std::primitive::i32> for ErrorCode {
155 #[inline]
156 fn from(x: ::std::primitive::i32) -> Self {
157 Self(x)
158 }
159 }
160
161 impl ::std::fmt::Display for ErrorCode {
162 fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
163 let s: &::std::primitive::str = match *self {
164 ErrorCode::SUCCEEDED => "SUCCEEDED",
165 ErrorCode::E_LOG_GAP => "E_LOG_GAP",
166 ErrorCode::E_LOG_STALE => "E_LOG_STALE",
167 ErrorCode::E_MISSING_COMMIT => "E_MISSING_COMMIT",
168 ErrorCode::E_WAITING_SNAPSHOT => "E_WAITING_SNAPSHOT",
169 ErrorCode::E_UNKNOWN_PART => "E_UNKNOWN_PART",
170 ErrorCode::E_TERM_OUT_OF_DATE => "E_TERM_OUT_OF_DATE",
171 ErrorCode::E_LAST_LOG_TERM_TOO_OLD => "E_LAST_LOG_TERM_TOO_OLD",
172 ErrorCode::E_BAD_STATE => "E_BAD_STATE",
173 ErrorCode::E_WRONG_LEADER => "E_WRONG_LEADER",
174 ErrorCode::E_WAL_FAIL => "E_WAL_FAIL",
175 ErrorCode::E_NOT_READY => "E_NOT_READY",
176 ErrorCode::E_HOST_STOPPED => "E_HOST_STOPPED",
177 ErrorCode::E_NOT_A_LEADER => "E_NOT_A_LEADER",
178 ErrorCode::E_HOST_DISCONNECTED => "E_HOST_DISCONNECTED",
179 ErrorCode::E_TOO_MANY_REQUESTS => "E_TOO_MANY_REQUESTS",
180 ErrorCode::E_PERSIST_SNAPSHOT_FAILED => "E_PERSIST_SNAPSHOT_FAILED",
181 ErrorCode::E_BAD_ROLE => "E_BAD_ROLE",
182 ErrorCode::E_EXCEPTION => "E_EXCEPTION",
183 ErrorCode(x) => return write!(fmt, "{}", x),
184 };
185 write!(fmt, "{}", s)
186 }
187 }
188
189 impl ::std::fmt::Debug for ErrorCode {
190 fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
191 write!(fmt, "ErrorCode::{}", self)
192 }
193 }
194
195 impl ::std::str::FromStr for ErrorCode {
196 type Err = ::anyhow::Error;
197
198 fn from_str(string: &::std::primitive::str) -> ::std::result::Result<Self, Self::Err> {
199 match string {
200 "SUCCEEDED" => ::std::result::Result::Ok(ErrorCode::SUCCEEDED),
201 "E_LOG_GAP" => ::std::result::Result::Ok(ErrorCode::E_LOG_GAP),
202 "E_LOG_STALE" => ::std::result::Result::Ok(ErrorCode::E_LOG_STALE),
203 "E_MISSING_COMMIT" => ::std::result::Result::Ok(ErrorCode::E_MISSING_COMMIT),
204 "E_WAITING_SNAPSHOT" => ::std::result::Result::Ok(ErrorCode::E_WAITING_SNAPSHOT),
205 "E_UNKNOWN_PART" => ::std::result::Result::Ok(ErrorCode::E_UNKNOWN_PART),
206 "E_TERM_OUT_OF_DATE" => ::std::result::Result::Ok(ErrorCode::E_TERM_OUT_OF_DATE),
207 "E_LAST_LOG_TERM_TOO_OLD" => ::std::result::Result::Ok(ErrorCode::E_LAST_LOG_TERM_TOO_OLD),
208 "E_BAD_STATE" => ::std::result::Result::Ok(ErrorCode::E_BAD_STATE),
209 "E_WRONG_LEADER" => ::std::result::Result::Ok(ErrorCode::E_WRONG_LEADER),
210 "E_WAL_FAIL" => ::std::result::Result::Ok(ErrorCode::E_WAL_FAIL),
211 "E_NOT_READY" => ::std::result::Result::Ok(ErrorCode::E_NOT_READY),
212 "E_HOST_STOPPED" => ::std::result::Result::Ok(ErrorCode::E_HOST_STOPPED),
213 "E_NOT_A_LEADER" => ::std::result::Result::Ok(ErrorCode::E_NOT_A_LEADER),
214 "E_HOST_DISCONNECTED" => ::std::result::Result::Ok(ErrorCode::E_HOST_DISCONNECTED),
215 "E_TOO_MANY_REQUESTS" => ::std::result::Result::Ok(ErrorCode::E_TOO_MANY_REQUESTS),
216 "E_PERSIST_SNAPSHOT_FAILED" => ::std::result::Result::Ok(ErrorCode::E_PERSIST_SNAPSHOT_FAILED),
217 "E_BAD_ROLE" => ::std::result::Result::Ok(ErrorCode::E_BAD_ROLE),
218 "E_EXCEPTION" => ::std::result::Result::Ok(ErrorCode::E_EXCEPTION),
219 _ => ::anyhow::bail!("Unable to parse {} as ErrorCode", string),
220 }
221 }
222 }
223
224 impl ::fbthrift::GetTType for ErrorCode {
225 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::I32;
226 }
227
228 impl<P> ::fbthrift::Serialize<P> for ErrorCode
229 where
230 P: ::fbthrift::ProtocolWriter,
231 {
232 #[inline]
233 fn write(&self, p: &mut P) {
234 p.write_i32(self.into())
235 }
236 }
237
238 impl<P> ::fbthrift::Deserialize<P> for ErrorCode
239 where
240 P: ::fbthrift::ProtocolReader,
241 {
242 #[inline]
243 fn read(p: &mut P) -> ::anyhow::Result<Self> {
244 ::std::result::Result::Ok(ErrorCode::from(p.read_i32()?))
245 }
246 }
247
248
249
250 impl ::std::default::Default for self::AskForVoteRequest {
251 fn default() -> Self {
252 Self {
253 space: ::std::default::Default::default(),
254 part: ::std::default::Default::default(),
255 candidate_ip: ::std::default::Default::default(),
256 candidate_port: ::std::default::Default::default(),
257 term: ::std::default::Default::default(),
258 last_log_id: ::std::default::Default::default(),
259 last_log_term: ::std::default::Default::default(),
260 }
261 }
262 }
263
264 unsafe impl ::std::marker::Send for self::AskForVoteRequest {}
265 unsafe impl ::std::marker::Sync for self::AskForVoteRequest {}
266
267 impl ::fbthrift::GetTType for self::AskForVoteRequest {
268 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
269 }
270
271 impl<P> ::fbthrift::Serialize<P> for self::AskForVoteRequest
272 where
273 P: ::fbthrift::ProtocolWriter,
274 {
275 fn write(&self, p: &mut P) {
276 p.write_struct_begin("AskForVoteRequest");
277 p.write_field_begin("space", ::fbthrift::TType::I32, 1);
278 ::fbthrift::Serialize::write(&self.space, p);
279 p.write_field_end();
280 p.write_field_begin("part", ::fbthrift::TType::I32, 2);
281 ::fbthrift::Serialize::write(&self.part, p);
282 p.write_field_end();
283 p.write_field_begin("candidate_ip", ::fbthrift::TType::I32, 3);
284 ::fbthrift::Serialize::write(&self.candidate_ip, p);
285 p.write_field_end();
286 p.write_field_begin("candidate_port", ::fbthrift::TType::I32, 4);
287 ::fbthrift::Serialize::write(&self.candidate_port, p);
288 p.write_field_end();
289 p.write_field_begin("term", ::fbthrift::TType::I64, 5);
290 ::fbthrift::Serialize::write(&self.term, p);
291 p.write_field_end();
292 p.write_field_begin("last_log_id", ::fbthrift::TType::I64, 6);
293 ::fbthrift::Serialize::write(&self.last_log_id, p);
294 p.write_field_end();
295 p.write_field_begin("last_log_term", ::fbthrift::TType::I64, 7);
296 ::fbthrift::Serialize::write(&self.last_log_term, p);
297 p.write_field_end();
298 p.write_field_stop();
299 p.write_struct_end();
300 }
301 }
302
303 impl<P> ::fbthrift::Deserialize<P> for self::AskForVoteRequest
304 where
305 P: ::fbthrift::ProtocolReader,
306 {
307 fn read(p: &mut P) -> ::anyhow::Result<Self> {
308 let mut field_space = ::std::option::Option::None;
309 let mut field_part = ::std::option::Option::None;
310 let mut field_candidate_ip = ::std::option::Option::None;
311 let mut field_candidate_port = ::std::option::Option::None;
312 let mut field_term = ::std::option::Option::None;
313 let mut field_last_log_id = ::std::option::Option::None;
314 let mut field_last_log_term = ::std::option::Option::None;
315 let _ = p.read_struct_begin(|_| ())?;
316 loop {
317 let (_, fty, fid) = p.read_field_begin(|_| ())?;
318 match (fty, fid as ::std::primitive::i32) {
319 (::fbthrift::TType::Stop, _) => break,
320 (::fbthrift::TType::I32, 1) => field_space = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
321 (::fbthrift::TType::I32, 2) => field_part = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
322 (::fbthrift::TType::I32, 3) => field_candidate_ip = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
323 (::fbthrift::TType::I32, 4) => field_candidate_port = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
324 (::fbthrift::TType::I64, 5) => field_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
325 (::fbthrift::TType::I64, 6) => field_last_log_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
326 (::fbthrift::TType::I64, 7) => field_last_log_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
327 (fty, _) => p.skip(fty)?,
328 }
329 p.read_field_end()?;
330 }
331 p.read_struct_end()?;
332 ::std::result::Result::Ok(Self {
333 space: field_space.unwrap_or_default(),
334 part: field_part.unwrap_or_default(),
335 candidate_ip: field_candidate_ip.unwrap_or_default(),
336 candidate_port: field_candidate_port.unwrap_or_default(),
337 term: field_term.unwrap_or_default(),
338 last_log_id: field_last_log_id.unwrap_or_default(),
339 last_log_term: field_last_log_term.unwrap_or_default(),
340 })
341 }
342 }
343
344
345 impl ::std::default::Default for self::AskForVoteResponse {
346 fn default() -> Self {
347 Self {
348 error_code: ::std::default::Default::default(),
349 }
350 }
351 }
352
353 unsafe impl ::std::marker::Send for self::AskForVoteResponse {}
354 unsafe impl ::std::marker::Sync for self::AskForVoteResponse {}
355
356 impl ::fbthrift::GetTType for self::AskForVoteResponse {
357 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
358 }
359
360 impl<P> ::fbthrift::Serialize<P> for self::AskForVoteResponse
361 where
362 P: ::fbthrift::ProtocolWriter,
363 {
364 fn write(&self, p: &mut P) {
365 p.write_struct_begin("AskForVoteResponse");
366 p.write_field_begin("error_code", ::fbthrift::TType::I32, 1);
367 ::fbthrift::Serialize::write(&self.error_code, p);
368 p.write_field_end();
369 p.write_field_stop();
370 p.write_struct_end();
371 }
372 }
373
374 impl<P> ::fbthrift::Deserialize<P> for self::AskForVoteResponse
375 where
376 P: ::fbthrift::ProtocolReader,
377 {
378 fn read(p: &mut P) -> ::anyhow::Result<Self> {
379 let mut field_error_code = ::std::option::Option::None;
380 let _ = p.read_struct_begin(|_| ())?;
381 loop {
382 let (_, fty, fid) = p.read_field_begin(|_| ())?;
383 match (fty, fid as ::std::primitive::i32) {
384 (::fbthrift::TType::Stop, _) => break,
385 (::fbthrift::TType::I32, 1) => field_error_code = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
386 (fty, _) => p.skip(fty)?,
387 }
388 p.read_field_end()?;
389 }
390 p.read_struct_end()?;
391 ::std::result::Result::Ok(Self {
392 error_code: field_error_code.unwrap_or_default(),
393 })
394 }
395 }
396
397
398 impl ::std::default::Default for self::LogEntry {
399 fn default() -> Self {
400 Self {
401 cluster: ::std::default::Default::default(),
402 log_str: ::std::default::Default::default(),
403 }
404 }
405 }
406
407 unsafe impl ::std::marker::Send for self::LogEntry {}
408 unsafe impl ::std::marker::Sync for self::LogEntry {}
409
410 impl ::fbthrift::GetTType for self::LogEntry {
411 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
412 }
413
414 impl<P> ::fbthrift::Serialize<P> for self::LogEntry
415 where
416 P: ::fbthrift::ProtocolWriter,
417 {
418 fn write(&self, p: &mut P) {
419 p.write_struct_begin("LogEntry");
420 p.write_field_begin("cluster", ::fbthrift::TType::I64, 1);
421 ::fbthrift::Serialize::write(&self.cluster, p);
422 p.write_field_end();
423 p.write_field_begin("log_str", ::fbthrift::TType::String, 2);
424 ::fbthrift::Serialize::write(&self.log_str, p);
425 p.write_field_end();
426 p.write_field_stop();
427 p.write_struct_end();
428 }
429 }
430
431 impl<P> ::fbthrift::Deserialize<P> for self::LogEntry
432 where
433 P: ::fbthrift::ProtocolReader,
434 {
435 fn read(p: &mut P) -> ::anyhow::Result<Self> {
436 let mut field_cluster = ::std::option::Option::None;
437 let mut field_log_str = ::std::option::Option::None;
438 let _ = p.read_struct_begin(|_| ())?;
439 loop {
440 let (_, fty, fid) = p.read_field_begin(|_| ())?;
441 match (fty, fid as ::std::primitive::i32) {
442 (::fbthrift::TType::Stop, _) => break,
443 (::fbthrift::TType::I64, 1) => field_cluster = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
444 (::fbthrift::TType::String, 2) => field_log_str = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
445 (fty, _) => p.skip(fty)?,
446 }
447 p.read_field_end()?;
448 }
449 p.read_struct_end()?;
450 ::std::result::Result::Ok(Self {
451 cluster: field_cluster.unwrap_or_default(),
452 log_str: field_log_str.unwrap_or_default(),
453 })
454 }
455 }
456
457
458 impl ::std::default::Default for self::AppendLogRequest {
459 fn default() -> Self {
460 Self {
461 space: ::std::default::Default::default(),
462 part: ::std::default::Default::default(),
463 current_term: ::std::default::Default::default(),
464 last_log_id: ::std::default::Default::default(),
465 committed_log_id: ::std::default::Default::default(),
466 leader_ip: ::std::default::Default::default(),
467 leader_port: ::std::default::Default::default(),
468 last_log_term_sent: ::std::default::Default::default(),
469 last_log_id_sent: ::std::default::Default::default(),
470 log_term: ::std::default::Default::default(),
471 log_str_list: ::std::default::Default::default(),
472 sending_snapshot: ::std::default::Default::default(),
473 }
474 }
475 }
476
477 unsafe impl ::std::marker::Send for self::AppendLogRequest {}
478 unsafe impl ::std::marker::Sync for self::AppendLogRequest {}
479
480 impl ::fbthrift::GetTType for self::AppendLogRequest {
481 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
482 }
483
484 impl<P> ::fbthrift::Serialize<P> for self::AppendLogRequest
485 where
486 P: ::fbthrift::ProtocolWriter,
487 {
488 fn write(&self, p: &mut P) {
489 p.write_struct_begin("AppendLogRequest");
490 p.write_field_begin("space", ::fbthrift::TType::I32, 1);
491 ::fbthrift::Serialize::write(&self.space, p);
492 p.write_field_end();
493 p.write_field_begin("part", ::fbthrift::TType::I32, 2);
494 ::fbthrift::Serialize::write(&self.part, p);
495 p.write_field_end();
496 p.write_field_begin("current_term", ::fbthrift::TType::I64, 3);
497 ::fbthrift::Serialize::write(&self.current_term, p);
498 p.write_field_end();
499 p.write_field_begin("last_log_id", ::fbthrift::TType::I64, 4);
500 ::fbthrift::Serialize::write(&self.last_log_id, p);
501 p.write_field_end();
502 p.write_field_begin("committed_log_id", ::fbthrift::TType::I64, 5);
503 ::fbthrift::Serialize::write(&self.committed_log_id, p);
504 p.write_field_end();
505 p.write_field_begin("leader_ip", ::fbthrift::TType::I32, 6);
506 ::fbthrift::Serialize::write(&self.leader_ip, p);
507 p.write_field_end();
508 p.write_field_begin("leader_port", ::fbthrift::TType::I32, 7);
509 ::fbthrift::Serialize::write(&self.leader_port, p);
510 p.write_field_end();
511 p.write_field_begin("last_log_term_sent", ::fbthrift::TType::I64, 8);
512 ::fbthrift::Serialize::write(&self.last_log_term_sent, p);
513 p.write_field_end();
514 p.write_field_begin("last_log_id_sent", ::fbthrift::TType::I64, 9);
515 ::fbthrift::Serialize::write(&self.last_log_id_sent, p);
516 p.write_field_end();
517 p.write_field_begin("log_term", ::fbthrift::TType::I64, 10);
518 ::fbthrift::Serialize::write(&self.log_term, p);
519 p.write_field_end();
520 p.write_field_begin("log_str_list", ::fbthrift::TType::List, 11);
521 ::fbthrift::Serialize::write(&self.log_str_list, p);
522 p.write_field_end();
523 p.write_field_begin("sending_snapshot", ::fbthrift::TType::Bool, 12);
524 ::fbthrift::Serialize::write(&self.sending_snapshot, p);
525 p.write_field_end();
526 p.write_field_stop();
527 p.write_struct_end();
528 }
529 }
530
531 impl<P> ::fbthrift::Deserialize<P> for self::AppendLogRequest
532 where
533 P: ::fbthrift::ProtocolReader,
534 {
535 fn read(p: &mut P) -> ::anyhow::Result<Self> {
536 let mut field_space = ::std::option::Option::None;
537 let mut field_part = ::std::option::Option::None;
538 let mut field_current_term = ::std::option::Option::None;
539 let mut field_last_log_id = ::std::option::Option::None;
540 let mut field_committed_log_id = ::std::option::Option::None;
541 let mut field_leader_ip = ::std::option::Option::None;
542 let mut field_leader_port = ::std::option::Option::None;
543 let mut field_last_log_term_sent = ::std::option::Option::None;
544 let mut field_last_log_id_sent = ::std::option::Option::None;
545 let mut field_log_term = ::std::option::Option::None;
546 let mut field_log_str_list = ::std::option::Option::None;
547 let mut field_sending_snapshot = ::std::option::Option::None;
548 let _ = p.read_struct_begin(|_| ())?;
549 loop {
550 let (_, fty, fid) = p.read_field_begin(|_| ())?;
551 match (fty, fid as ::std::primitive::i32) {
552 (::fbthrift::TType::Stop, _) => break,
553 (::fbthrift::TType::I32, 1) => field_space = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
554 (::fbthrift::TType::I32, 2) => field_part = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
555 (::fbthrift::TType::I64, 3) => field_current_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
556 (::fbthrift::TType::I64, 4) => field_last_log_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
557 (::fbthrift::TType::I64, 5) => field_committed_log_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
558 (::fbthrift::TType::I32, 6) => field_leader_ip = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
559 (::fbthrift::TType::I32, 7) => field_leader_port = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
560 (::fbthrift::TType::I64, 8) => field_last_log_term_sent = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
561 (::fbthrift::TType::I64, 9) => field_last_log_id_sent = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
562 (::fbthrift::TType::I64, 10) => field_log_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
563 (::fbthrift::TType::List, 11) => field_log_str_list = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
564 (::fbthrift::TType::Bool, 12) => field_sending_snapshot = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
565 (fty, _) => p.skip(fty)?,
566 }
567 p.read_field_end()?;
568 }
569 p.read_struct_end()?;
570 ::std::result::Result::Ok(Self {
571 space: field_space.unwrap_or_default(),
572 part: field_part.unwrap_or_default(),
573 current_term: field_current_term.unwrap_or_default(),
574 last_log_id: field_last_log_id.unwrap_or_default(),
575 committed_log_id: field_committed_log_id.unwrap_or_default(),
576 leader_ip: field_leader_ip.unwrap_or_default(),
577 leader_port: field_leader_port.unwrap_or_default(),
578 last_log_term_sent: field_last_log_term_sent.unwrap_or_default(),
579 last_log_id_sent: field_last_log_id_sent.unwrap_or_default(),
580 log_term: field_log_term.unwrap_or_default(),
581 log_str_list: field_log_str_list.unwrap_or_default(),
582 sending_snapshot: field_sending_snapshot.unwrap_or_default(),
583 })
584 }
585 }
586
587
588 impl ::std::default::Default for self::AppendLogResponse {
589 fn default() -> Self {
590 Self {
591 error_code: ::std::default::Default::default(),
592 current_term: ::std::default::Default::default(),
593 leader_ip: ::std::default::Default::default(),
594 leader_port: ::std::default::Default::default(),
595 committed_log_id: ::std::default::Default::default(),
596 last_log_id: ::std::default::Default::default(),
597 last_log_term: ::std::default::Default::default(),
598 }
599 }
600 }
601
602 unsafe impl ::std::marker::Send for self::AppendLogResponse {}
603 unsafe impl ::std::marker::Sync for self::AppendLogResponse {}
604
605 impl ::fbthrift::GetTType for self::AppendLogResponse {
606 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
607 }
608
609 impl<P> ::fbthrift::Serialize<P> for self::AppendLogResponse
610 where
611 P: ::fbthrift::ProtocolWriter,
612 {
613 fn write(&self, p: &mut P) {
614 p.write_struct_begin("AppendLogResponse");
615 p.write_field_begin("error_code", ::fbthrift::TType::I32, 1);
616 ::fbthrift::Serialize::write(&self.error_code, p);
617 p.write_field_end();
618 p.write_field_begin("current_term", ::fbthrift::TType::I64, 2);
619 ::fbthrift::Serialize::write(&self.current_term, p);
620 p.write_field_end();
621 p.write_field_begin("leader_ip", ::fbthrift::TType::I32, 3);
622 ::fbthrift::Serialize::write(&self.leader_ip, p);
623 p.write_field_end();
624 p.write_field_begin("leader_port", ::fbthrift::TType::I32, 4);
625 ::fbthrift::Serialize::write(&self.leader_port, p);
626 p.write_field_end();
627 p.write_field_begin("committed_log_id", ::fbthrift::TType::I64, 5);
628 ::fbthrift::Serialize::write(&self.committed_log_id, p);
629 p.write_field_end();
630 p.write_field_begin("last_log_id", ::fbthrift::TType::I64, 6);
631 ::fbthrift::Serialize::write(&self.last_log_id, p);
632 p.write_field_end();
633 p.write_field_begin("last_log_term", ::fbthrift::TType::I64, 7);
634 ::fbthrift::Serialize::write(&self.last_log_term, p);
635 p.write_field_end();
636 p.write_field_stop();
637 p.write_struct_end();
638 }
639 }
640
641 impl<P> ::fbthrift::Deserialize<P> for self::AppendLogResponse
642 where
643 P: ::fbthrift::ProtocolReader,
644 {
645 fn read(p: &mut P) -> ::anyhow::Result<Self> {
646 let mut field_error_code = ::std::option::Option::None;
647 let mut field_current_term = ::std::option::Option::None;
648 let mut field_leader_ip = ::std::option::Option::None;
649 let mut field_leader_port = ::std::option::Option::None;
650 let mut field_committed_log_id = ::std::option::Option::None;
651 let mut field_last_log_id = ::std::option::Option::None;
652 let mut field_last_log_term = ::std::option::Option::None;
653 let _ = p.read_struct_begin(|_| ())?;
654 loop {
655 let (_, fty, fid) = p.read_field_begin(|_| ())?;
656 match (fty, fid as ::std::primitive::i32) {
657 (::fbthrift::TType::Stop, _) => break,
658 (::fbthrift::TType::I32, 1) => field_error_code = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
659 (::fbthrift::TType::I64, 2) => field_current_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
660 (::fbthrift::TType::I32, 3) => field_leader_ip = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
661 (::fbthrift::TType::I32, 4) => field_leader_port = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
662 (::fbthrift::TType::I64, 5) => field_committed_log_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
663 (::fbthrift::TType::I64, 6) => field_last_log_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
664 (::fbthrift::TType::I64, 7) => field_last_log_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
665 (fty, _) => p.skip(fty)?,
666 }
667 p.read_field_end()?;
668 }
669 p.read_struct_end()?;
670 ::std::result::Result::Ok(Self {
671 error_code: field_error_code.unwrap_or_default(),
672 current_term: field_current_term.unwrap_or_default(),
673 leader_ip: field_leader_ip.unwrap_or_default(),
674 leader_port: field_leader_port.unwrap_or_default(),
675 committed_log_id: field_committed_log_id.unwrap_or_default(),
676 last_log_id: field_last_log_id.unwrap_or_default(),
677 last_log_term: field_last_log_term.unwrap_or_default(),
678 })
679 }
680 }
681
682
683 impl ::std::default::Default for self::SendSnapshotRequest {
684 fn default() -> Self {
685 Self {
686 space: ::std::default::Default::default(),
687 part: ::std::default::Default::default(),
688 term: ::std::default::Default::default(),
689 committed_log_id: ::std::default::Default::default(),
690 committed_log_term: ::std::default::Default::default(),
691 leader_ip: ::std::default::Default::default(),
692 leader_port: ::std::default::Default::default(),
693 rows: ::std::default::Default::default(),
694 total_size: ::std::default::Default::default(),
695 total_count: ::std::default::Default::default(),
696 done: ::std::default::Default::default(),
697 }
698 }
699 }
700
701 unsafe impl ::std::marker::Send for self::SendSnapshotRequest {}
702 unsafe impl ::std::marker::Sync for self::SendSnapshotRequest {}
703
704 impl ::fbthrift::GetTType for self::SendSnapshotRequest {
705 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
706 }
707
708 impl<P> ::fbthrift::Serialize<P> for self::SendSnapshotRequest
709 where
710 P: ::fbthrift::ProtocolWriter,
711 {
712 fn write(&self, p: &mut P) {
713 p.write_struct_begin("SendSnapshotRequest");
714 p.write_field_begin("space", ::fbthrift::TType::I32, 1);
715 ::fbthrift::Serialize::write(&self.space, p);
716 p.write_field_end();
717 p.write_field_begin("part", ::fbthrift::TType::I32, 2);
718 ::fbthrift::Serialize::write(&self.part, p);
719 p.write_field_end();
720 p.write_field_begin("term", ::fbthrift::TType::I64, 3);
721 ::fbthrift::Serialize::write(&self.term, p);
722 p.write_field_end();
723 p.write_field_begin("committed_log_id", ::fbthrift::TType::I64, 4);
724 ::fbthrift::Serialize::write(&self.committed_log_id, p);
725 p.write_field_end();
726 p.write_field_begin("committed_log_term", ::fbthrift::TType::I64, 5);
727 ::fbthrift::Serialize::write(&self.committed_log_term, p);
728 p.write_field_end();
729 p.write_field_begin("leader_ip", ::fbthrift::TType::I32, 6);
730 ::fbthrift::Serialize::write(&self.leader_ip, p);
731 p.write_field_end();
732 p.write_field_begin("leader_port", ::fbthrift::TType::I32, 7);
733 ::fbthrift::Serialize::write(&self.leader_port, p);
734 p.write_field_end();
735 p.write_field_begin("rows", ::fbthrift::TType::List, 8);
736 ::fbthrift::Serialize::write(&self.rows, p);
737 p.write_field_end();
738 p.write_field_begin("total_size", ::fbthrift::TType::I64, 9);
739 ::fbthrift::Serialize::write(&self.total_size, p);
740 p.write_field_end();
741 p.write_field_begin("total_count", ::fbthrift::TType::I64, 10);
742 ::fbthrift::Serialize::write(&self.total_count, p);
743 p.write_field_end();
744 p.write_field_begin("done", ::fbthrift::TType::Bool, 11);
745 ::fbthrift::Serialize::write(&self.done, p);
746 p.write_field_end();
747 p.write_field_stop();
748 p.write_struct_end();
749 }
750 }
751
752 impl<P> ::fbthrift::Deserialize<P> for self::SendSnapshotRequest
753 where
754 P: ::fbthrift::ProtocolReader,
755 {
756 fn read(p: &mut P) -> ::anyhow::Result<Self> {
757 let mut field_space = ::std::option::Option::None;
758 let mut field_part = ::std::option::Option::None;
759 let mut field_term = ::std::option::Option::None;
760 let mut field_committed_log_id = ::std::option::Option::None;
761 let mut field_committed_log_term = ::std::option::Option::None;
762 let mut field_leader_ip = ::std::option::Option::None;
763 let mut field_leader_port = ::std::option::Option::None;
764 let mut field_rows = ::std::option::Option::None;
765 let mut field_total_size = ::std::option::Option::None;
766 let mut field_total_count = ::std::option::Option::None;
767 let mut field_done = ::std::option::Option::None;
768 let _ = p.read_struct_begin(|_| ())?;
769 loop {
770 let (_, fty, fid) = p.read_field_begin(|_| ())?;
771 match (fty, fid as ::std::primitive::i32) {
772 (::fbthrift::TType::Stop, _) => break,
773 (::fbthrift::TType::I32, 1) => field_space = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
774 (::fbthrift::TType::I32, 2) => field_part = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
775 (::fbthrift::TType::I64, 3) => field_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
776 (::fbthrift::TType::I64, 4) => field_committed_log_id = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
777 (::fbthrift::TType::I64, 5) => field_committed_log_term = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
778 (::fbthrift::TType::I32, 6) => field_leader_ip = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
779 (::fbthrift::TType::I32, 7) => field_leader_port = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
780 (::fbthrift::TType::List, 8) => field_rows = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
781 (::fbthrift::TType::I64, 9) => field_total_size = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
782 (::fbthrift::TType::I64, 10) => field_total_count = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
783 (::fbthrift::TType::Bool, 11) => field_done = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
784 (fty, _) => p.skip(fty)?,
785 }
786 p.read_field_end()?;
787 }
788 p.read_struct_end()?;
789 ::std::result::Result::Ok(Self {
790 space: field_space.unwrap_or_default(),
791 part: field_part.unwrap_or_default(),
792 term: field_term.unwrap_or_default(),
793 committed_log_id: field_committed_log_id.unwrap_or_default(),
794 committed_log_term: field_committed_log_term.unwrap_or_default(),
795 leader_ip: field_leader_ip.unwrap_or_default(),
796 leader_port: field_leader_port.unwrap_or_default(),
797 rows: field_rows.unwrap_or_default(),
798 total_size: field_total_size.unwrap_or_default(),
799 total_count: field_total_count.unwrap_or_default(),
800 done: field_done.unwrap_or_default(),
801 })
802 }
803 }
804
805
806 impl ::std::default::Default for self::SendSnapshotResponse {
807 fn default() -> Self {
808 Self {
809 error_code: ::std::default::Default::default(),
810 }
811 }
812 }
813
814 unsafe impl ::std::marker::Send for self::SendSnapshotResponse {}
815 unsafe impl ::std::marker::Sync for self::SendSnapshotResponse {}
816
817 impl ::fbthrift::GetTType for self::SendSnapshotResponse {
818 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
819 }
820
821 impl<P> ::fbthrift::Serialize<P> for self::SendSnapshotResponse
822 where
823 P: ::fbthrift::ProtocolWriter,
824 {
825 fn write(&self, p: &mut P) {
826 p.write_struct_begin("SendSnapshotResponse");
827 p.write_field_begin("error_code", ::fbthrift::TType::I32, 1);
828 ::fbthrift::Serialize::write(&self.error_code, p);
829 p.write_field_end();
830 p.write_field_stop();
831 p.write_struct_end();
832 }
833 }
834
835 impl<P> ::fbthrift::Deserialize<P> for self::SendSnapshotResponse
836 where
837 P: ::fbthrift::ProtocolReader,
838 {
839 fn read(p: &mut P) -> ::anyhow::Result<Self> {
840 let mut field_error_code = ::std::option::Option::None;
841 let _ = p.read_struct_begin(|_| ())?;
842 loop {
843 let (_, fty, fid) = p.read_field_begin(|_| ())?;
844 match (fty, fid as ::std::primitive::i32) {
845 (::fbthrift::TType::Stop, _) => break,
846 (::fbthrift::TType::I32, 1) => field_error_code = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
847 (fty, _) => p.skip(fty)?,
848 }
849 p.read_field_end()?;
850 }
851 p.read_struct_end()?;
852 ::std::result::Result::Ok(Self {
853 error_code: field_error_code.unwrap_or_default(),
854 })
855 }
856 }
857
858}
859
860pub mod dependencies {
861 pub use common as common;
862}
863
864pub mod services {
865 pub mod raftex_service {
866
867 #[derive(Clone, Debug)]
868 pub enum AskForVoteExn {
869 Success(crate::types::AskForVoteResponse),
870 ApplicationException(::fbthrift::ApplicationException),
871 }
872
873 impl ::std::convert::From<::fbthrift::ApplicationException> for AskForVoteExn {
874 fn from(exn: ::fbthrift::ApplicationException) -> Self {
875 AskForVoteExn::ApplicationException(exn)
876 }
877 }
878
879 impl ::fbthrift::GetTType for AskForVoteExn {
880 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
881 }
882
883 impl<P> ::fbthrift::Serialize<P> for AskForVoteExn
884 where
885 P: ::fbthrift::ProtocolWriter,
886 {
887 fn write(&self, p: &mut P) {
888 p.write_struct_begin("AskForVote");
889 match self {
890 AskForVoteExn::Success(inner) => {
891 p.write_field_begin(
892 "Success",
893 ::fbthrift::TType::Struct,
894 0i16,
895 );
896 inner.write(p);
897 p.write_field_end();
898 }
899 AskForVoteExn::ApplicationException(_) => panic!(
900 "Bad union Alt field {} id {}",
901 "ApplicationException",
902 -2147483648i32,
903 ),
904 }
905 p.write_field_stop();
906 p.write_struct_end();
907 }
908 }
909
910 impl<P> ::fbthrift::Deserialize<P> for AskForVoteExn
911 where
912 P: ::fbthrift::ProtocolReader,
913 {
914 fn read(p: &mut P) -> ::anyhow::Result<Self> {
915 let _ = p.read_struct_begin(|_| ())?;
916 let mut once = false;
917 let mut alt = ::std::option::Option::None;
918 loop {
919 let (_, fty, fid) = p.read_field_begin(|_| ())?;
920 match ((fty, fid as ::std::primitive::i32), once) {
921 ((::fbthrift::TType::Stop, _), _) => {
922 p.read_field_end()?;
923 break;
924 }
925 ((::fbthrift::TType::Struct, 0i32), false) => {
926 once = true;
927 alt = ::std::option::Option::Some(AskForVoteExn::Success(::fbthrift::Deserialize::read(p)?));
928 }
929 ((ty, _id), false) => p.skip(ty)?,
930 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
931 ::fbthrift::ApplicationException::new(
932 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
933 format!(
934 "unwanted extra union {} field ty {:?} id {}",
935 "AskForVoteExn",
936 badty,
937 badid,
938 ),
939 )
940 )),
941 }
942 p.read_field_end()?;
943 }
944 p.read_struct_end()?;
945 alt.ok_or_else(||
946 ::fbthrift::ApplicationException::new(
947 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
948 format!("Empty union {}", "AskForVoteExn"),
949 )
950 .into(),
951 )
952 }
953 }
954
955 #[derive(Clone, Debug)]
956 pub enum AppendLogExn {
957 Success(crate::types::AppendLogResponse),
958 ApplicationException(::fbthrift::ApplicationException),
959 }
960
961 impl ::std::convert::From<::fbthrift::ApplicationException> for AppendLogExn {
962 fn from(exn: ::fbthrift::ApplicationException) -> Self {
963 AppendLogExn::ApplicationException(exn)
964 }
965 }
966
967 impl ::fbthrift::GetTType for AppendLogExn {
968 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
969 }
970
971 impl<P> ::fbthrift::Serialize<P> for AppendLogExn
972 where
973 P: ::fbthrift::ProtocolWriter,
974 {
975 fn write(&self, p: &mut P) {
976 p.write_struct_begin("AppendLog");
977 match self {
978 AppendLogExn::Success(inner) => {
979 p.write_field_begin(
980 "Success",
981 ::fbthrift::TType::Struct,
982 0i16,
983 );
984 inner.write(p);
985 p.write_field_end();
986 }
987 AppendLogExn::ApplicationException(_) => panic!(
988 "Bad union Alt field {} id {}",
989 "ApplicationException",
990 -2147483648i32,
991 ),
992 }
993 p.write_field_stop();
994 p.write_struct_end();
995 }
996 }
997
998 impl<P> ::fbthrift::Deserialize<P> for AppendLogExn
999 where
1000 P: ::fbthrift::ProtocolReader,
1001 {
1002 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1003 let _ = p.read_struct_begin(|_| ())?;
1004 let mut once = false;
1005 let mut alt = ::std::option::Option::None;
1006 loop {
1007 let (_, fty, fid) = p.read_field_begin(|_| ())?;
1008 match ((fty, fid as ::std::primitive::i32), once) {
1009 ((::fbthrift::TType::Stop, _), _) => {
1010 p.read_field_end()?;
1011 break;
1012 }
1013 ((::fbthrift::TType::Struct, 0i32), false) => {
1014 once = true;
1015 alt = ::std::option::Option::Some(AppendLogExn::Success(::fbthrift::Deserialize::read(p)?));
1016 }
1017 ((ty, _id), false) => p.skip(ty)?,
1018 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1019 ::fbthrift::ApplicationException::new(
1020 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1021 format!(
1022 "unwanted extra union {} field ty {:?} id {}",
1023 "AppendLogExn",
1024 badty,
1025 badid,
1026 ),
1027 )
1028 )),
1029 }
1030 p.read_field_end()?;
1031 }
1032 p.read_struct_end()?;
1033 alt.ok_or_else(||
1034 ::fbthrift::ApplicationException::new(
1035 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1036 format!("Empty union {}", "AppendLogExn"),
1037 )
1038 .into(),
1039 )
1040 }
1041 }
1042
1043 #[derive(Clone, Debug)]
1044 pub enum SendSnapshotExn {
1045 Success(crate::types::SendSnapshotResponse),
1046 ApplicationException(::fbthrift::ApplicationException),
1047 }
1048
1049 impl ::std::convert::From<::fbthrift::ApplicationException> for SendSnapshotExn {
1050 fn from(exn: ::fbthrift::ApplicationException) -> Self {
1051 SendSnapshotExn::ApplicationException(exn)
1052 }
1053 }
1054
1055 impl ::fbthrift::GetTType for SendSnapshotExn {
1056 const TTYPE: ::fbthrift::TType = ::fbthrift::TType::Struct;
1057 }
1058
1059 impl<P> ::fbthrift::Serialize<P> for SendSnapshotExn
1060 where
1061 P: ::fbthrift::ProtocolWriter,
1062 {
1063 fn write(&self, p: &mut P) {
1064 p.write_struct_begin("SendSnapshot");
1065 match self {
1066 SendSnapshotExn::Success(inner) => {
1067 p.write_field_begin(
1068 "Success",
1069 ::fbthrift::TType::Struct,
1070 0i16,
1071 );
1072 inner.write(p);
1073 p.write_field_end();
1074 }
1075 SendSnapshotExn::ApplicationException(_) => panic!(
1076 "Bad union Alt field {} id {}",
1077 "ApplicationException",
1078 -2147483648i32,
1079 ),
1080 }
1081 p.write_field_stop();
1082 p.write_struct_end();
1083 }
1084 }
1085
1086 impl<P> ::fbthrift::Deserialize<P> for SendSnapshotExn
1087 where
1088 P: ::fbthrift::ProtocolReader,
1089 {
1090 fn read(p: &mut P) -> ::anyhow::Result<Self> {
1091 let _ = p.read_struct_begin(|_| ())?;
1092 let mut once = false;
1093 let mut alt = ::std::option::Option::None;
1094 loop {
1095 let (_, fty, fid) = p.read_field_begin(|_| ())?;
1096 match ((fty, fid as ::std::primitive::i32), once) {
1097 ((::fbthrift::TType::Stop, _), _) => {
1098 p.read_field_end()?;
1099 break;
1100 }
1101 ((::fbthrift::TType::Struct, 0i32), false) => {
1102 once = true;
1103 alt = ::std::option::Option::Some(SendSnapshotExn::Success(::fbthrift::Deserialize::read(p)?));
1104 }
1105 ((ty, _id), false) => p.skip(ty)?,
1106 ((badty, badid), true) => return ::std::result::Result::Err(::std::convert::From::from(
1107 ::fbthrift::ApplicationException::new(
1108 ::fbthrift::ApplicationExceptionErrorCode::ProtocolError,
1109 format!(
1110 "unwanted extra union {} field ty {:?} id {}",
1111 "SendSnapshotExn",
1112 badty,
1113 badid,
1114 ),
1115 )
1116 )),
1117 }
1118 p.read_field_end()?;
1119 }
1120 p.read_struct_end()?;
1121 alt.ok_or_else(||
1122 ::fbthrift::ApplicationException::new(
1123 ::fbthrift::ApplicationExceptionErrorCode::MissingResult,
1124 format!("Empty union {}", "SendSnapshotExn"),
1125 )
1126 .into(),
1127 )
1128 }
1129 }
1130 }
1131}
1132
1133pub mod client {
1134
1135 pub struct RaftexServiceImpl<P, T> {
1136 transport: T,
1137 _phantom: ::std::marker::PhantomData<fn() -> P>,
1138 }
1139
1140 impl<P, T> RaftexServiceImpl<P, T> {
1141 pub fn new(
1142 transport: T,
1143 ) -> Self {
1144 Self {
1145 transport,
1146 _phantom: ::std::marker::PhantomData,
1147 }
1148 }
1149
1150 pub fn transport(&self) -> &T {
1151 &self.transport
1152 }
1153 }
1154
1155 pub trait RaftexService: ::std::marker::Send {
1156 fn askForVote(
1157 &self,
1158 arg_req: &crate::types::AskForVoteRequest,
1159 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AskForVoteResponse, crate::errors::raftex_service::AskForVoteError>> + ::std::marker::Send + 'static>>;
1160 fn appendLog(
1161 &self,
1162 arg_req: &crate::types::AppendLogRequest,
1163 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AppendLogResponse, crate::errors::raftex_service::AppendLogError>> + ::std::marker::Send + 'static>>;
1164 fn sendSnapshot(
1165 &self,
1166 arg_req: &crate::types::SendSnapshotRequest,
1167 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::SendSnapshotResponse, crate::errors::raftex_service::SendSnapshotError>> + ::std::marker::Send + 'static>>;
1168 }
1169
1170 impl<P, T> RaftexService for RaftexServiceImpl<P, T>
1171 where
1172 P: ::fbthrift::Protocol,
1173 T: ::fbthrift::Transport,
1174 P::Frame: ::fbthrift::Framing<DecBuf = ::fbthrift::FramingDecoded<T>>,
1175 ::fbthrift::ProtocolEncoded<P>: ::fbthrift::BufMutExt<Final = ::fbthrift::FramingEncodedFinal<T>>,
1176 { fn askForVote(
1177 &self,
1178 arg_req: &crate::types::AskForVoteRequest,
1179 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AskForVoteResponse, crate::errors::raftex_service::AskForVoteError>> + ::std::marker::Send + 'static>> {
1180 use ::fbthrift::{ProtocolReader as _, ProtocolWriter as _};
1181 use ::futures::future::{FutureExt as _, TryFutureExt as _};
1182 let request = ::fbthrift::serialize!(P, |p| ::fbthrift::protocol::write_message(
1183 p,
1184 "askForVote",
1185 ::fbthrift::MessageType::Call,
1186 0,
1190 |p| {
1191 p.write_struct_begin("args");
1192 p.write_field_begin("arg_req", ::fbthrift::TType::Struct, 1i16);
1193 ::fbthrift::Serialize::write(&arg_req, p);
1194 p.write_field_end();
1195 p.write_field_stop();
1196 p.write_struct_end();
1197 },
1198 ));
1199 self.transport()
1200 .call(request)
1201 .map_err(::std::convert::From::from)
1202 .and_then(|reply| ::futures::future::ready({
1203 let de = P::deserializer(reply);
1204 move |mut p: P::Deserializer| -> ::std::result::Result<crate::types::AskForVoteResponse, crate::errors::raftex_service::AskForVoteError> {
1205 let p = &mut p;
1206 let (_, message_type, _) = p.read_message_begin(|_| ())?;
1207 let result = match message_type {
1208 ::fbthrift::MessageType::Reply => {
1209 let exn: crate::services::raftex_service::AskForVoteExn = ::fbthrift::Deserialize::read(p)?;
1210 match exn {
1211 crate::services::raftex_service::AskForVoteExn::Success(x) => ::std::result::Result::Ok(x),
1212 crate::services::raftex_service::AskForVoteExn::ApplicationException(ae) => {
1213 ::std::result::Result::Err(crate::errors::raftex_service::AskForVoteError::ApplicationException(ae))
1214 }
1215 }
1216 }
1217 ::fbthrift::MessageType::Exception => {
1218 let ae: ::fbthrift::ApplicationException = ::fbthrift::Deserialize::read(p)?;
1219 ::std::result::Result::Err(crate::errors::raftex_service::AskForVoteError::ApplicationException(ae))
1220 }
1221 ::fbthrift::MessageType::Call | ::fbthrift::MessageType::Oneway | ::fbthrift::MessageType::InvalidMessageType => {
1222 let err = ::anyhow::anyhow!("Unexpected message type {:?}", message_type);
1223 ::std::result::Result::Err(crate::errors::raftex_service::AskForVoteError::ThriftError(err))
1224 }
1225 };
1226 p.read_message_end()?;
1227 result
1228 }(de)
1229 }))
1230 .boxed()
1231 }
1232 fn appendLog(
1233 &self,
1234 arg_req: &crate::types::AppendLogRequest,
1235 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AppendLogResponse, crate::errors::raftex_service::AppendLogError>> + ::std::marker::Send + 'static>> {
1236 use ::fbthrift::{ProtocolReader as _, ProtocolWriter as _};
1237 use ::futures::future::{FutureExt as _, TryFutureExt as _};
1238 let request = ::fbthrift::serialize!(P, |p| ::fbthrift::protocol::write_message(
1239 p,
1240 "appendLog",
1241 ::fbthrift::MessageType::Call,
1242 0,
1246 |p| {
1247 p.write_struct_begin("args");
1248 p.write_field_begin("arg_req", ::fbthrift::TType::Struct, 1i16);
1249 ::fbthrift::Serialize::write(&arg_req, p);
1250 p.write_field_end();
1251 p.write_field_stop();
1252 p.write_struct_end();
1253 },
1254 ));
1255 self.transport()
1256 .call(request)
1257 .map_err(::std::convert::From::from)
1258 .and_then(|reply| ::futures::future::ready({
1259 let de = P::deserializer(reply);
1260 move |mut p: P::Deserializer| -> ::std::result::Result<crate::types::AppendLogResponse, crate::errors::raftex_service::AppendLogError> {
1261 let p = &mut p;
1262 let (_, message_type, _) = p.read_message_begin(|_| ())?;
1263 let result = match message_type {
1264 ::fbthrift::MessageType::Reply => {
1265 let exn: crate::services::raftex_service::AppendLogExn = ::fbthrift::Deserialize::read(p)?;
1266 match exn {
1267 crate::services::raftex_service::AppendLogExn::Success(x) => ::std::result::Result::Ok(x),
1268 crate::services::raftex_service::AppendLogExn::ApplicationException(ae) => {
1269 ::std::result::Result::Err(crate::errors::raftex_service::AppendLogError::ApplicationException(ae))
1270 }
1271 }
1272 }
1273 ::fbthrift::MessageType::Exception => {
1274 let ae: ::fbthrift::ApplicationException = ::fbthrift::Deserialize::read(p)?;
1275 ::std::result::Result::Err(crate::errors::raftex_service::AppendLogError::ApplicationException(ae))
1276 }
1277 ::fbthrift::MessageType::Call | ::fbthrift::MessageType::Oneway | ::fbthrift::MessageType::InvalidMessageType => {
1278 let err = ::anyhow::anyhow!("Unexpected message type {:?}", message_type);
1279 ::std::result::Result::Err(crate::errors::raftex_service::AppendLogError::ThriftError(err))
1280 }
1281 };
1282 p.read_message_end()?;
1283 result
1284 }(de)
1285 }))
1286 .boxed()
1287 }
1288 fn sendSnapshot(
1289 &self,
1290 arg_req: &crate::types::SendSnapshotRequest,
1291 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::SendSnapshotResponse, crate::errors::raftex_service::SendSnapshotError>> + ::std::marker::Send + 'static>> {
1292 use ::fbthrift::{ProtocolReader as _, ProtocolWriter as _};
1293 use ::futures::future::{FutureExt as _, TryFutureExt as _};
1294 let request = ::fbthrift::serialize!(P, |p| ::fbthrift::protocol::write_message(
1295 p,
1296 "sendSnapshot",
1297 ::fbthrift::MessageType::Call,
1298 0,
1302 |p| {
1303 p.write_struct_begin("args");
1304 p.write_field_begin("arg_req", ::fbthrift::TType::Struct, 1i16);
1305 ::fbthrift::Serialize::write(&arg_req, p);
1306 p.write_field_end();
1307 p.write_field_stop();
1308 p.write_struct_end();
1309 },
1310 ));
1311 self.transport()
1312 .call(request)
1313 .map_err(::std::convert::From::from)
1314 .and_then(|reply| ::futures::future::ready({
1315 let de = P::deserializer(reply);
1316 move |mut p: P::Deserializer| -> ::std::result::Result<crate::types::SendSnapshotResponse, crate::errors::raftex_service::SendSnapshotError> {
1317 let p = &mut p;
1318 let (_, message_type, _) = p.read_message_begin(|_| ())?;
1319 let result = match message_type {
1320 ::fbthrift::MessageType::Reply => {
1321 let exn: crate::services::raftex_service::SendSnapshotExn = ::fbthrift::Deserialize::read(p)?;
1322 match exn {
1323 crate::services::raftex_service::SendSnapshotExn::Success(x) => ::std::result::Result::Ok(x),
1324 crate::services::raftex_service::SendSnapshotExn::ApplicationException(ae) => {
1325 ::std::result::Result::Err(crate::errors::raftex_service::SendSnapshotError::ApplicationException(ae))
1326 }
1327 }
1328 }
1329 ::fbthrift::MessageType::Exception => {
1330 let ae: ::fbthrift::ApplicationException = ::fbthrift::Deserialize::read(p)?;
1331 ::std::result::Result::Err(crate::errors::raftex_service::SendSnapshotError::ApplicationException(ae))
1332 }
1333 ::fbthrift::MessageType::Call | ::fbthrift::MessageType::Oneway | ::fbthrift::MessageType::InvalidMessageType => {
1334 let err = ::anyhow::anyhow!("Unexpected message type {:?}", message_type);
1335 ::std::result::Result::Err(crate::errors::raftex_service::SendSnapshotError::ThriftError(err))
1336 }
1337 };
1338 p.read_message_end()?;
1339 result
1340 }(de)
1341 }))
1342 .boxed()
1343 }
1344 }
1345
1346 impl<'a, T> RaftexService for T
1347 where
1348 T: ::std::convert::AsRef<dyn RaftexService + 'a>,
1349 T: ::std::marker::Send,
1350 {
1351 fn askForVote(
1352 &self,
1353 arg_req: &crate::types::AskForVoteRequest,
1354 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AskForVoteResponse, crate::errors::raftex_service::AskForVoteError>> + ::std::marker::Send + 'static>> {
1355 self.as_ref().askForVote(
1356 arg_req,
1357 )
1358 }
1359 fn appendLog(
1360 &self,
1361 arg_req: &crate::types::AppendLogRequest,
1362 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AppendLogResponse, crate::errors::raftex_service::AppendLogError>> + ::std::marker::Send + 'static>> {
1363 self.as_ref().appendLog(
1364 arg_req,
1365 )
1366 }
1367 fn sendSnapshot(
1368 &self,
1369 arg_req: &crate::types::SendSnapshotRequest,
1370 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::SendSnapshotResponse, crate::errors::raftex_service::SendSnapshotError>> + ::std::marker::Send + 'static>> {
1371 self.as_ref().sendSnapshot(
1372 arg_req,
1373 )
1374 }
1375 }
1376
1377 pub struct make_RaftexService;
1378
1379 impl dyn RaftexService {
1391 pub fn new<P, T>(
1392 protocol: P,
1393 transport: T,
1394 ) -> ::std::sync::Arc<impl RaftexService + ::std::marker::Send + 'static>
1395 where
1396 P: ::fbthrift::Protocol<Frame = T>,
1397 T: ::fbthrift::Transport,
1398 {
1399 let _ = protocol;
1400 ::std::sync::Arc::new(RaftexServiceImpl::<P, T>::new(transport))
1401 }
1402 }
1403
1404 impl ::fbthrift::ClientFactory for make_RaftexService {
1407 type Api = dyn RaftexService + ::std::marker::Send + ::std::marker::Sync + 'static;
1408
1409 fn new<P, T>(protocol: P, transport: T) -> ::std::sync::Arc<Self::Api>
1410 where
1411 P: ::fbthrift::Protocol<Frame = T>,
1412 T: ::fbthrift::Transport + ::std::marker::Sync,
1413 {
1414 RaftexService::new(protocol, transport)
1415 }
1416 }
1417}
1418
1419pub mod server {
1420 #[::async_trait::async_trait]
1421 pub trait RaftexService: ::std::marker::Send + ::std::marker::Sync + 'static {
1422 async fn askForVote(
1423 &self,
1424 _req: crate::types::AskForVoteRequest,
1425 ) -> ::std::result::Result<crate::types::AskForVoteResponse, crate::services::raftex_service::AskForVoteExn> {
1426 ::std::result::Result::Err(crate::services::raftex_service::AskForVoteExn::ApplicationException(
1427 ::fbthrift::ApplicationException::unimplemented_method(
1428 "RaftexService",
1429 "askForVote",
1430 ),
1431 ))
1432 }
1433 async fn appendLog(
1434 &self,
1435 _req: crate::types::AppendLogRequest,
1436 ) -> ::std::result::Result<crate::types::AppendLogResponse, crate::services::raftex_service::AppendLogExn> {
1437 ::std::result::Result::Err(crate::services::raftex_service::AppendLogExn::ApplicationException(
1438 ::fbthrift::ApplicationException::unimplemented_method(
1439 "RaftexService",
1440 "appendLog",
1441 ),
1442 ))
1443 }
1444 async fn sendSnapshot(
1445 &self,
1446 _req: crate::types::SendSnapshotRequest,
1447 ) -> ::std::result::Result<crate::types::SendSnapshotResponse, crate::services::raftex_service::SendSnapshotExn> {
1448 ::std::result::Result::Err(crate::services::raftex_service::SendSnapshotExn::ApplicationException(
1449 ::fbthrift::ApplicationException::unimplemented_method(
1450 "RaftexService",
1451 "sendSnapshot",
1452 ),
1453 ))
1454 }
1455 }
1456
1457 #[derive(Clone, Debug)]
1458 pub struct RaftexServiceProcessor<P, H, R> {
1459 service: H,
1460 supa: ::fbthrift::NullServiceProcessor<P, R>,
1461 _phantom: ::std::marker::PhantomData<(P, H, R)>,
1462 }
1463
1464 impl<P, H, R> RaftexServiceProcessor<P, H, R>
1465 where
1466 P: ::fbthrift::Protocol + ::std::marker::Send + ::std::marker::Sync + 'static,
1467 P::Deserializer: ::std::marker::Send,
1468 H: RaftexService,
1469 {
1470 pub fn new(service: H) -> Self {
1471 Self {
1472 service,
1473 supa: ::fbthrift::NullServiceProcessor::new(),
1474 _phantom: ::std::marker::PhantomData,
1475 }
1476 }
1477
1478 pub fn into_inner(self) -> H {
1479 self.service
1480 }
1481
1482 async fn handle_askForVote<'a>(
1483 &'a self,
1484 p: &'a mut P::Deserializer,
1485 _req_ctxt: &R,
1486 seqid: ::std::primitive::u32,
1487 ) -> ::anyhow::Result<::fbthrift::ProtocolEncodedFinal<P>> {
1488 use ::fbthrift::ProtocolReader as _;
1489 let mut field_req = ::std::option::Option::None;
1490 let _ = p.read_struct_begin(|_| ())?;
1491 loop {
1492 let (_, fty, fid) = p.read_field_begin(|_| ())?;
1493 match (fty, fid as ::std::primitive::i32) {
1494 (::fbthrift::TType::Stop, _) => break,
1495 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1496 (fty, _) => p.skip(fty)?,
1497 }
1498 p.read_field_end()?;
1499 }
1500 p.read_struct_end()?;
1501 let res = self.service.askForVote(
1502 field_req.ok_or_else(|| {
1503 ::fbthrift::ApplicationException::missing_arg(
1504 "askForVote",
1505 "req",
1506 )
1507 })?,
1508 ).await;
1509 let res = match res {
1510 ::std::result::Result::Ok(res) => {
1511 crate::services::raftex_service::AskForVoteExn::Success(res)
1512 }
1513 ::std::result::Result::Err(crate::services::raftex_service::AskForVoteExn::ApplicationException(aexn)) => {
1514 return ::std::result::Result::Err(aexn.into())
1515 }
1516 ::std::result::Result::Err(crate::services::raftex_service::AskForVoteExn::Success(_)) => {
1517 panic!(
1518 "{} attempted to return success via error",
1519 "askForVote",
1520 )
1521 }
1522 };
1523 let res = ::fbthrift::serialize!(P, |p| ::fbthrift::protocol::write_message(
1524 p,
1525 "askForVote",
1526 ::fbthrift::MessageType::Reply,
1527 seqid,
1528 |p| ::fbthrift::Serialize::write(&res, p),
1529 ));
1530 ::std::result::Result::Ok(res)
1531 }
1532
1533 async fn handle_appendLog<'a>(
1534 &'a self,
1535 p: &'a mut P::Deserializer,
1536 _req_ctxt: &R,
1537 seqid: ::std::primitive::u32,
1538 ) -> ::anyhow::Result<::fbthrift::ProtocolEncodedFinal<P>> {
1539 use ::fbthrift::ProtocolReader as _;
1540 let mut field_req = ::std::option::Option::None;
1541 let _ = p.read_struct_begin(|_| ())?;
1542 loop {
1543 let (_, fty, fid) = p.read_field_begin(|_| ())?;
1544 match (fty, fid as ::std::primitive::i32) {
1545 (::fbthrift::TType::Stop, _) => break,
1546 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1547 (fty, _) => p.skip(fty)?,
1548 }
1549 p.read_field_end()?;
1550 }
1551 p.read_struct_end()?;
1552 let res = self.service.appendLog(
1553 field_req.ok_or_else(|| {
1554 ::fbthrift::ApplicationException::missing_arg(
1555 "appendLog",
1556 "req",
1557 )
1558 })?,
1559 ).await;
1560 let res = match res {
1561 ::std::result::Result::Ok(res) => {
1562 crate::services::raftex_service::AppendLogExn::Success(res)
1563 }
1564 ::std::result::Result::Err(crate::services::raftex_service::AppendLogExn::ApplicationException(aexn)) => {
1565 return ::std::result::Result::Err(aexn.into())
1566 }
1567 ::std::result::Result::Err(crate::services::raftex_service::AppendLogExn::Success(_)) => {
1568 panic!(
1569 "{} attempted to return success via error",
1570 "appendLog",
1571 )
1572 }
1573 };
1574 let res = ::fbthrift::serialize!(P, |p| ::fbthrift::protocol::write_message(
1575 p,
1576 "appendLog",
1577 ::fbthrift::MessageType::Reply,
1578 seqid,
1579 |p| ::fbthrift::Serialize::write(&res, p),
1580 ));
1581 ::std::result::Result::Ok(res)
1582 }
1583
1584 async fn handle_sendSnapshot<'a>(
1585 &'a self,
1586 p: &'a mut P::Deserializer,
1587 _req_ctxt: &R,
1588 seqid: ::std::primitive::u32,
1589 ) -> ::anyhow::Result<::fbthrift::ProtocolEncodedFinal<P>> {
1590 use ::fbthrift::ProtocolReader as _;
1591 let mut field_req = ::std::option::Option::None;
1592 let _ = p.read_struct_begin(|_| ())?;
1593 loop {
1594 let (_, fty, fid) = p.read_field_begin(|_| ())?;
1595 match (fty, fid as ::std::primitive::i32) {
1596 (::fbthrift::TType::Stop, _) => break,
1597 (::fbthrift::TType::Struct, 1) => field_req = ::std::option::Option::Some(::fbthrift::Deserialize::read(p)?),
1598 (fty, _) => p.skip(fty)?,
1599 }
1600 p.read_field_end()?;
1601 }
1602 p.read_struct_end()?;
1603 let res = self.service.sendSnapshot(
1604 field_req.ok_or_else(|| {
1605 ::fbthrift::ApplicationException::missing_arg(
1606 "sendSnapshot",
1607 "req",
1608 )
1609 })?,
1610 ).await;
1611 let res = match res {
1612 ::std::result::Result::Ok(res) => {
1613 crate::services::raftex_service::SendSnapshotExn::Success(res)
1614 }
1615 ::std::result::Result::Err(crate::services::raftex_service::SendSnapshotExn::ApplicationException(aexn)) => {
1616 return ::std::result::Result::Err(aexn.into())
1617 }
1618 ::std::result::Result::Err(crate::services::raftex_service::SendSnapshotExn::Success(_)) => {
1619 panic!(
1620 "{} attempted to return success via error",
1621 "sendSnapshot",
1622 )
1623 }
1624 };
1625 let res = ::fbthrift::serialize!(P, |p| ::fbthrift::protocol::write_message(
1626 p,
1627 "sendSnapshot",
1628 ::fbthrift::MessageType::Reply,
1629 seqid,
1630 |p| ::fbthrift::Serialize::write(&res, p),
1631 ));
1632 ::std::result::Result::Ok(res)
1633 }
1634 }
1635
1636 #[::async_trait::async_trait]
1637 impl<P, H, R> ::fbthrift::ServiceProcessor<P> for RaftexServiceProcessor<P, H, R>
1638 where
1639 P: ::fbthrift::Protocol + ::std::marker::Send + ::std::marker::Sync + 'static,
1640 P::Deserializer: ::std::marker::Send,
1641 H: RaftexService,
1642 R: ::std::marker::Send + ::std::marker::Sync + 'static,
1643 {
1644 type RequestContext = R;
1645
1646 #[inline]
1647 fn method_idx(&self, name: &[::std::primitive::u8]) -> ::std::result::Result<::std::primitive::usize, ::fbthrift::ApplicationException> {
1648 match name {
1649 b"askForVote" => ::std::result::Result::Ok(0usize),
1650 b"appendLog" => ::std::result::Result::Ok(1usize),
1651 b"sendSnapshot" => ::std::result::Result::Ok(2usize),
1652 _ => ::std::result::Result::Err(::fbthrift::ApplicationException::unknown_method()),
1653 }
1654 }
1655
1656 async fn handle_method(
1657 &self,
1658 idx: ::std::primitive::usize,
1659 _p: &mut P::Deserializer,
1660 _r: &R,
1661 _seqid: ::std::primitive::u32,
1662 ) -> ::anyhow::Result<::fbthrift::ProtocolEncodedFinal<P>> {
1663 match idx {
1664 0usize => self.handle_askForVote(_p, _r, _seqid).await,
1665 1usize => self.handle_appendLog(_p, _r, _seqid).await,
1666 2usize => self.handle_sendSnapshot(_p, _r, _seqid).await,
1667 bad => panic!(
1668 "{}: unexpected method idx {}",
1669 "RaftexServiceProcessor",
1670 bad
1671 ),
1672 }
1673 }
1674 }
1675
1676 #[::async_trait::async_trait]
1677 impl<P, H, R> ::fbthrift::ThriftService<P::Frame> for RaftexServiceProcessor<P, H, R>
1678 where
1679 P: ::fbthrift::Protocol + ::std::marker::Send + ::std::marker::Sync + 'static,
1680 P::Deserializer: ::std::marker::Send,
1681 P::Frame: ::std::marker::Send + 'static,
1682 H: RaftexService,
1683 R: ::std::marker::Send + ::std::marker::Sync + 'static,
1684 {
1685 type Handler = H;
1686 type RequestContext = R;
1687
1688 async fn call(
1689 &self,
1690 req: ::fbthrift::ProtocolDecoded<P>,
1691 req_ctxt: &R,
1692 ) -> ::anyhow::Result<::fbthrift::ProtocolEncodedFinal<P>> {
1693 use ::fbthrift::{BufExt as _, ProtocolReader as _, ServiceProcessor as _};
1694 let mut p = P::deserializer(req);
1695 let (idx, mty, seqid) = p.read_message_begin(|name| self.method_idx(name))?;
1696 if mty != ::fbthrift::MessageType::Call {
1697 return ::std::result::Result::Err(::std::convert::From::from(::fbthrift::ApplicationException::new(
1698 ::fbthrift::ApplicationExceptionErrorCode::InvalidMessageType,
1699 format!("message type {:?} not handled", mty)
1700 )));
1701 }
1702 let idx = match idx {
1703 ::std::result::Result::Ok(idx) => idx,
1704 ::std::result::Result::Err(_) => {
1705 let cur = P::into_buffer(p).reset();
1706 return self.supa.call(cur, req_ctxt).await;
1707 }
1708 };
1709 let res = self.handle_method(idx, &mut p, req_ctxt, seqid).await;
1710 p.read_message_end()?;
1711 match res {
1712 ::std::result::Result::Ok(bytes) => ::std::result::Result::Ok(bytes),
1713 ::std::result::Result::Err(err) => match err.downcast_ref::<::fbthrift::ProtocolError>() {
1714 ::std::option::Option::Some(::fbthrift::ProtocolError::ApplicationException(ae)) => {
1715 let res = ::fbthrift::serialize!(P, |p| {
1716 ::fbthrift::protocol::write_message(
1717 p,
1718 "RaftexServiceProcessor",
1719 ::fbthrift::MessageType::Exception,
1720 seqid,
1721 |p| ::fbthrift::Serialize::write(&ae, p),
1722 )
1723 });
1724 ::std::result::Result::Ok(res)
1725 }
1726 _ => ::std::result::Result::Err(err),
1727 },
1728 }
1729 }
1730 }
1731
1732 pub fn make_RaftexService_server<F, H, R>(
1733 proto: ::fbthrift::ProtocolID,
1734 handler: H,
1735 ) -> ::std::result::Result<::std::boxed::Box<dyn ::fbthrift::ThriftService<F, Handler = H, RequestContext = R> + ::std::marker::Send + 'static>, ::fbthrift::ApplicationException>
1736 where
1737 F: ::fbthrift::Framing + ::std::marker::Send + ::std::marker::Sync + 'static,
1738 H: RaftexService,
1739 R: ::std::marker::Send + ::std::marker::Sync + 'static,
1740 {
1741 match proto {
1742 ::fbthrift::ProtocolID::BinaryProtocol => {
1743 ::std::result::Result::Ok(::std::boxed::Box::new(RaftexServiceProcessor::<::fbthrift::BinaryProtocol<F>, H, R>::new(handler)))
1744 }
1745 ::fbthrift::ProtocolID::CompactProtocol => {
1746 ::std::result::Result::Ok(::std::boxed::Box::new(RaftexServiceProcessor::<::fbthrift::CompactProtocol<F>, H, R>::new(handler)))
1747 }
1748 bad => ::std::result::Result::Err(::fbthrift::ApplicationException::invalid_protocol(bad)),
1749 }
1750 }
1751}
1752
1753pub mod mock {
1830 pub struct RaftexService<'mock> {
1831 pub askForVote: r#impl::raftex_service::askForVote<'mock>,
1832 pub appendLog: r#impl::raftex_service::appendLog<'mock>,
1833 pub sendSnapshot: r#impl::raftex_service::sendSnapshot<'mock>,
1834 _marker: ::std::marker::PhantomData<&'mock ()>,
1835 }
1836
1837 impl dyn super::client::RaftexService {
1838 pub fn mock<'mock>() -> RaftexService<'mock> {
1839 RaftexService {
1840 askForVote: r#impl::raftex_service::askForVote::unimplemented(),
1841 appendLog: r#impl::raftex_service::appendLog::unimplemented(),
1842 sendSnapshot: r#impl::raftex_service::sendSnapshot::unimplemented(),
1843 _marker: ::std::marker::PhantomData,
1844 }
1845 }
1846 }
1847
1848 #[::async_trait::async_trait]
1849 impl<'mock> super::client::RaftexService for RaftexService<'mock> {
1850 fn askForVote(
1851 &self,
1852 arg_req: &crate::types::AskForVoteRequest,
1853 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AskForVoteResponse, crate::errors::raftex_service::AskForVoteError>> + ::std::marker::Send + 'static>> {
1854 let mut closure = self.askForVote.closure.lock().unwrap();
1855 let closure: &mut dyn ::std::ops::FnMut(crate::types::AskForVoteRequest) -> _ = &mut **closure;
1856 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
1857 }
1858 fn appendLog(
1859 &self,
1860 arg_req: &crate::types::AppendLogRequest,
1861 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::AppendLogResponse, crate::errors::raftex_service::AppendLogError>> + ::std::marker::Send + 'static>> {
1862 let mut closure = self.appendLog.closure.lock().unwrap();
1863 let closure: &mut dyn ::std::ops::FnMut(crate::types::AppendLogRequest) -> _ = &mut **closure;
1864 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
1865 }
1866 fn sendSnapshot(
1867 &self,
1868 arg_req: &crate::types::SendSnapshotRequest,
1869 ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<crate::types::SendSnapshotResponse, crate::errors::raftex_service::SendSnapshotError>> + ::std::marker::Send + 'static>> {
1870 let mut closure = self.sendSnapshot.closure.lock().unwrap();
1871 let closure: &mut dyn ::std::ops::FnMut(crate::types::SendSnapshotRequest) -> _ = &mut **closure;
1872 ::std::boxed::Box::pin(::futures::future::ready(closure(arg_req.clone())))
1873 }
1874 }
1875
1876 mod r#impl {
1877 pub mod raftex_service {
1878
1879 pub struct askForVote<'mock> {
1880 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
1881 dyn ::std::ops::FnMut(crate::types::AskForVoteRequest) -> ::std::result::Result<
1882 crate::types::AskForVoteResponse,
1883 crate::errors::raftex_service::AskForVoteError,
1884 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
1885 >>,
1886 }
1887
1888 impl<'mock> askForVote<'mock> {
1889 pub fn unimplemented() -> Self {
1890 askForVote {
1891 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::AskForVoteRequest| panic!(
1892 "{}::{} is not mocked",
1893 "RaftexService",
1894 "askForVote",
1895 ))),
1896 }
1897 }
1898
1899 pub fn ret(&self, value: crate::types::AskForVoteResponse) {
1900 self.mock(move |_: crate::types::AskForVoteRequest| value.clone());
1901 }
1902
1903 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::AskForVoteRequest) -> crate::types::AskForVoteResponse + ::std::marker::Send + ::std::marker::Sync + 'mock) {
1904 let mut closure = self.closure.lock().unwrap();
1905 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
1906 }
1907
1908 pub fn throw<E>(&self, exception: E)
1909 where
1910 E: ::std::convert::Into<crate::errors::raftex_service::AskForVoteError>,
1911 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
1912 {
1913 let mut closure = self.closure.lock().unwrap();
1914 *closure = ::std::boxed::Box::new(move |_: crate::types::AskForVoteRequest| ::std::result::Result::Err(exception.clone().into()));
1915 }
1916 }
1917
1918 pub struct appendLog<'mock> {
1919 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
1920 dyn ::std::ops::FnMut(crate::types::AppendLogRequest) -> ::std::result::Result<
1921 crate::types::AppendLogResponse,
1922 crate::errors::raftex_service::AppendLogError,
1923 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
1924 >>,
1925 }
1926
1927 impl<'mock> appendLog<'mock> {
1928 pub fn unimplemented() -> Self {
1929 appendLog {
1930 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::AppendLogRequest| panic!(
1931 "{}::{} is not mocked",
1932 "RaftexService",
1933 "appendLog",
1934 ))),
1935 }
1936 }
1937
1938 pub fn ret(&self, value: crate::types::AppendLogResponse) {
1939 self.mock(move |_: crate::types::AppendLogRequest| value.clone());
1940 }
1941
1942 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::AppendLogRequest) -> crate::types::AppendLogResponse + ::std::marker::Send + ::std::marker::Sync + 'mock) {
1943 let mut closure = self.closure.lock().unwrap();
1944 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
1945 }
1946
1947 pub fn throw<E>(&self, exception: E)
1948 where
1949 E: ::std::convert::Into<crate::errors::raftex_service::AppendLogError>,
1950 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
1951 {
1952 let mut closure = self.closure.lock().unwrap();
1953 *closure = ::std::boxed::Box::new(move |_: crate::types::AppendLogRequest| ::std::result::Result::Err(exception.clone().into()));
1954 }
1955 }
1956
1957 pub struct sendSnapshot<'mock> {
1958 pub(crate) closure: ::std::sync::Mutex<::std::boxed::Box<
1959 dyn ::std::ops::FnMut(crate::types::SendSnapshotRequest) -> ::std::result::Result<
1960 crate::types::SendSnapshotResponse,
1961 crate::errors::raftex_service::SendSnapshotError,
1962 > + ::std::marker::Send + ::std::marker::Sync + 'mock,
1963 >>,
1964 }
1965
1966 impl<'mock> sendSnapshot<'mock> {
1967 pub fn unimplemented() -> Self {
1968 sendSnapshot {
1969 closure: ::std::sync::Mutex::new(::std::boxed::Box::new(|_: crate::types::SendSnapshotRequest| panic!(
1970 "{}::{} is not mocked",
1971 "RaftexService",
1972 "sendSnapshot",
1973 ))),
1974 }
1975 }
1976
1977 pub fn ret(&self, value: crate::types::SendSnapshotResponse) {
1978 self.mock(move |_: crate::types::SendSnapshotRequest| value.clone());
1979 }
1980
1981 pub fn mock(&self, mut mock: impl ::std::ops::FnMut(crate::types::SendSnapshotRequest) -> crate::types::SendSnapshotResponse + ::std::marker::Send + ::std::marker::Sync + 'mock) {
1982 let mut closure = self.closure.lock().unwrap();
1983 *closure = ::std::boxed::Box::new(move |req| ::std::result::Result::Ok(mock(req)));
1984 }
1985
1986 pub fn throw<E>(&self, exception: E)
1987 where
1988 E: ::std::convert::Into<crate::errors::raftex_service::SendSnapshotError>,
1989 E: ::std::clone::Clone + ::std::marker::Send + ::std::marker::Sync + 'mock,
1990 {
1991 let mut closure = self.closure.lock().unwrap();
1992 *closure = ::std::boxed::Box::new(move |_: crate::types::SendSnapshotRequest| ::std::result::Result::Err(exception.clone().into()));
1993 }
1994 }
1995 }
1996 }
1997}
1998
1999pub mod errors {
2000 pub mod raftex_service {
2001
2002 pub type AskForVoteError = ::fbthrift::NonthrowingFunctionError;
2003
2004 pub type AppendLogError = ::fbthrift::NonthrowingFunctionError;
2005
2006 pub type SendSnapshotError = ::fbthrift::NonthrowingFunctionError;
2007
2008 }
2009
2010}