1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7
8#![allow(unused_attributes)]
9#![cfg_attr(rustfmt, rustfmt::skip)]
10
11#![allow(box_pointers)]
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_imports)]
19#![allow(unused_results)]
20#[derive(PartialEq,Clone,Default)]
27pub struct Entry {
28 pub entry_type: EntryType,
30 pub term: u64,
31 pub index: u64,
32 pub data: ::bytes::Bytes,
33 pub context: ::bytes::Bytes,
34 pub sync_log: bool,
35 pub unknown_fields: ::protobuf::UnknownFields,
37 pub cached_size: ::protobuf::CachedSize,
38}
39
40impl<'a> ::std::default::Default for &'a Entry {
41 fn default() -> &'a Entry {
42 <Entry as ::protobuf::Message>::default_instance()
43 }
44}
45
46impl Entry {
47 pub fn new() -> Entry {
48 ::std::default::Default::default()
49 }
50
51 pub fn get_entry_type(&self) -> EntryType {
55 self.entry_type
56 }
57 pub fn clear_entry_type(&mut self) {
58 self.entry_type = EntryType::EntryNormal;
59 }
60
61 pub fn set_entry_type(&mut self, v: EntryType) {
63 self.entry_type = v;
64 }
65
66 pub fn get_term(&self) -> u64 {
70 self.term
71 }
72 pub fn clear_term(&mut self) {
73 self.term = 0;
74 }
75
76 pub fn set_term(&mut self, v: u64) {
78 self.term = v;
79 }
80
81 pub fn get_index(&self) -> u64 {
85 self.index
86 }
87 pub fn clear_index(&mut self) {
88 self.index = 0;
89 }
90
91 pub fn set_index(&mut self, v: u64) {
93 self.index = v;
94 }
95
96 pub fn get_data(&self) -> &[u8] {
100 &self.data
101 }
102 pub fn clear_data(&mut self) {
103 self.data.clear();
104 }
105
106 pub fn set_data(&mut self, v: ::bytes::Bytes) {
108 self.data = v;
109 }
110
111 pub fn mut_data(&mut self) -> &mut ::bytes::Bytes {
114 &mut self.data
115 }
116
117 pub fn take_data(&mut self) -> ::bytes::Bytes {
119 ::std::mem::replace(&mut self.data, ::bytes::Bytes::new())
120 }
121
122 pub fn get_context(&self) -> &[u8] {
126 &self.context
127 }
128 pub fn clear_context(&mut self) {
129 self.context.clear();
130 }
131
132 pub fn set_context(&mut self, v: ::bytes::Bytes) {
134 self.context = v;
135 }
136
137 pub fn mut_context(&mut self) -> &mut ::bytes::Bytes {
140 &mut self.context
141 }
142
143 pub fn take_context(&mut self) -> ::bytes::Bytes {
145 ::std::mem::replace(&mut self.context, ::bytes::Bytes::new())
146 }
147
148 pub fn get_sync_log(&self) -> bool {
152 self.sync_log
153 }
154 pub fn clear_sync_log(&mut self) {
155 self.sync_log = false;
156 }
157
158 pub fn set_sync_log(&mut self, v: bool) {
160 self.sync_log = v;
161 }
162}
163
164impl ::protobuf::Message for Entry {
165 fn is_initialized(&self) -> bool {
166 true
167 }
168
169 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
170 while !is.eof()? {
171 let (field_number, wire_type) = is.read_tag_unpack()?;
172 match field_number {
173 1 => {
174 if wire_type == ::protobuf::wire_format::WireTypeVarint {self.entry_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
175 },
176 2 => {
177 if wire_type != ::protobuf::wire_format::WireTypeVarint {
178 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
179 }
180 let tmp = is.read_uint64()?;
181 self.term = tmp;
182 },
183 3 => {
184 if wire_type != ::protobuf::wire_format::WireTypeVarint {
185 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
186 }
187 let tmp = is.read_uint64()?;
188 self.index = tmp;
189 },
190 4 => {
191 ::protobuf::rt::read_singular_proto3_carllerche_bytes_into(wire_type, is, &mut self.data)?;
192 },
193 6 => {
194 ::protobuf::rt::read_singular_proto3_carllerche_bytes_into(wire_type, is, &mut self.context)?;
195 },
196 5 => {
197 if wire_type != ::protobuf::wire_format::WireTypeVarint {
198 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
199 }
200 let tmp = is.read_bool()?;
201 self.sync_log = tmp;
202 },
203 _ => {
204 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
205 },
206 };
207 }
208 ::std::result::Result::Ok(())
209 }
210
211 #[allow(unused_variables)]
213 fn compute_size(&self) -> u32 {
214 let mut my_size = 0;
215 if self.entry_type != EntryType::EntryNormal {
216 my_size += ::protobuf::rt::enum_size(1, self.entry_type);
217 }
218 if self.term != 0 {
219 my_size += ::protobuf::rt::value_size(2, self.term, ::protobuf::wire_format::WireTypeVarint);
220 }
221 if self.index != 0 {
222 my_size += ::protobuf::rt::value_size(3, self.index, ::protobuf::wire_format::WireTypeVarint);
223 }
224 if !self.data.is_empty() {
225 my_size += ::protobuf::rt::bytes_size(4, &self.data);
226 }
227 if !self.context.is_empty() {
228 my_size += ::protobuf::rt::bytes_size(6, &self.context);
229 }
230 if self.sync_log != false {
231 my_size += 2;
232 }
233 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
234 self.cached_size.set(my_size);
235 my_size
236 }
237
238 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
239 if self.entry_type != EntryType::EntryNormal {
240 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.entry_type))?;
241 }
242 if self.term != 0 {
243 os.write_uint64(2, self.term)?;
244 }
245 if self.index != 0 {
246 os.write_uint64(3, self.index)?;
247 }
248 if !self.data.is_empty() {
249 os.write_bytes(4, &self.data)?;
250 }
251 if !self.context.is_empty() {
252 os.write_bytes(6, &self.context)?;
253 }
254 if self.sync_log != false {
255 os.write_bool(5, self.sync_log)?;
256 }
257 os.write_unknown_fields(self.get_unknown_fields())?;
258 ::std::result::Result::Ok(())
259 }
260
261 fn get_cached_size(&self) -> u32 {
262 self.cached_size.get()
263 }
264
265 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
266 &self.unknown_fields
267 }
268
269 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
270 &mut self.unknown_fields
271 }
272
273 fn as_any(&self) -> &dyn (::std::any::Any) {
274 self as &dyn (::std::any::Any)
275 }
276 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
277 self as &mut dyn (::std::any::Any)
278 }
279 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
280 self
281 }
282
283 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
284 Self::descriptor_static()
285 }
286
287 fn new() -> Entry {
288 Entry::new()
289 }
290
291 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
292 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
293 descriptor.get(|| {
294 let mut fields = ::std::vec::Vec::new();
295 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EntryType>>(
296 "entry_type",
297 |m: &Entry| { &m.entry_type },
298 |m: &mut Entry| { &mut m.entry_type },
299 ));
300 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
301 "term",
302 |m: &Entry| { &m.term },
303 |m: &mut Entry| { &mut m.term },
304 ));
305 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
306 "index",
307 |m: &Entry| { &m.index },
308 |m: &mut Entry| { &mut m.index },
309 ));
310 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeCarllercheBytes>(
311 "data",
312 |m: &Entry| { &m.data },
313 |m: &mut Entry| { &mut m.data },
314 ));
315 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeCarllercheBytes>(
316 "context",
317 |m: &Entry| { &m.context },
318 |m: &mut Entry| { &mut m.context },
319 ));
320 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
321 "sync_log",
322 |m: &Entry| { &m.sync_log },
323 |m: &mut Entry| { &mut m.sync_log },
324 ));
325 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Entry>(
326 "Entry",
327 fields,
328 file_descriptor_proto()
329 )
330 })
331 }
332
333 fn default_instance() -> &'static Entry {
334 static instance: ::protobuf::rt::LazyV2<Entry> = ::protobuf::rt::LazyV2::INIT;
335 instance.get(Entry::new)
336 }
337}
338
339impl ::protobuf::Clear for Entry {
340 fn clear(&mut self) {
341 self.entry_type = EntryType::EntryNormal;
342 self.term = 0;
343 self.index = 0;
344 self.data.clear();
345 self.context.clear();
346 self.sync_log = false;
347 self.unknown_fields.clear();
348 }
349}
350
351impl ::std::fmt::Debug for Entry {
352 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
353 ::protobuf::text_format::fmt(self, f)
354 }
355}
356
357impl ::protobuf::reflect::ProtobufValue for Entry {
358 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
359 ::protobuf::reflect::ReflectValueRef::Message(self)
360 }
361}
362
363#[derive(PartialEq,Clone,Default)]
364pub struct SnapshotMetadata {
365 pub conf_state: ::protobuf::SingularPtrField<ConfState>,
367 pub index: u64,
368 pub term: u64,
369 pub unknown_fields: ::protobuf::UnknownFields,
371 pub cached_size: ::protobuf::CachedSize,
372}
373
374impl<'a> ::std::default::Default for &'a SnapshotMetadata {
375 fn default() -> &'a SnapshotMetadata {
376 <SnapshotMetadata as ::protobuf::Message>::default_instance()
377 }
378}
379
380impl SnapshotMetadata {
381 pub fn new() -> SnapshotMetadata {
382 ::std::default::Default::default()
383 }
384
385 pub fn get_conf_state(&self) -> &ConfState {
389 self.conf_state.as_ref().unwrap_or_else(|| <ConfState as ::protobuf::Message>::default_instance())
390 }
391 pub fn clear_conf_state(&mut self) {
392 self.conf_state.clear();
393 }
394
395 pub fn has_conf_state(&self) -> bool {
396 self.conf_state.is_some()
397 }
398
399 pub fn set_conf_state(&mut self, v: ConfState) {
401 self.conf_state = ::protobuf::SingularPtrField::some(v);
402 }
403
404 pub fn mut_conf_state(&mut self) -> &mut ConfState {
407 if self.conf_state.is_none() {
408 self.conf_state.set_default();
409 }
410 self.conf_state.as_mut().unwrap()
411 }
412
413 pub fn take_conf_state(&mut self) -> ConfState {
415 self.conf_state.take().unwrap_or_else(|| ConfState::new())
416 }
417
418 pub fn get_index(&self) -> u64 {
422 self.index
423 }
424 pub fn clear_index(&mut self) {
425 self.index = 0;
426 }
427
428 pub fn set_index(&mut self, v: u64) {
430 self.index = v;
431 }
432
433 pub fn get_term(&self) -> u64 {
437 self.term
438 }
439 pub fn clear_term(&mut self) {
440 self.term = 0;
441 }
442
443 pub fn set_term(&mut self, v: u64) {
445 self.term = v;
446 }
447}
448
449impl ::protobuf::Message for SnapshotMetadata {
450 fn is_initialized(&self) -> bool {
451 for v in &self.conf_state {
452 if !v.is_initialized() {
453 return false;
454 }
455 };
456 true
457 }
458
459 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
460 while !is.eof()? {
461 let (field_number, wire_type) = is.read_tag_unpack()?;
462 match field_number {
463 1 => {
464 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.conf_state)?;
465 },
466 2 => {
467 if wire_type != ::protobuf::wire_format::WireTypeVarint {
468 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
469 }
470 let tmp = is.read_uint64()?;
471 self.index = tmp;
472 },
473 3 => {
474 if wire_type != ::protobuf::wire_format::WireTypeVarint {
475 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
476 }
477 let tmp = is.read_uint64()?;
478 self.term = tmp;
479 },
480 _ => {
481 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
482 },
483 };
484 }
485 ::std::result::Result::Ok(())
486 }
487
488 #[allow(unused_variables)]
490 fn compute_size(&self) -> u32 {
491 let mut my_size = 0;
492 if let Some(ref v) = self.conf_state.as_ref() {
493 let len = v.compute_size();
494 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
495 }
496 if self.index != 0 {
497 my_size += ::protobuf::rt::value_size(2, self.index, ::protobuf::wire_format::WireTypeVarint);
498 }
499 if self.term != 0 {
500 my_size += ::protobuf::rt::value_size(3, self.term, ::protobuf::wire_format::WireTypeVarint);
501 }
502 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
503 self.cached_size.set(my_size);
504 my_size
505 }
506
507 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
508 if let Some(ref v) = self.conf_state.as_ref() {
509 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
510 os.write_raw_varint32(v.get_cached_size())?;
511 v.write_to_with_cached_sizes(os)?;
512 }
513 if self.index != 0 {
514 os.write_uint64(2, self.index)?;
515 }
516 if self.term != 0 {
517 os.write_uint64(3, self.term)?;
518 }
519 os.write_unknown_fields(self.get_unknown_fields())?;
520 ::std::result::Result::Ok(())
521 }
522
523 fn get_cached_size(&self) -> u32 {
524 self.cached_size.get()
525 }
526
527 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
528 &self.unknown_fields
529 }
530
531 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
532 &mut self.unknown_fields
533 }
534
535 fn as_any(&self) -> &dyn (::std::any::Any) {
536 self as &dyn (::std::any::Any)
537 }
538 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
539 self as &mut dyn (::std::any::Any)
540 }
541 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
542 self
543 }
544
545 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
546 Self::descriptor_static()
547 }
548
549 fn new() -> SnapshotMetadata {
550 SnapshotMetadata::new()
551 }
552
553 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
554 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
555 descriptor.get(|| {
556 let mut fields = ::std::vec::Vec::new();
557 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ConfState>>(
558 "conf_state",
559 |m: &SnapshotMetadata| { &m.conf_state },
560 |m: &mut SnapshotMetadata| { &mut m.conf_state },
561 ));
562 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
563 "index",
564 |m: &SnapshotMetadata| { &m.index },
565 |m: &mut SnapshotMetadata| { &mut m.index },
566 ));
567 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
568 "term",
569 |m: &SnapshotMetadata| { &m.term },
570 |m: &mut SnapshotMetadata| { &mut m.term },
571 ));
572 ::protobuf::reflect::MessageDescriptor::new_pb_name::<SnapshotMetadata>(
573 "SnapshotMetadata",
574 fields,
575 file_descriptor_proto()
576 )
577 })
578 }
579
580 fn default_instance() -> &'static SnapshotMetadata {
581 static instance: ::protobuf::rt::LazyV2<SnapshotMetadata> = ::protobuf::rt::LazyV2::INIT;
582 instance.get(SnapshotMetadata::new)
583 }
584}
585
586impl ::protobuf::Clear for SnapshotMetadata {
587 fn clear(&mut self) {
588 self.conf_state.clear();
589 self.index = 0;
590 self.term = 0;
591 self.unknown_fields.clear();
592 }
593}
594
595impl ::std::fmt::Debug for SnapshotMetadata {
596 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
597 ::protobuf::text_format::fmt(self, f)
598 }
599}
600
601impl ::protobuf::reflect::ProtobufValue for SnapshotMetadata {
602 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
603 ::protobuf::reflect::ReflectValueRef::Message(self)
604 }
605}
606
607#[derive(PartialEq,Clone,Default)]
608pub struct Snapshot {
609 pub data: ::bytes::Bytes,
611 pub metadata: ::protobuf::SingularPtrField<SnapshotMetadata>,
612 pub unknown_fields: ::protobuf::UnknownFields,
614 pub cached_size: ::protobuf::CachedSize,
615}
616
617impl<'a> ::std::default::Default for &'a Snapshot {
618 fn default() -> &'a Snapshot {
619 <Snapshot as ::protobuf::Message>::default_instance()
620 }
621}
622
623impl Snapshot {
624 pub fn new() -> Snapshot {
625 ::std::default::Default::default()
626 }
627
628 pub fn get_data(&self) -> &[u8] {
632 &self.data
633 }
634 pub fn clear_data(&mut self) {
635 self.data.clear();
636 }
637
638 pub fn set_data(&mut self, v: ::bytes::Bytes) {
640 self.data = v;
641 }
642
643 pub fn mut_data(&mut self) -> &mut ::bytes::Bytes {
646 &mut self.data
647 }
648
649 pub fn take_data(&mut self) -> ::bytes::Bytes {
651 ::std::mem::replace(&mut self.data, ::bytes::Bytes::new())
652 }
653
654 pub fn get_metadata(&self) -> &SnapshotMetadata {
658 self.metadata.as_ref().unwrap_or_else(|| <SnapshotMetadata as ::protobuf::Message>::default_instance())
659 }
660 pub fn clear_metadata(&mut self) {
661 self.metadata.clear();
662 }
663
664 pub fn has_metadata(&self) -> bool {
665 self.metadata.is_some()
666 }
667
668 pub fn set_metadata(&mut self, v: SnapshotMetadata) {
670 self.metadata = ::protobuf::SingularPtrField::some(v);
671 }
672
673 pub fn mut_metadata(&mut self) -> &mut SnapshotMetadata {
676 if self.metadata.is_none() {
677 self.metadata.set_default();
678 }
679 self.metadata.as_mut().unwrap()
680 }
681
682 pub fn take_metadata(&mut self) -> SnapshotMetadata {
684 self.metadata.take().unwrap_or_else(|| SnapshotMetadata::new())
685 }
686}
687
688impl ::protobuf::Message for Snapshot {
689 fn is_initialized(&self) -> bool {
690 for v in &self.metadata {
691 if !v.is_initialized() {
692 return false;
693 }
694 };
695 true
696 }
697
698 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
699 while !is.eof()? {
700 let (field_number, wire_type) = is.read_tag_unpack()?;
701 match field_number {
702 1 => {
703 ::protobuf::rt::read_singular_proto3_carllerche_bytes_into(wire_type, is, &mut self.data)?;
704 },
705 2 => {
706 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metadata)?;
707 },
708 _ => {
709 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
710 },
711 };
712 }
713 ::std::result::Result::Ok(())
714 }
715
716 #[allow(unused_variables)]
718 fn compute_size(&self) -> u32 {
719 let mut my_size = 0;
720 if !self.data.is_empty() {
721 my_size += ::protobuf::rt::bytes_size(1, &self.data);
722 }
723 if let Some(ref v) = self.metadata.as_ref() {
724 let len = v.compute_size();
725 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
726 }
727 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
728 self.cached_size.set(my_size);
729 my_size
730 }
731
732 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
733 if !self.data.is_empty() {
734 os.write_bytes(1, &self.data)?;
735 }
736 if let Some(ref v) = self.metadata.as_ref() {
737 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
738 os.write_raw_varint32(v.get_cached_size())?;
739 v.write_to_with_cached_sizes(os)?;
740 }
741 os.write_unknown_fields(self.get_unknown_fields())?;
742 ::std::result::Result::Ok(())
743 }
744
745 fn get_cached_size(&self) -> u32 {
746 self.cached_size.get()
747 }
748
749 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
750 &self.unknown_fields
751 }
752
753 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
754 &mut self.unknown_fields
755 }
756
757 fn as_any(&self) -> &dyn (::std::any::Any) {
758 self as &dyn (::std::any::Any)
759 }
760 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
761 self as &mut dyn (::std::any::Any)
762 }
763 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
764 self
765 }
766
767 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
768 Self::descriptor_static()
769 }
770
771 fn new() -> Snapshot {
772 Snapshot::new()
773 }
774
775 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
776 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
777 descriptor.get(|| {
778 let mut fields = ::std::vec::Vec::new();
779 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeCarllercheBytes>(
780 "data",
781 |m: &Snapshot| { &m.data },
782 |m: &mut Snapshot| { &mut m.data },
783 ));
784 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SnapshotMetadata>>(
785 "metadata",
786 |m: &Snapshot| { &m.metadata },
787 |m: &mut Snapshot| { &mut m.metadata },
788 ));
789 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Snapshot>(
790 "Snapshot",
791 fields,
792 file_descriptor_proto()
793 )
794 })
795 }
796
797 fn default_instance() -> &'static Snapshot {
798 static instance: ::protobuf::rt::LazyV2<Snapshot> = ::protobuf::rt::LazyV2::INIT;
799 instance.get(Snapshot::new)
800 }
801}
802
803impl ::protobuf::Clear for Snapshot {
804 fn clear(&mut self) {
805 self.data.clear();
806 self.metadata.clear();
807 self.unknown_fields.clear();
808 }
809}
810
811impl ::std::fmt::Debug for Snapshot {
812 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
813 ::protobuf::text_format::fmt(self, f)
814 }
815}
816
817impl ::protobuf::reflect::ProtobufValue for Snapshot {
818 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
819 ::protobuf::reflect::ReflectValueRef::Message(self)
820 }
821}
822
823#[derive(PartialEq,Clone,Default)]
824pub struct Message {
825 pub msg_type: MessageType,
827 pub to: u64,
828 pub from: u64,
829 pub term: u64,
830 pub log_term: u64,
831 pub index: u64,
832 pub entries: ::protobuf::RepeatedField<Entry>,
833 pub commit: u64,
834 pub commit_term: u64,
835 pub snapshot: ::protobuf::SingularPtrField<Snapshot>,
836 pub request_snapshot: u64,
837 pub reject: bool,
838 pub reject_hint: u64,
839 pub context: ::bytes::Bytes,
840 pub deprecated_priority: u64,
841 pub priority: i64,
842 pub unknown_fields: ::protobuf::UnknownFields,
844 pub cached_size: ::protobuf::CachedSize,
845}
846
847impl<'a> ::std::default::Default for &'a Message {
848 fn default() -> &'a Message {
849 <Message as ::protobuf::Message>::default_instance()
850 }
851}
852
853impl Message {
854 pub fn new() -> Message {
855 ::std::default::Default::default()
856 }
857
858 pub fn get_msg_type(&self) -> MessageType {
862 self.msg_type
863 }
864 pub fn clear_msg_type(&mut self) {
865 self.msg_type = MessageType::MsgHup;
866 }
867
868 pub fn set_msg_type(&mut self, v: MessageType) {
870 self.msg_type = v;
871 }
872
873 pub fn get_to(&self) -> u64 {
877 self.to
878 }
879 pub fn clear_to(&mut self) {
880 self.to = 0;
881 }
882
883 pub fn set_to(&mut self, v: u64) {
885 self.to = v;
886 }
887
888 pub fn get_from(&self) -> u64 {
892 self.from
893 }
894 pub fn clear_from(&mut self) {
895 self.from = 0;
896 }
897
898 pub fn set_from(&mut self, v: u64) {
900 self.from = v;
901 }
902
903 pub fn get_term(&self) -> u64 {
907 self.term
908 }
909 pub fn clear_term(&mut self) {
910 self.term = 0;
911 }
912
913 pub fn set_term(&mut self, v: u64) {
915 self.term = v;
916 }
917
918 pub fn get_log_term(&self) -> u64 {
922 self.log_term
923 }
924 pub fn clear_log_term(&mut self) {
925 self.log_term = 0;
926 }
927
928 pub fn set_log_term(&mut self, v: u64) {
930 self.log_term = v;
931 }
932
933 pub fn get_index(&self) -> u64 {
937 self.index
938 }
939 pub fn clear_index(&mut self) {
940 self.index = 0;
941 }
942
943 pub fn set_index(&mut self, v: u64) {
945 self.index = v;
946 }
947
948 pub fn get_entries(&self) -> &[Entry] {
952 &self.entries
953 }
954 pub fn clear_entries(&mut self) {
955 self.entries.clear();
956 }
957
958 pub fn set_entries(&mut self, v: ::protobuf::RepeatedField<Entry>) {
960 self.entries = v;
961 }
962
963 pub fn mut_entries(&mut self) -> &mut ::protobuf::RepeatedField<Entry> {
965 &mut self.entries
966 }
967
968 pub fn take_entries(&mut self) -> ::protobuf::RepeatedField<Entry> {
970 ::std::mem::replace(&mut self.entries, ::protobuf::RepeatedField::new())
971 }
972
973 pub fn get_commit(&self) -> u64 {
977 self.commit
978 }
979 pub fn clear_commit(&mut self) {
980 self.commit = 0;
981 }
982
983 pub fn set_commit(&mut self, v: u64) {
985 self.commit = v;
986 }
987
988 pub fn get_commit_term(&self) -> u64 {
992 self.commit_term
993 }
994 pub fn clear_commit_term(&mut self) {
995 self.commit_term = 0;
996 }
997
998 pub fn set_commit_term(&mut self, v: u64) {
1000 self.commit_term = v;
1001 }
1002
1003 pub fn get_snapshot(&self) -> &Snapshot {
1007 self.snapshot.as_ref().unwrap_or_else(|| <Snapshot as ::protobuf::Message>::default_instance())
1008 }
1009 pub fn clear_snapshot(&mut self) {
1010 self.snapshot.clear();
1011 }
1012
1013 pub fn has_snapshot(&self) -> bool {
1014 self.snapshot.is_some()
1015 }
1016
1017 pub fn set_snapshot(&mut self, v: Snapshot) {
1019 self.snapshot = ::protobuf::SingularPtrField::some(v);
1020 }
1021
1022 pub fn mut_snapshot(&mut self) -> &mut Snapshot {
1025 if self.snapshot.is_none() {
1026 self.snapshot.set_default();
1027 }
1028 self.snapshot.as_mut().unwrap()
1029 }
1030
1031 pub fn take_snapshot(&mut self) -> Snapshot {
1033 self.snapshot.take().unwrap_or_else(|| Snapshot::new())
1034 }
1035
1036 pub fn get_request_snapshot(&self) -> u64 {
1040 self.request_snapshot
1041 }
1042 pub fn clear_request_snapshot(&mut self) {
1043 self.request_snapshot = 0;
1044 }
1045
1046 pub fn set_request_snapshot(&mut self, v: u64) {
1048 self.request_snapshot = v;
1049 }
1050
1051 pub fn get_reject(&self) -> bool {
1055 self.reject
1056 }
1057 pub fn clear_reject(&mut self) {
1058 self.reject = false;
1059 }
1060
1061 pub fn set_reject(&mut self, v: bool) {
1063 self.reject = v;
1064 }
1065
1066 pub fn get_reject_hint(&self) -> u64 {
1070 self.reject_hint
1071 }
1072 pub fn clear_reject_hint(&mut self) {
1073 self.reject_hint = 0;
1074 }
1075
1076 pub fn set_reject_hint(&mut self, v: u64) {
1078 self.reject_hint = v;
1079 }
1080
1081 pub fn get_context(&self) -> &[u8] {
1085 &self.context
1086 }
1087 pub fn clear_context(&mut self) {
1088 self.context.clear();
1089 }
1090
1091 pub fn set_context(&mut self, v: ::bytes::Bytes) {
1093 self.context = v;
1094 }
1095
1096 pub fn mut_context(&mut self) -> &mut ::bytes::Bytes {
1099 &mut self.context
1100 }
1101
1102 pub fn take_context(&mut self) -> ::bytes::Bytes {
1104 ::std::mem::replace(&mut self.context, ::bytes::Bytes::new())
1105 }
1106
1107 pub fn get_deprecated_priority(&self) -> u64 {
1111 self.deprecated_priority
1112 }
1113 pub fn clear_deprecated_priority(&mut self) {
1114 self.deprecated_priority = 0;
1115 }
1116
1117 pub fn set_deprecated_priority(&mut self, v: u64) {
1119 self.deprecated_priority = v;
1120 }
1121
1122 pub fn get_priority(&self) -> i64 {
1126 self.priority
1127 }
1128 pub fn clear_priority(&mut self) {
1129 self.priority = 0;
1130 }
1131
1132 pub fn set_priority(&mut self, v: i64) {
1134 self.priority = v;
1135 }
1136}
1137
1138impl ::protobuf::Message for Message {
1139 fn is_initialized(&self) -> bool {
1140 for v in &self.entries {
1141 if !v.is_initialized() {
1142 return false;
1143 }
1144 };
1145 for v in &self.snapshot {
1146 if !v.is_initialized() {
1147 return false;
1148 }
1149 };
1150 true
1151 }
1152
1153 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1154 while !is.eof()? {
1155 let (field_number, wire_type) = is.read_tag_unpack()?;
1156 match field_number {
1157 1 => {
1158 if wire_type == ::protobuf::wire_format::WireTypeVarint {self.msg_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
1159 },
1160 2 => {
1161 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1162 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1163 }
1164 let tmp = is.read_uint64()?;
1165 self.to = tmp;
1166 },
1167 3 => {
1168 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1169 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1170 }
1171 let tmp = is.read_uint64()?;
1172 self.from = tmp;
1173 },
1174 4 => {
1175 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1176 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1177 }
1178 let tmp = is.read_uint64()?;
1179 self.term = tmp;
1180 },
1181 5 => {
1182 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1183 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1184 }
1185 let tmp = is.read_uint64()?;
1186 self.log_term = tmp;
1187 },
1188 6 => {
1189 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1190 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1191 }
1192 let tmp = is.read_uint64()?;
1193 self.index = tmp;
1194 },
1195 7 => {
1196 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entries)?;
1197 },
1198 8 => {
1199 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1200 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1201 }
1202 let tmp = is.read_uint64()?;
1203 self.commit = tmp;
1204 },
1205 15 => {
1206 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1207 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1208 }
1209 let tmp = is.read_uint64()?;
1210 self.commit_term = tmp;
1211 },
1212 9 => {
1213 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.snapshot)?;
1214 },
1215 13 => {
1216 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1217 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1218 }
1219 let tmp = is.read_uint64()?;
1220 self.request_snapshot = tmp;
1221 },
1222 10 => {
1223 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1224 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1225 }
1226 let tmp = is.read_bool()?;
1227 self.reject = tmp;
1228 },
1229 11 => {
1230 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1231 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1232 }
1233 let tmp = is.read_uint64()?;
1234 self.reject_hint = tmp;
1235 },
1236 12 => {
1237 ::protobuf::rt::read_singular_proto3_carllerche_bytes_into(wire_type, is, &mut self.context)?;
1238 },
1239 14 => {
1240 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1241 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1242 }
1243 let tmp = is.read_uint64()?;
1244 self.deprecated_priority = tmp;
1245 },
1246 16 => {
1247 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1248 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1249 }
1250 let tmp = is.read_int64()?;
1251 self.priority = tmp;
1252 },
1253 _ => {
1254 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1255 },
1256 };
1257 }
1258 ::std::result::Result::Ok(())
1259 }
1260
1261 #[allow(unused_variables)]
1263 fn compute_size(&self) -> u32 {
1264 let mut my_size = 0;
1265 if self.msg_type != MessageType::MsgHup {
1266 my_size += ::protobuf::rt::enum_size(1, self.msg_type);
1267 }
1268 if self.to != 0 {
1269 my_size += ::protobuf::rt::value_size(2, self.to, ::protobuf::wire_format::WireTypeVarint);
1270 }
1271 if self.from != 0 {
1272 my_size += ::protobuf::rt::value_size(3, self.from, ::protobuf::wire_format::WireTypeVarint);
1273 }
1274 if self.term != 0 {
1275 my_size += ::protobuf::rt::value_size(4, self.term, ::protobuf::wire_format::WireTypeVarint);
1276 }
1277 if self.log_term != 0 {
1278 my_size += ::protobuf::rt::value_size(5, self.log_term, ::protobuf::wire_format::WireTypeVarint);
1279 }
1280 if self.index != 0 {
1281 my_size += ::protobuf::rt::value_size(6, self.index, ::protobuf::wire_format::WireTypeVarint);
1282 }
1283 for value in &self.entries {
1284 let len = value.compute_size();
1285 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1286 };
1287 if self.commit != 0 {
1288 my_size += ::protobuf::rt::value_size(8, self.commit, ::protobuf::wire_format::WireTypeVarint);
1289 }
1290 if self.commit_term != 0 {
1291 my_size += ::protobuf::rt::value_size(15, self.commit_term, ::protobuf::wire_format::WireTypeVarint);
1292 }
1293 if let Some(ref v) = self.snapshot.as_ref() {
1294 let len = v.compute_size();
1295 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1296 }
1297 if self.request_snapshot != 0 {
1298 my_size += ::protobuf::rt::value_size(13, self.request_snapshot, ::protobuf::wire_format::WireTypeVarint);
1299 }
1300 if self.reject != false {
1301 my_size += 2;
1302 }
1303 if self.reject_hint != 0 {
1304 my_size += ::protobuf::rt::value_size(11, self.reject_hint, ::protobuf::wire_format::WireTypeVarint);
1305 }
1306 if !self.context.is_empty() {
1307 my_size += ::protobuf::rt::bytes_size(12, &self.context);
1308 }
1309 if self.deprecated_priority != 0 {
1310 my_size += ::protobuf::rt::value_size(14, self.deprecated_priority, ::protobuf::wire_format::WireTypeVarint);
1311 }
1312 if self.priority != 0 {
1313 my_size += ::protobuf::rt::value_size(16, self.priority, ::protobuf::wire_format::WireTypeVarint);
1314 }
1315 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1316 self.cached_size.set(my_size);
1317 my_size
1318 }
1319
1320 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1321 if self.msg_type != MessageType::MsgHup {
1322 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.msg_type))?;
1323 }
1324 if self.to != 0 {
1325 os.write_uint64(2, self.to)?;
1326 }
1327 if self.from != 0 {
1328 os.write_uint64(3, self.from)?;
1329 }
1330 if self.term != 0 {
1331 os.write_uint64(4, self.term)?;
1332 }
1333 if self.log_term != 0 {
1334 os.write_uint64(5, self.log_term)?;
1335 }
1336 if self.index != 0 {
1337 os.write_uint64(6, self.index)?;
1338 }
1339 for v in &self.entries {
1340 os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1341 os.write_raw_varint32(v.get_cached_size())?;
1342 v.write_to_with_cached_sizes(os)?;
1343 };
1344 if self.commit != 0 {
1345 os.write_uint64(8, self.commit)?;
1346 }
1347 if self.commit_term != 0 {
1348 os.write_uint64(15, self.commit_term)?;
1349 }
1350 if let Some(ref v) = self.snapshot.as_ref() {
1351 os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1352 os.write_raw_varint32(v.get_cached_size())?;
1353 v.write_to_with_cached_sizes(os)?;
1354 }
1355 if self.request_snapshot != 0 {
1356 os.write_uint64(13, self.request_snapshot)?;
1357 }
1358 if self.reject != false {
1359 os.write_bool(10, self.reject)?;
1360 }
1361 if self.reject_hint != 0 {
1362 os.write_uint64(11, self.reject_hint)?;
1363 }
1364 if !self.context.is_empty() {
1365 os.write_bytes(12, &self.context)?;
1366 }
1367 if self.deprecated_priority != 0 {
1368 os.write_uint64(14, self.deprecated_priority)?;
1369 }
1370 if self.priority != 0 {
1371 os.write_int64(16, self.priority)?;
1372 }
1373 os.write_unknown_fields(self.get_unknown_fields())?;
1374 ::std::result::Result::Ok(())
1375 }
1376
1377 fn get_cached_size(&self) -> u32 {
1378 self.cached_size.get()
1379 }
1380
1381 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1382 &self.unknown_fields
1383 }
1384
1385 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1386 &mut self.unknown_fields
1387 }
1388
1389 fn as_any(&self) -> &dyn (::std::any::Any) {
1390 self as &dyn (::std::any::Any)
1391 }
1392 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1393 self as &mut dyn (::std::any::Any)
1394 }
1395 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1396 self
1397 }
1398
1399 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1400 Self::descriptor_static()
1401 }
1402
1403 fn new() -> Message {
1404 Message::new()
1405 }
1406
1407 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1408 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1409 descriptor.get(|| {
1410 let mut fields = ::std::vec::Vec::new();
1411 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<MessageType>>(
1412 "msg_type",
1413 |m: &Message| { &m.msg_type },
1414 |m: &mut Message| { &mut m.msg_type },
1415 ));
1416 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1417 "to",
1418 |m: &Message| { &m.to },
1419 |m: &mut Message| { &mut m.to },
1420 ));
1421 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1422 "from",
1423 |m: &Message| { &m.from },
1424 |m: &mut Message| { &mut m.from },
1425 ));
1426 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1427 "term",
1428 |m: &Message| { &m.term },
1429 |m: &mut Message| { &mut m.term },
1430 ));
1431 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1432 "log_term",
1433 |m: &Message| { &m.log_term },
1434 |m: &mut Message| { &mut m.log_term },
1435 ));
1436 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1437 "index",
1438 |m: &Message| { &m.index },
1439 |m: &mut Message| { &mut m.index },
1440 ));
1441 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Entry>>(
1442 "entries",
1443 |m: &Message| { &m.entries },
1444 |m: &mut Message| { &mut m.entries },
1445 ));
1446 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1447 "commit",
1448 |m: &Message| { &m.commit },
1449 |m: &mut Message| { &mut m.commit },
1450 ));
1451 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1452 "commit_term",
1453 |m: &Message| { &m.commit_term },
1454 |m: &mut Message| { &mut m.commit_term },
1455 ));
1456 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Snapshot>>(
1457 "snapshot",
1458 |m: &Message| { &m.snapshot },
1459 |m: &mut Message| { &mut m.snapshot },
1460 ));
1461 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1462 "request_snapshot",
1463 |m: &Message| { &m.request_snapshot },
1464 |m: &mut Message| { &mut m.request_snapshot },
1465 ));
1466 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
1467 "reject",
1468 |m: &Message| { &m.reject },
1469 |m: &mut Message| { &mut m.reject },
1470 ));
1471 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1472 "reject_hint",
1473 |m: &Message| { &m.reject_hint },
1474 |m: &mut Message| { &mut m.reject_hint },
1475 ));
1476 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeCarllercheBytes>(
1477 "context",
1478 |m: &Message| { &m.context },
1479 |m: &mut Message| { &mut m.context },
1480 ));
1481 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1482 "deprecated_priority",
1483 |m: &Message| { &m.deprecated_priority },
1484 |m: &mut Message| { &mut m.deprecated_priority },
1485 ));
1486 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
1487 "priority",
1488 |m: &Message| { &m.priority },
1489 |m: &mut Message| { &mut m.priority },
1490 ));
1491 ::protobuf::reflect::MessageDescriptor::new_pb_name::<Message>(
1492 "Message",
1493 fields,
1494 file_descriptor_proto()
1495 )
1496 })
1497 }
1498
1499 fn default_instance() -> &'static Message {
1500 static instance: ::protobuf::rt::LazyV2<Message> = ::protobuf::rt::LazyV2::INIT;
1501 instance.get(Message::new)
1502 }
1503}
1504
1505impl ::protobuf::Clear for Message {
1506 fn clear(&mut self) {
1507 self.msg_type = MessageType::MsgHup;
1508 self.to = 0;
1509 self.from = 0;
1510 self.term = 0;
1511 self.log_term = 0;
1512 self.index = 0;
1513 self.entries.clear();
1514 self.commit = 0;
1515 self.commit_term = 0;
1516 self.snapshot.clear();
1517 self.request_snapshot = 0;
1518 self.reject = false;
1519 self.reject_hint = 0;
1520 self.context.clear();
1521 self.deprecated_priority = 0;
1522 self.priority = 0;
1523 self.unknown_fields.clear();
1524 }
1525}
1526
1527impl ::std::fmt::Debug for Message {
1528 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1529 ::protobuf::text_format::fmt(self, f)
1530 }
1531}
1532
1533impl ::protobuf::reflect::ProtobufValue for Message {
1534 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1535 ::protobuf::reflect::ReflectValueRef::Message(self)
1536 }
1537}
1538
1539#[derive(PartialEq,Clone,Default)]
1540pub struct HardState {
1541 pub term: u64,
1543 pub vote: u64,
1544 pub commit: u64,
1545 pub unknown_fields: ::protobuf::UnknownFields,
1547 pub cached_size: ::protobuf::CachedSize,
1548}
1549
1550impl<'a> ::std::default::Default for &'a HardState {
1551 fn default() -> &'a HardState {
1552 <HardState as ::protobuf::Message>::default_instance()
1553 }
1554}
1555
1556impl HardState {
1557 pub fn new() -> HardState {
1558 ::std::default::Default::default()
1559 }
1560
1561 pub fn get_term(&self) -> u64 {
1565 self.term
1566 }
1567 pub fn clear_term(&mut self) {
1568 self.term = 0;
1569 }
1570
1571 pub fn set_term(&mut self, v: u64) {
1573 self.term = v;
1574 }
1575
1576 pub fn get_vote(&self) -> u64 {
1580 self.vote
1581 }
1582 pub fn clear_vote(&mut self) {
1583 self.vote = 0;
1584 }
1585
1586 pub fn set_vote(&mut self, v: u64) {
1588 self.vote = v;
1589 }
1590
1591 pub fn get_commit(&self) -> u64 {
1595 self.commit
1596 }
1597 pub fn clear_commit(&mut self) {
1598 self.commit = 0;
1599 }
1600
1601 pub fn set_commit(&mut self, v: u64) {
1603 self.commit = v;
1604 }
1605}
1606
1607impl ::protobuf::Message for HardState {
1608 fn is_initialized(&self) -> bool {
1609 true
1610 }
1611
1612 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1613 while !is.eof()? {
1614 let (field_number, wire_type) = is.read_tag_unpack()?;
1615 match field_number {
1616 1 => {
1617 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1618 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1619 }
1620 let tmp = is.read_uint64()?;
1621 self.term = tmp;
1622 },
1623 2 => {
1624 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1625 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1626 }
1627 let tmp = is.read_uint64()?;
1628 self.vote = tmp;
1629 },
1630 3 => {
1631 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1632 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1633 }
1634 let tmp = is.read_uint64()?;
1635 self.commit = tmp;
1636 },
1637 _ => {
1638 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1639 },
1640 };
1641 }
1642 ::std::result::Result::Ok(())
1643 }
1644
1645 #[allow(unused_variables)]
1647 fn compute_size(&self) -> u32 {
1648 let mut my_size = 0;
1649 if self.term != 0 {
1650 my_size += ::protobuf::rt::value_size(1, self.term, ::protobuf::wire_format::WireTypeVarint);
1651 }
1652 if self.vote != 0 {
1653 my_size += ::protobuf::rt::value_size(2, self.vote, ::protobuf::wire_format::WireTypeVarint);
1654 }
1655 if self.commit != 0 {
1656 my_size += ::protobuf::rt::value_size(3, self.commit, ::protobuf::wire_format::WireTypeVarint);
1657 }
1658 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1659 self.cached_size.set(my_size);
1660 my_size
1661 }
1662
1663 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1664 if self.term != 0 {
1665 os.write_uint64(1, self.term)?;
1666 }
1667 if self.vote != 0 {
1668 os.write_uint64(2, self.vote)?;
1669 }
1670 if self.commit != 0 {
1671 os.write_uint64(3, self.commit)?;
1672 }
1673 os.write_unknown_fields(self.get_unknown_fields())?;
1674 ::std::result::Result::Ok(())
1675 }
1676
1677 fn get_cached_size(&self) -> u32 {
1678 self.cached_size.get()
1679 }
1680
1681 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1682 &self.unknown_fields
1683 }
1684
1685 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1686 &mut self.unknown_fields
1687 }
1688
1689 fn as_any(&self) -> &dyn (::std::any::Any) {
1690 self as &dyn (::std::any::Any)
1691 }
1692 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1693 self as &mut dyn (::std::any::Any)
1694 }
1695 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1696 self
1697 }
1698
1699 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1700 Self::descriptor_static()
1701 }
1702
1703 fn new() -> HardState {
1704 HardState::new()
1705 }
1706
1707 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1708 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1709 descriptor.get(|| {
1710 let mut fields = ::std::vec::Vec::new();
1711 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1712 "term",
1713 |m: &HardState| { &m.term },
1714 |m: &mut HardState| { &mut m.term },
1715 ));
1716 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1717 "vote",
1718 |m: &HardState| { &m.vote },
1719 |m: &mut HardState| { &mut m.vote },
1720 ));
1721 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
1722 "commit",
1723 |m: &HardState| { &m.commit },
1724 |m: &mut HardState| { &mut m.commit },
1725 ));
1726 ::protobuf::reflect::MessageDescriptor::new_pb_name::<HardState>(
1727 "HardState",
1728 fields,
1729 file_descriptor_proto()
1730 )
1731 })
1732 }
1733
1734 fn default_instance() -> &'static HardState {
1735 static instance: ::protobuf::rt::LazyV2<HardState> = ::protobuf::rt::LazyV2::INIT;
1736 instance.get(HardState::new)
1737 }
1738}
1739
1740impl ::protobuf::Clear for HardState {
1741 fn clear(&mut self) {
1742 self.term = 0;
1743 self.vote = 0;
1744 self.commit = 0;
1745 self.unknown_fields.clear();
1746 }
1747}
1748
1749impl ::std::fmt::Debug for HardState {
1750 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1751 ::protobuf::text_format::fmt(self, f)
1752 }
1753}
1754
1755impl ::protobuf::reflect::ProtobufValue for HardState {
1756 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1757 ::protobuf::reflect::ReflectValueRef::Message(self)
1758 }
1759}
1760
1761#[derive(PartialEq,Clone,Default)]
1762pub struct ConfState {
1763 pub voters: ::std::vec::Vec<u64>,
1765 pub learners: ::std::vec::Vec<u64>,
1766 pub voters_outgoing: ::std::vec::Vec<u64>,
1767 pub learners_next: ::std::vec::Vec<u64>,
1768 pub auto_leave: bool,
1769 pub unknown_fields: ::protobuf::UnknownFields,
1771 pub cached_size: ::protobuf::CachedSize,
1772}
1773
1774impl<'a> ::std::default::Default for &'a ConfState {
1775 fn default() -> &'a ConfState {
1776 <ConfState as ::protobuf::Message>::default_instance()
1777 }
1778}
1779
1780impl ConfState {
1781 pub fn new() -> ConfState {
1782 ::std::default::Default::default()
1783 }
1784
1785 pub fn get_voters(&self) -> &[u64] {
1789 &self.voters
1790 }
1791 pub fn clear_voters(&mut self) {
1792 self.voters.clear();
1793 }
1794
1795 pub fn set_voters(&mut self, v: ::std::vec::Vec<u64>) {
1797 self.voters = v;
1798 }
1799
1800 pub fn mut_voters(&mut self) -> &mut ::std::vec::Vec<u64> {
1802 &mut self.voters
1803 }
1804
1805 pub fn take_voters(&mut self) -> ::std::vec::Vec<u64> {
1807 ::std::mem::replace(&mut self.voters, ::std::vec::Vec::new())
1808 }
1809
1810 pub fn get_learners(&self) -> &[u64] {
1814 &self.learners
1815 }
1816 pub fn clear_learners(&mut self) {
1817 self.learners.clear();
1818 }
1819
1820 pub fn set_learners(&mut self, v: ::std::vec::Vec<u64>) {
1822 self.learners = v;
1823 }
1824
1825 pub fn mut_learners(&mut self) -> &mut ::std::vec::Vec<u64> {
1827 &mut self.learners
1828 }
1829
1830 pub fn take_learners(&mut self) -> ::std::vec::Vec<u64> {
1832 ::std::mem::replace(&mut self.learners, ::std::vec::Vec::new())
1833 }
1834
1835 pub fn get_voters_outgoing(&self) -> &[u64] {
1839 &self.voters_outgoing
1840 }
1841 pub fn clear_voters_outgoing(&mut self) {
1842 self.voters_outgoing.clear();
1843 }
1844
1845 pub fn set_voters_outgoing(&mut self, v: ::std::vec::Vec<u64>) {
1847 self.voters_outgoing = v;
1848 }
1849
1850 pub fn mut_voters_outgoing(&mut self) -> &mut ::std::vec::Vec<u64> {
1852 &mut self.voters_outgoing
1853 }
1854
1855 pub fn take_voters_outgoing(&mut self) -> ::std::vec::Vec<u64> {
1857 ::std::mem::replace(&mut self.voters_outgoing, ::std::vec::Vec::new())
1858 }
1859
1860 pub fn get_learners_next(&self) -> &[u64] {
1864 &self.learners_next
1865 }
1866 pub fn clear_learners_next(&mut self) {
1867 self.learners_next.clear();
1868 }
1869
1870 pub fn set_learners_next(&mut self, v: ::std::vec::Vec<u64>) {
1872 self.learners_next = v;
1873 }
1874
1875 pub fn mut_learners_next(&mut self) -> &mut ::std::vec::Vec<u64> {
1877 &mut self.learners_next
1878 }
1879
1880 pub fn take_learners_next(&mut self) -> ::std::vec::Vec<u64> {
1882 ::std::mem::replace(&mut self.learners_next, ::std::vec::Vec::new())
1883 }
1884
1885 pub fn get_auto_leave(&self) -> bool {
1889 self.auto_leave
1890 }
1891 pub fn clear_auto_leave(&mut self) {
1892 self.auto_leave = false;
1893 }
1894
1895 pub fn set_auto_leave(&mut self, v: bool) {
1897 self.auto_leave = v;
1898 }
1899}
1900
1901impl ::protobuf::Message for ConfState {
1902 fn is_initialized(&self) -> bool {
1903 true
1904 }
1905
1906 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1907 while !is.eof()? {
1908 let (field_number, wire_type) = is.read_tag_unpack()?;
1909 match field_number {
1910 1 => {
1911 ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.voters)?;
1912 },
1913 2 => {
1914 ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.learners)?;
1915 },
1916 3 => {
1917 ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.voters_outgoing)?;
1918 },
1919 4 => {
1920 ::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.learners_next)?;
1921 },
1922 5 => {
1923 if wire_type != ::protobuf::wire_format::WireTypeVarint {
1924 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1925 }
1926 let tmp = is.read_bool()?;
1927 self.auto_leave = tmp;
1928 },
1929 _ => {
1930 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1931 },
1932 };
1933 }
1934 ::std::result::Result::Ok(())
1935 }
1936
1937 #[allow(unused_variables)]
1939 fn compute_size(&self) -> u32 {
1940 let mut my_size = 0;
1941 for value in &self.voters {
1942 my_size += ::protobuf::rt::value_size(1, *value, ::protobuf::wire_format::WireTypeVarint);
1943 };
1944 for value in &self.learners {
1945 my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint);
1946 };
1947 for value in &self.voters_outgoing {
1948 my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint);
1949 };
1950 for value in &self.learners_next {
1951 my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint);
1952 };
1953 if self.auto_leave != false {
1954 my_size += 2;
1955 }
1956 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1957 self.cached_size.set(my_size);
1958 my_size
1959 }
1960
1961 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1962 for v in &self.voters {
1963 os.write_uint64(1, *v)?;
1964 };
1965 for v in &self.learners {
1966 os.write_uint64(2, *v)?;
1967 };
1968 for v in &self.voters_outgoing {
1969 os.write_uint64(3, *v)?;
1970 };
1971 for v in &self.learners_next {
1972 os.write_uint64(4, *v)?;
1973 };
1974 if self.auto_leave != false {
1975 os.write_bool(5, self.auto_leave)?;
1976 }
1977 os.write_unknown_fields(self.get_unknown_fields())?;
1978 ::std::result::Result::Ok(())
1979 }
1980
1981 fn get_cached_size(&self) -> u32 {
1982 self.cached_size.get()
1983 }
1984
1985 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1986 &self.unknown_fields
1987 }
1988
1989 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1990 &mut self.unknown_fields
1991 }
1992
1993 fn as_any(&self) -> &dyn (::std::any::Any) {
1994 self as &dyn (::std::any::Any)
1995 }
1996 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1997 self as &mut dyn (::std::any::Any)
1998 }
1999 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2000 self
2001 }
2002
2003 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2004 Self::descriptor_static()
2005 }
2006
2007 fn new() -> ConfState {
2008 ConfState::new()
2009 }
2010
2011 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2012 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2013 descriptor.get(|| {
2014 let mut fields = ::std::vec::Vec::new();
2015 fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
2016 "voters",
2017 |m: &ConfState| { &m.voters },
2018 |m: &mut ConfState| { &mut m.voters },
2019 ));
2020 fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
2021 "learners",
2022 |m: &ConfState| { &m.learners },
2023 |m: &mut ConfState| { &mut m.learners },
2024 ));
2025 fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
2026 "voters_outgoing",
2027 |m: &ConfState| { &m.voters_outgoing },
2028 |m: &mut ConfState| { &mut m.voters_outgoing },
2029 ));
2030 fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
2031 "learners_next",
2032 |m: &ConfState| { &m.learners_next },
2033 |m: &mut ConfState| { &mut m.learners_next },
2034 ));
2035 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
2036 "auto_leave",
2037 |m: &ConfState| { &m.auto_leave },
2038 |m: &mut ConfState| { &mut m.auto_leave },
2039 ));
2040 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ConfState>(
2041 "ConfState",
2042 fields,
2043 file_descriptor_proto()
2044 )
2045 })
2046 }
2047
2048 fn default_instance() -> &'static ConfState {
2049 static instance: ::protobuf::rt::LazyV2<ConfState> = ::protobuf::rt::LazyV2::INIT;
2050 instance.get(ConfState::new)
2051 }
2052}
2053
2054impl ::protobuf::Clear for ConfState {
2055 fn clear(&mut self) {
2056 self.voters.clear();
2057 self.learners.clear();
2058 self.voters_outgoing.clear();
2059 self.learners_next.clear();
2060 self.auto_leave = false;
2061 self.unknown_fields.clear();
2062 }
2063}
2064
2065impl ::std::fmt::Debug for ConfState {
2066 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2067 ::protobuf::text_format::fmt(self, f)
2068 }
2069}
2070
2071impl ::protobuf::reflect::ProtobufValue for ConfState {
2072 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2073 ::protobuf::reflect::ReflectValueRef::Message(self)
2074 }
2075}
2076
2077#[derive(PartialEq,Clone,Default)]
2078pub struct ConfChange {
2079 pub change_type: ConfChangeType,
2081 pub node_id: u64,
2082 pub context: ::bytes::Bytes,
2083 pub id: u64,
2084 pub unknown_fields: ::protobuf::UnknownFields,
2086 pub cached_size: ::protobuf::CachedSize,
2087}
2088
2089impl<'a> ::std::default::Default for &'a ConfChange {
2090 fn default() -> &'a ConfChange {
2091 <ConfChange as ::protobuf::Message>::default_instance()
2092 }
2093}
2094
2095impl ConfChange {
2096 pub fn new() -> ConfChange {
2097 ::std::default::Default::default()
2098 }
2099
2100 pub fn get_change_type(&self) -> ConfChangeType {
2104 self.change_type
2105 }
2106 pub fn clear_change_type(&mut self) {
2107 self.change_type = ConfChangeType::AddNode;
2108 }
2109
2110 pub fn set_change_type(&mut self, v: ConfChangeType) {
2112 self.change_type = v;
2113 }
2114
2115 pub fn get_node_id(&self) -> u64 {
2119 self.node_id
2120 }
2121 pub fn clear_node_id(&mut self) {
2122 self.node_id = 0;
2123 }
2124
2125 pub fn set_node_id(&mut self, v: u64) {
2127 self.node_id = v;
2128 }
2129
2130 pub fn get_context(&self) -> &[u8] {
2134 &self.context
2135 }
2136 pub fn clear_context(&mut self) {
2137 self.context.clear();
2138 }
2139
2140 pub fn set_context(&mut self, v: ::bytes::Bytes) {
2142 self.context = v;
2143 }
2144
2145 pub fn mut_context(&mut self) -> &mut ::bytes::Bytes {
2148 &mut self.context
2149 }
2150
2151 pub fn take_context(&mut self) -> ::bytes::Bytes {
2153 ::std::mem::replace(&mut self.context, ::bytes::Bytes::new())
2154 }
2155
2156 pub fn get_id(&self) -> u64 {
2160 self.id
2161 }
2162 pub fn clear_id(&mut self) {
2163 self.id = 0;
2164 }
2165
2166 pub fn set_id(&mut self, v: u64) {
2168 self.id = v;
2169 }
2170}
2171
2172impl ::protobuf::Message for ConfChange {
2173 fn is_initialized(&self) -> bool {
2174 true
2175 }
2176
2177 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2178 while !is.eof()? {
2179 let (field_number, wire_type) = is.read_tag_unpack()?;
2180 match field_number {
2181 2 => {
2182 if wire_type == ::protobuf::wire_format::WireTypeVarint {self.change_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
2183 },
2184 3 => {
2185 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2186 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2187 }
2188 let tmp = is.read_uint64()?;
2189 self.node_id = tmp;
2190 },
2191 4 => {
2192 ::protobuf::rt::read_singular_proto3_carllerche_bytes_into(wire_type, is, &mut self.context)?;
2193 },
2194 1 => {
2195 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2196 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2197 }
2198 let tmp = is.read_uint64()?;
2199 self.id = tmp;
2200 },
2201 _ => {
2202 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2203 },
2204 };
2205 }
2206 ::std::result::Result::Ok(())
2207 }
2208
2209 #[allow(unused_variables)]
2211 fn compute_size(&self) -> u32 {
2212 let mut my_size = 0;
2213 if self.change_type != ConfChangeType::AddNode {
2214 my_size += ::protobuf::rt::enum_size(2, self.change_type);
2215 }
2216 if self.node_id != 0 {
2217 my_size += ::protobuf::rt::value_size(3, self.node_id, ::protobuf::wire_format::WireTypeVarint);
2218 }
2219 if !self.context.is_empty() {
2220 my_size += ::protobuf::rt::bytes_size(4, &self.context);
2221 }
2222 if self.id != 0 {
2223 my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
2224 }
2225 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2226 self.cached_size.set(my_size);
2227 my_size
2228 }
2229
2230 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2231 if self.change_type != ConfChangeType::AddNode {
2232 os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.change_type))?;
2233 }
2234 if self.node_id != 0 {
2235 os.write_uint64(3, self.node_id)?;
2236 }
2237 if !self.context.is_empty() {
2238 os.write_bytes(4, &self.context)?;
2239 }
2240 if self.id != 0 {
2241 os.write_uint64(1, self.id)?;
2242 }
2243 os.write_unknown_fields(self.get_unknown_fields())?;
2244 ::std::result::Result::Ok(())
2245 }
2246
2247 fn get_cached_size(&self) -> u32 {
2248 self.cached_size.get()
2249 }
2250
2251 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2252 &self.unknown_fields
2253 }
2254
2255 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2256 &mut self.unknown_fields
2257 }
2258
2259 fn as_any(&self) -> &dyn (::std::any::Any) {
2260 self as &dyn (::std::any::Any)
2261 }
2262 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2263 self as &mut dyn (::std::any::Any)
2264 }
2265 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2266 self
2267 }
2268
2269 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2270 Self::descriptor_static()
2271 }
2272
2273 fn new() -> ConfChange {
2274 ConfChange::new()
2275 }
2276
2277 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2278 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2279 descriptor.get(|| {
2280 let mut fields = ::std::vec::Vec::new();
2281 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ConfChangeType>>(
2282 "change_type",
2283 |m: &ConfChange| { &m.change_type },
2284 |m: &mut ConfChange| { &mut m.change_type },
2285 ));
2286 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
2287 "node_id",
2288 |m: &ConfChange| { &m.node_id },
2289 |m: &mut ConfChange| { &mut m.node_id },
2290 ));
2291 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeCarllercheBytes>(
2292 "context",
2293 |m: &ConfChange| { &m.context },
2294 |m: &mut ConfChange| { &mut m.context },
2295 ));
2296 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
2297 "id",
2298 |m: &ConfChange| { &m.id },
2299 |m: &mut ConfChange| { &mut m.id },
2300 ));
2301 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ConfChange>(
2302 "ConfChange",
2303 fields,
2304 file_descriptor_proto()
2305 )
2306 })
2307 }
2308
2309 fn default_instance() -> &'static ConfChange {
2310 static instance: ::protobuf::rt::LazyV2<ConfChange> = ::protobuf::rt::LazyV2::INIT;
2311 instance.get(ConfChange::new)
2312 }
2313}
2314
2315impl ::protobuf::Clear for ConfChange {
2316 fn clear(&mut self) {
2317 self.change_type = ConfChangeType::AddNode;
2318 self.node_id = 0;
2319 self.context.clear();
2320 self.id = 0;
2321 self.unknown_fields.clear();
2322 }
2323}
2324
2325impl ::std::fmt::Debug for ConfChange {
2326 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2327 ::protobuf::text_format::fmt(self, f)
2328 }
2329}
2330
2331impl ::protobuf::reflect::ProtobufValue for ConfChange {
2332 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2333 ::protobuf::reflect::ReflectValueRef::Message(self)
2334 }
2335}
2336
2337#[derive(PartialEq,Clone,Default)]
2338pub struct ConfChangeSingle {
2339 pub change_type: ConfChangeType,
2341 pub node_id: u64,
2342 pub unknown_fields: ::protobuf::UnknownFields,
2344 pub cached_size: ::protobuf::CachedSize,
2345}
2346
2347impl<'a> ::std::default::Default for &'a ConfChangeSingle {
2348 fn default() -> &'a ConfChangeSingle {
2349 <ConfChangeSingle as ::protobuf::Message>::default_instance()
2350 }
2351}
2352
2353impl ConfChangeSingle {
2354 pub fn new() -> ConfChangeSingle {
2355 ::std::default::Default::default()
2356 }
2357
2358 pub fn get_change_type(&self) -> ConfChangeType {
2362 self.change_type
2363 }
2364 pub fn clear_change_type(&mut self) {
2365 self.change_type = ConfChangeType::AddNode;
2366 }
2367
2368 pub fn set_change_type(&mut self, v: ConfChangeType) {
2370 self.change_type = v;
2371 }
2372
2373 pub fn get_node_id(&self) -> u64 {
2377 self.node_id
2378 }
2379 pub fn clear_node_id(&mut self) {
2380 self.node_id = 0;
2381 }
2382
2383 pub fn set_node_id(&mut self, v: u64) {
2385 self.node_id = v;
2386 }
2387}
2388
2389impl ::protobuf::Message for ConfChangeSingle {
2390 fn is_initialized(&self) -> bool {
2391 true
2392 }
2393
2394 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2395 while !is.eof()? {
2396 let (field_number, wire_type) = is.read_tag_unpack()?;
2397 match field_number {
2398 1 => {
2399 if wire_type == ::protobuf::wire_format::WireTypeVarint {self.change_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
2400 },
2401 2 => {
2402 if wire_type != ::protobuf::wire_format::WireTypeVarint {
2403 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
2404 }
2405 let tmp = is.read_uint64()?;
2406 self.node_id = tmp;
2407 },
2408 _ => {
2409 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2410 },
2411 };
2412 }
2413 ::std::result::Result::Ok(())
2414 }
2415
2416 #[allow(unused_variables)]
2418 fn compute_size(&self) -> u32 {
2419 let mut my_size = 0;
2420 if self.change_type != ConfChangeType::AddNode {
2421 my_size += ::protobuf::rt::enum_size(1, self.change_type);
2422 }
2423 if self.node_id != 0 {
2424 my_size += ::protobuf::rt::value_size(2, self.node_id, ::protobuf::wire_format::WireTypeVarint);
2425 }
2426 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2427 self.cached_size.set(my_size);
2428 my_size
2429 }
2430
2431 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2432 if self.change_type != ConfChangeType::AddNode {
2433 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.change_type))?;
2434 }
2435 if self.node_id != 0 {
2436 os.write_uint64(2, self.node_id)?;
2437 }
2438 os.write_unknown_fields(self.get_unknown_fields())?;
2439 ::std::result::Result::Ok(())
2440 }
2441
2442 fn get_cached_size(&self) -> u32 {
2443 self.cached_size.get()
2444 }
2445
2446 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2447 &self.unknown_fields
2448 }
2449
2450 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2451 &mut self.unknown_fields
2452 }
2453
2454 fn as_any(&self) -> &dyn (::std::any::Any) {
2455 self as &dyn (::std::any::Any)
2456 }
2457 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2458 self as &mut dyn (::std::any::Any)
2459 }
2460 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2461 self
2462 }
2463
2464 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2465 Self::descriptor_static()
2466 }
2467
2468 fn new() -> ConfChangeSingle {
2469 ConfChangeSingle::new()
2470 }
2471
2472 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2473 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2474 descriptor.get(|| {
2475 let mut fields = ::std::vec::Vec::new();
2476 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ConfChangeType>>(
2477 "change_type",
2478 |m: &ConfChangeSingle| { &m.change_type },
2479 |m: &mut ConfChangeSingle| { &mut m.change_type },
2480 ));
2481 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
2482 "node_id",
2483 |m: &ConfChangeSingle| { &m.node_id },
2484 |m: &mut ConfChangeSingle| { &mut m.node_id },
2485 ));
2486 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ConfChangeSingle>(
2487 "ConfChangeSingle",
2488 fields,
2489 file_descriptor_proto()
2490 )
2491 })
2492 }
2493
2494 fn default_instance() -> &'static ConfChangeSingle {
2495 static instance: ::protobuf::rt::LazyV2<ConfChangeSingle> = ::protobuf::rt::LazyV2::INIT;
2496 instance.get(ConfChangeSingle::new)
2497 }
2498}
2499
2500impl ::protobuf::Clear for ConfChangeSingle {
2501 fn clear(&mut self) {
2502 self.change_type = ConfChangeType::AddNode;
2503 self.node_id = 0;
2504 self.unknown_fields.clear();
2505 }
2506}
2507
2508impl ::std::fmt::Debug for ConfChangeSingle {
2509 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2510 ::protobuf::text_format::fmt(self, f)
2511 }
2512}
2513
2514impl ::protobuf::reflect::ProtobufValue for ConfChangeSingle {
2515 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2516 ::protobuf::reflect::ReflectValueRef::Message(self)
2517 }
2518}
2519
2520#[derive(PartialEq,Clone,Default)]
2521pub struct ConfChangeV2 {
2522 pub transition: ConfChangeTransition,
2524 pub changes: ::protobuf::RepeatedField<ConfChangeSingle>,
2525 pub context: ::bytes::Bytes,
2526 pub unknown_fields: ::protobuf::UnknownFields,
2528 pub cached_size: ::protobuf::CachedSize,
2529}
2530
2531impl<'a> ::std::default::Default for &'a ConfChangeV2 {
2532 fn default() -> &'a ConfChangeV2 {
2533 <ConfChangeV2 as ::protobuf::Message>::default_instance()
2534 }
2535}
2536
2537impl ConfChangeV2 {
2538 pub fn new() -> ConfChangeV2 {
2539 ::std::default::Default::default()
2540 }
2541
2542 pub fn get_transition(&self) -> ConfChangeTransition {
2546 self.transition
2547 }
2548 pub fn clear_transition(&mut self) {
2549 self.transition = ConfChangeTransition::Auto;
2550 }
2551
2552 pub fn set_transition(&mut self, v: ConfChangeTransition) {
2554 self.transition = v;
2555 }
2556
2557 pub fn get_changes(&self) -> &[ConfChangeSingle] {
2561 &self.changes
2562 }
2563 pub fn clear_changes(&mut self) {
2564 self.changes.clear();
2565 }
2566
2567 pub fn set_changes(&mut self, v: ::protobuf::RepeatedField<ConfChangeSingle>) {
2569 self.changes = v;
2570 }
2571
2572 pub fn mut_changes(&mut self) -> &mut ::protobuf::RepeatedField<ConfChangeSingle> {
2574 &mut self.changes
2575 }
2576
2577 pub fn take_changes(&mut self) -> ::protobuf::RepeatedField<ConfChangeSingle> {
2579 ::std::mem::replace(&mut self.changes, ::protobuf::RepeatedField::new())
2580 }
2581
2582 pub fn get_context(&self) -> &[u8] {
2586 &self.context
2587 }
2588 pub fn clear_context(&mut self) {
2589 self.context.clear();
2590 }
2591
2592 pub fn set_context(&mut self, v: ::bytes::Bytes) {
2594 self.context = v;
2595 }
2596
2597 pub fn mut_context(&mut self) -> &mut ::bytes::Bytes {
2600 &mut self.context
2601 }
2602
2603 pub fn take_context(&mut self) -> ::bytes::Bytes {
2605 ::std::mem::replace(&mut self.context, ::bytes::Bytes::new())
2606 }
2607}
2608
2609impl ::protobuf::Message for ConfChangeV2 {
2610 fn is_initialized(&self) -> bool {
2611 for v in &self.changes {
2612 if !v.is_initialized() {
2613 return false;
2614 }
2615 };
2616 true
2617 }
2618
2619 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2620 while !is.eof()? {
2621 let (field_number, wire_type) = is.read_tag_unpack()?;
2622 match field_number {
2623 1 => {
2624 if wire_type == ::protobuf::wire_format::WireTypeVarint {self.transition = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
2625 },
2626 2 => {
2627 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.changes)?;
2628 },
2629 3 => {
2630 ::protobuf::rt::read_singular_proto3_carllerche_bytes_into(wire_type, is, &mut self.context)?;
2631 },
2632 _ => {
2633 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2634 },
2635 };
2636 }
2637 ::std::result::Result::Ok(())
2638 }
2639
2640 #[allow(unused_variables)]
2642 fn compute_size(&self) -> u32 {
2643 let mut my_size = 0;
2644 if self.transition != ConfChangeTransition::Auto {
2645 my_size += ::protobuf::rt::enum_size(1, self.transition);
2646 }
2647 for value in &self.changes {
2648 let len = value.compute_size();
2649 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2650 };
2651 if !self.context.is_empty() {
2652 my_size += ::protobuf::rt::bytes_size(3, &self.context);
2653 }
2654 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2655 self.cached_size.set(my_size);
2656 my_size
2657 }
2658
2659 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2660 if self.transition != ConfChangeTransition::Auto {
2661 os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.transition))?;
2662 }
2663 for v in &self.changes {
2664 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2665 os.write_raw_varint32(v.get_cached_size())?;
2666 v.write_to_with_cached_sizes(os)?;
2667 };
2668 if !self.context.is_empty() {
2669 os.write_bytes(3, &self.context)?;
2670 }
2671 os.write_unknown_fields(self.get_unknown_fields())?;
2672 ::std::result::Result::Ok(())
2673 }
2674
2675 fn get_cached_size(&self) -> u32 {
2676 self.cached_size.get()
2677 }
2678
2679 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2680 &self.unknown_fields
2681 }
2682
2683 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2684 &mut self.unknown_fields
2685 }
2686
2687 fn as_any(&self) -> &dyn (::std::any::Any) {
2688 self as &dyn (::std::any::Any)
2689 }
2690 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2691 self as &mut dyn (::std::any::Any)
2692 }
2693 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2694 self
2695 }
2696
2697 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2698 Self::descriptor_static()
2699 }
2700
2701 fn new() -> ConfChangeV2 {
2702 ConfChangeV2::new()
2703 }
2704
2705 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2706 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2707 descriptor.get(|| {
2708 let mut fields = ::std::vec::Vec::new();
2709 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ConfChangeTransition>>(
2710 "transition",
2711 |m: &ConfChangeV2| { &m.transition },
2712 |m: &mut ConfChangeV2| { &mut m.transition },
2713 ));
2714 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ConfChangeSingle>>(
2715 "changes",
2716 |m: &ConfChangeV2| { &m.changes },
2717 |m: &mut ConfChangeV2| { &mut m.changes },
2718 ));
2719 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeCarllercheBytes>(
2720 "context",
2721 |m: &ConfChangeV2| { &m.context },
2722 |m: &mut ConfChangeV2| { &mut m.context },
2723 ));
2724 ::protobuf::reflect::MessageDescriptor::new_pb_name::<ConfChangeV2>(
2725 "ConfChangeV2",
2726 fields,
2727 file_descriptor_proto()
2728 )
2729 })
2730 }
2731
2732 fn default_instance() -> &'static ConfChangeV2 {
2733 static instance: ::protobuf::rt::LazyV2<ConfChangeV2> = ::protobuf::rt::LazyV2::INIT;
2734 instance.get(ConfChangeV2::new)
2735 }
2736}
2737
2738impl ::protobuf::Clear for ConfChangeV2 {
2739 fn clear(&mut self) {
2740 self.transition = ConfChangeTransition::Auto;
2741 self.changes.clear();
2742 self.context.clear();
2743 self.unknown_fields.clear();
2744 }
2745}
2746
2747impl ::std::fmt::Debug for ConfChangeV2 {
2748 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2749 ::protobuf::text_format::fmt(self, f)
2750 }
2751}
2752
2753impl ::protobuf::reflect::ProtobufValue for ConfChangeV2 {
2754 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2755 ::protobuf::reflect::ReflectValueRef::Message(self)
2756 }
2757}
2758
2759#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2760pub enum EntryType {
2761 EntryNormal = 0,
2762 EntryConfChange = 1,
2763 EntryConfChangeV2 = 2,
2764}
2765
2766impl ::protobuf::ProtobufEnum for EntryType {
2767 fn value(&self) -> i32 {
2768 *self as i32
2769 }
2770
2771 fn from_i32(value: i32) -> ::std::option::Option<EntryType> {
2772 match value {
2773 0 => ::std::option::Option::Some(EntryType::EntryNormal),
2774 1 => ::std::option::Option::Some(EntryType::EntryConfChange),
2775 2 => ::std::option::Option::Some(EntryType::EntryConfChangeV2),
2776 _ => ::std::option::Option::None
2777 }
2778 }
2779
2780 fn values() -> &'static [Self] {
2781 static values: &'static [EntryType] = &[
2782 EntryType::EntryNormal,
2783 EntryType::EntryConfChange,
2784 EntryType::EntryConfChangeV2,
2785 ];
2786 values
2787 }
2788
2789 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2790 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2791 descriptor.get(|| {
2792 ::protobuf::reflect::EnumDescriptor::new_pb_name::<EntryType>("EntryType", file_descriptor_proto())
2793 })
2794 }
2795}
2796
2797impl ::std::marker::Copy for EntryType {
2798}
2799
2800impl ::std::default::Default for EntryType {
2801 fn default() -> Self {
2802 EntryType::EntryNormal
2803 }
2804}
2805
2806impl ::protobuf::reflect::ProtobufValue for EntryType {
2807 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2808 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
2809 }
2810}
2811
2812#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2813pub enum MessageType {
2814 MsgHup = 0,
2815 MsgBeat = 1,
2816 MsgPropose = 2,
2817 MsgAppend = 3,
2818 MsgAppendResponse = 4,
2819 MsgRequestVote = 5,
2820 MsgRequestVoteResponse = 6,
2821 MsgSnapshot = 7,
2822 MsgHeartbeat = 8,
2823 MsgHeartbeatResponse = 9,
2824 MsgUnreachable = 10,
2825 MsgSnapStatus = 11,
2826 MsgCheckQuorum = 12,
2827 MsgTransferLeader = 13,
2828 MsgTimeoutNow = 14,
2829 MsgReadIndex = 15,
2830 MsgReadIndexResp = 16,
2831 MsgRequestPreVote = 17,
2832 MsgRequestPreVoteResponse = 18,
2833}
2834
2835impl ::protobuf::ProtobufEnum for MessageType {
2836 fn value(&self) -> i32 {
2837 *self as i32
2838 }
2839
2840 fn from_i32(value: i32) -> ::std::option::Option<MessageType> {
2841 match value {
2842 0 => ::std::option::Option::Some(MessageType::MsgHup),
2843 1 => ::std::option::Option::Some(MessageType::MsgBeat),
2844 2 => ::std::option::Option::Some(MessageType::MsgPropose),
2845 3 => ::std::option::Option::Some(MessageType::MsgAppend),
2846 4 => ::std::option::Option::Some(MessageType::MsgAppendResponse),
2847 5 => ::std::option::Option::Some(MessageType::MsgRequestVote),
2848 6 => ::std::option::Option::Some(MessageType::MsgRequestVoteResponse),
2849 7 => ::std::option::Option::Some(MessageType::MsgSnapshot),
2850 8 => ::std::option::Option::Some(MessageType::MsgHeartbeat),
2851 9 => ::std::option::Option::Some(MessageType::MsgHeartbeatResponse),
2852 10 => ::std::option::Option::Some(MessageType::MsgUnreachable),
2853 11 => ::std::option::Option::Some(MessageType::MsgSnapStatus),
2854 12 => ::std::option::Option::Some(MessageType::MsgCheckQuorum),
2855 13 => ::std::option::Option::Some(MessageType::MsgTransferLeader),
2856 14 => ::std::option::Option::Some(MessageType::MsgTimeoutNow),
2857 15 => ::std::option::Option::Some(MessageType::MsgReadIndex),
2858 16 => ::std::option::Option::Some(MessageType::MsgReadIndexResp),
2859 17 => ::std::option::Option::Some(MessageType::MsgRequestPreVote),
2860 18 => ::std::option::Option::Some(MessageType::MsgRequestPreVoteResponse),
2861 _ => ::std::option::Option::None
2862 }
2863 }
2864
2865 fn values() -> &'static [Self] {
2866 static values: &'static [MessageType] = &[
2867 MessageType::MsgHup,
2868 MessageType::MsgBeat,
2869 MessageType::MsgPropose,
2870 MessageType::MsgAppend,
2871 MessageType::MsgAppendResponse,
2872 MessageType::MsgRequestVote,
2873 MessageType::MsgRequestVoteResponse,
2874 MessageType::MsgSnapshot,
2875 MessageType::MsgHeartbeat,
2876 MessageType::MsgHeartbeatResponse,
2877 MessageType::MsgUnreachable,
2878 MessageType::MsgSnapStatus,
2879 MessageType::MsgCheckQuorum,
2880 MessageType::MsgTransferLeader,
2881 MessageType::MsgTimeoutNow,
2882 MessageType::MsgReadIndex,
2883 MessageType::MsgReadIndexResp,
2884 MessageType::MsgRequestPreVote,
2885 MessageType::MsgRequestPreVoteResponse,
2886 ];
2887 values
2888 }
2889
2890 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2891 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2892 descriptor.get(|| {
2893 ::protobuf::reflect::EnumDescriptor::new_pb_name::<MessageType>("MessageType", file_descriptor_proto())
2894 })
2895 }
2896}
2897
2898impl ::std::marker::Copy for MessageType {
2899}
2900
2901impl ::std::default::Default for MessageType {
2902 fn default() -> Self {
2903 MessageType::MsgHup
2904 }
2905}
2906
2907impl ::protobuf::reflect::ProtobufValue for MessageType {
2908 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2909 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
2910 }
2911}
2912
2913#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2914pub enum ConfChangeTransition {
2915 Auto = 0,
2916 Implicit = 1,
2917 Explicit = 2,
2918}
2919
2920impl ::protobuf::ProtobufEnum for ConfChangeTransition {
2921 fn value(&self) -> i32 {
2922 *self as i32
2923 }
2924
2925 fn from_i32(value: i32) -> ::std::option::Option<ConfChangeTransition> {
2926 match value {
2927 0 => ::std::option::Option::Some(ConfChangeTransition::Auto),
2928 1 => ::std::option::Option::Some(ConfChangeTransition::Implicit),
2929 2 => ::std::option::Option::Some(ConfChangeTransition::Explicit),
2930 _ => ::std::option::Option::None
2931 }
2932 }
2933
2934 fn values() -> &'static [Self] {
2935 static values: &'static [ConfChangeTransition] = &[
2936 ConfChangeTransition::Auto,
2937 ConfChangeTransition::Implicit,
2938 ConfChangeTransition::Explicit,
2939 ];
2940 values
2941 }
2942
2943 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2944 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2945 descriptor.get(|| {
2946 ::protobuf::reflect::EnumDescriptor::new_pb_name::<ConfChangeTransition>("ConfChangeTransition", file_descriptor_proto())
2947 })
2948 }
2949}
2950
2951impl ::std::marker::Copy for ConfChangeTransition {
2952}
2953
2954impl ::std::default::Default for ConfChangeTransition {
2955 fn default() -> Self {
2956 ConfChangeTransition::Auto
2957 }
2958}
2959
2960impl ::protobuf::reflect::ProtobufValue for ConfChangeTransition {
2961 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2962 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
2963 }
2964}
2965
2966#[derive(Clone,PartialEq,Eq,Debug,Hash)]
2967pub enum ConfChangeType {
2968 AddNode = 0,
2969 RemoveNode = 1,
2970 AddLearnerNode = 2,
2971}
2972
2973impl ::protobuf::ProtobufEnum for ConfChangeType {
2974 fn value(&self) -> i32 {
2975 *self as i32
2976 }
2977
2978 fn from_i32(value: i32) -> ::std::option::Option<ConfChangeType> {
2979 match value {
2980 0 => ::std::option::Option::Some(ConfChangeType::AddNode),
2981 1 => ::std::option::Option::Some(ConfChangeType::RemoveNode),
2982 2 => ::std::option::Option::Some(ConfChangeType::AddLearnerNode),
2983 _ => ::std::option::Option::None
2984 }
2985 }
2986
2987 fn values() -> &'static [Self] {
2988 static values: &'static [ConfChangeType] = &[
2989 ConfChangeType::AddNode,
2990 ConfChangeType::RemoveNode,
2991 ConfChangeType::AddLearnerNode,
2992 ];
2993 values
2994 }
2995
2996 fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
2997 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
2998 descriptor.get(|| {
2999 ::protobuf::reflect::EnumDescriptor::new_pb_name::<ConfChangeType>("ConfChangeType", file_descriptor_proto())
3000 })
3001 }
3002}
3003
3004impl ::std::marker::Copy for ConfChangeType {
3005}
3006
3007impl ::std::default::Default for ConfChangeType {
3008 fn default() -> Self {
3009 ConfChangeType::AddNode
3010 }
3011}
3012
3013impl ::protobuf::reflect::ProtobufValue for ConfChangeType {
3014 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
3015 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
3016 }
3017}
3018
3019static file_descriptor_proto_data: &'static [u8] = b"\
3020 \n\nraft.proto\x12\x07raft.v1\x1a\x0frustproto.proto\"\xad\x01\n\x05Entr\
3021 y\x121\n\nentry_type\x18\x01\x20\x01(\x0e2\x12.raft.v1.EntryTypeR\tentry\
3022 Type\x12\x12\n\x04term\x18\x02\x20\x01(\x04R\x04term\x12\x14\n\x05index\
3023 \x18\x03\x20\x01(\x04R\x05index\x12\x12\n\x04data\x18\x04\x20\x01(\x0cR\
3024 \x04data\x12\x18\n\x07context\x18\x06\x20\x01(\x0cR\x07context\x12\x19\n\
3025 \x08sync_log\x18\x05\x20\x01(\x08R\x07syncLog\"o\n\x10SnapshotMetadata\
3026 \x121\n\nconf_state\x18\x01\x20\x01(\x0b2\x12.raft.v1.ConfStateR\tconfSt\
3027 ate\x12\x14\n\x05index\x18\x02\x20\x01(\x04R\x05index\x12\x12\n\x04term\
3028 \x18\x03\x20\x01(\x04R\x04term\"U\n\x08Snapshot\x12\x12\n\x04data\x18\
3029 \x01\x20\x01(\x0cR\x04data\x125\n\x08metadata\x18\x02\x20\x01(\x0b2\x19.\
3030 raft.v1.SnapshotMetadataR\x08metadata\"\x80\x04\n\x07Message\x12/\n\x08m\
3031 sg_type\x18\x01\x20\x01(\x0e2\x14.raft.v1.MessageTypeR\x07msgType\x12\
3032 \x0e\n\x02to\x18\x02\x20\x01(\x04R\x02to\x12\x12\n\x04from\x18\x03\x20\
3033 \x01(\x04R\x04from\x12\x12\n\x04term\x18\x04\x20\x01(\x04R\x04term\x12\
3034 \x19\n\x08log_term\x18\x05\x20\x01(\x04R\x07logTerm\x12\x14\n\x05index\
3035 \x18\x06\x20\x01(\x04R\x05index\x12(\n\x07entries\x18\x07\x20\x03(\x0b2\
3036 \x0e.raft.v1.EntryR\x07entries\x12\x16\n\x06commit\x18\x08\x20\x01(\x04R\
3037 \x06commit\x12\x1f\n\x0bcommit_term\x18\x0f\x20\x01(\x04R\ncommitTerm\
3038 \x12-\n\x08snapshot\x18\t\x20\x01(\x0b2\x11.raft.v1.SnapshotR\x08snapsho\
3039 t\x12)\n\x10request_snapshot\x18\r\x20\x01(\x04R\x0frequestSnapshot\x12\
3040 \x16\n\x06reject\x18\n\x20\x01(\x08R\x06reject\x12\x1f\n\x0breject_hint\
3041 \x18\x0b\x20\x01(\x04R\nrejectHint\x12\x18\n\x07context\x18\x0c\x20\x01(\
3042 \x0cR\x07context\x12/\n\x13deprecated_priority\x18\x0e\x20\x01(\x04R\x12\
3043 deprecatedPriority\x12\x1a\n\x08priority\x18\x10\x20\x01(\x03R\x08priori\
3044 ty\"K\n\tHardState\x12\x12\n\x04term\x18\x01\x20\x01(\x04R\x04term\x12\
3045 \x12\n\x04vote\x18\x02\x20\x01(\x04R\x04vote\x12\x16\n\x06commit\x18\x03\
3046 \x20\x01(\x04R\x06commit\"\xac\x01\n\tConfState\x12\x16\n\x06voters\x18\
3047 \x01\x20\x03(\x04R\x06voters\x12\x1a\n\x08learners\x18\x02\x20\x03(\x04R\
3048 \x08learners\x12'\n\x0fvoters_outgoing\x18\x03\x20\x03(\x04R\x0evotersOu\
3049 tgoing\x12#\n\rlearners_next\x18\x04\x20\x03(\x04R\x0clearnersNext\x12\
3050 \x1d\n\nauto_leave\x18\x05\x20\x01(\x08R\tautoLeave\"\x89\x01\n\nConfCha\
3051 nge\x128\n\x0bchange_type\x18\x02\x20\x01(\x0e2\x17.raft.v1.ConfChangeTy\
3052 peR\nchangeType\x12\x17\n\x07node_id\x18\x03\x20\x01(\x04R\x06nodeId\x12\
3053 \x18\n\x07context\x18\x04\x20\x01(\x0cR\x07context\x12\x0e\n\x02id\x18\
3054 \x01\x20\x01(\x04R\x02id\"e\n\x10ConfChangeSingle\x128\n\x0bchange_type\
3055 \x18\x01\x20\x01(\x0e2\x17.raft.v1.ConfChangeTypeR\nchangeType\x12\x17\n\
3056 \x07node_id\x18\x02\x20\x01(\x04R\x06nodeId\"\x9c\x01\n\x0cConfChangeV2\
3057 \x12=\n\ntransition\x18\x01\x20\x01(\x0e2\x1d.raft.v1.ConfChangeTransiti\
3058 onR\ntransition\x123\n\x07changes\x18\x02\x20\x03(\x0b2\x19.raft.v1.Conf\
3059 ChangeSingleR\x07changes\x12\x18\n\x07context\x18\x03\x20\x01(\x0cR\x07c\
3060 ontext*H\n\tEntryType\x12\x0f\n\x0bEntryNormal\x10\0\x12\x13\n\x0fEntryC\
3061 onfChange\x10\x01\x12\x15\n\x11EntryConfChangeV2\x10\x02*\x8c\x03\n\x0bM\
3062 essageType\x12\n\n\x06MsgHup\x10\0\x12\x0b\n\x07MsgBeat\x10\x01\x12\x0e\
3063 \n\nMsgPropose\x10\x02\x12\r\n\tMsgAppend\x10\x03\x12\x15\n\x11MsgAppend\
3064 Response\x10\x04\x12\x12\n\x0eMsgRequestVote\x10\x05\x12\x1a\n\x16MsgReq\
3065 uestVoteResponse\x10\x06\x12\x0f\n\x0bMsgSnapshot\x10\x07\x12\x10\n\x0cM\
3066 sgHeartbeat\x10\x08\x12\x18\n\x14MsgHeartbeatResponse\x10\t\x12\x12\n\
3067 \x0eMsgUnreachable\x10\n\x12\x11\n\rMsgSnapStatus\x10\x0b\x12\x12\n\x0eM\
3068 sgCheckQuorum\x10\x0c\x12\x15\n\x11MsgTransferLeader\x10\r\x12\x11\n\rMs\
3069 gTimeoutNow\x10\x0e\x12\x10\n\x0cMsgReadIndex\x10\x0f\x12\x14\n\x10MsgRe\
3070 adIndexResp\x10\x10\x12\x15\n\x11MsgRequestPreVote\x10\x11\x12\x1d\n\x19\
3071 MsgRequestPreVoteResponse\x10\x12*<\n\x14ConfChangeTransition\x12\x08\n\
3072 \x04Auto\x10\0\x12\x0c\n\x08Implicit\x10\x01\x12\x0c\n\x08Explicit\x10\
3073 \x02*A\n\x0eConfChangeType\x12\x0b\n\x07AddNode\x10\0\x12\x0e\n\nRemoveN\
3074 ode\x10\x01\x12\x12\n\x0eAddLearnerNode\x10\x02B\rZ\x07raft.v1\x98\xa7\
3075 \x08\x01J\x9dI\n\x07\x12\x05\x10\0\xd5\x01\x01\n\x85\x05\n\x01\x0c\x12\
3076 \x03\x10\0\x122A\x20Copyright\x202019\x20TiKV\x20Project\x20Authors.\x20\
3077 Licensed\x20under\x20Apache-2.0.\n2\xb7\x04\x20Copyright\x202015\x20The\
3078 \x20etcd\x20Authors\n\n\x20Licensed\x20under\x20the\x20Apache\x20License\
3079 ,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20u\
3080 se\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\x20Licen\
3081 se.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\
3082 \n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\
3083 \x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\
3084 \x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\x20Licen\
3085 se\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHO\
3086 UT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20\
3087 express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20sp\
3088 ecific\x20language\x20governing\x20permissions\x20and\n\x20limitations\
3089 \x20under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x11\0\x10\n\x08\n\
3090 \x01\x08\x12\x03\x13\0\x1e\n\t\n\x02\x08\x0b\x12\x03\x13\0\x1e\n\t\n\x02\
3091 \x03\0\x12\x03\x15\0\x19\n\x08\n\x01\x08\x12\x03\x16\09\n\x0b\n\x04\x08\
3092 \xf3\x84\x01\x12\x03\x16\09\n\n\n\x02\x05\0\x12\x04\x18\0\x1c\x01\n\n\n\
3093 \x03\x05\0\x01\x12\x03\x18\x05\x0e\n\x0b\n\x04\x05\0\x02\0\x12\x03\x19\
3094 \x04\x14\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x19\x04\x0f\n\x0c\n\x05\x05\
3095 \0\x02\0\x02\x12\x03\x19\x12\x13\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x1a\
3096 \x04\x18\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x1a\x04\x13\n\x0c\n\x05\
3097 \x05\0\x02\x01\x02\x12\x03\x1a\x16\x17\n\x0b\n\x04\x05\0\x02\x02\x12\x03\
3098 \x1b\x04\x1a\n\x0c\n\x05\x05\0\x02\x02\x01\x12\x03\x1b\x04\x15\n\x0c\n\
3099 \x05\x05\0\x02\x02\x02\x12\x03\x1b\x18\x19\n\xdd\x04\n\x02\x04\0\x12\x04\
3100 (\02\x01\x1a\xd0\x04\x20The\x20entry\x20is\x20a\x20type\x20of\x20change\
3101 \x20that\x20needs\x20to\x20be\x20applied.\x20It\x20contains\x20two\x20da\
3102 ta\x20fields.\n\x20While\x20the\x20fields\x20are\x20built\x20into\x20the\
3103 \x20model;\x20their\x20usage\x20is\x20determined\x20by\x20the\x20entry_t\
3104 ype.\n\n\x20For\x20normal\x20entries,\x20the\x20data\x20field\x20should\
3105 \x20contain\x20the\x20data\x20change\x20that\x20should\x20be\x20applied.\
3106 \n\x20The\x20context\x20field\x20can\x20be\x20used\x20for\x20any\x20cont\
3107 extual\x20data\x20that\x20might\x20be\x20relevant\x20to\x20the\n\x20appl\
3108 ication\x20of\x20the\x20data.\n\n\x20For\x20configuration\x20changes,\
3109 \x20the\x20data\x20will\x20contain\x20the\x20ConfChange\x20message\x20an\
3110 d\x20the\n\x20context\x20will\x20provide\x20anything\x20needed\x20to\x20\
3111 assist\x20the\x20configuration\x20change.\x20The\x20context\n\x20if\x20f\
3112 or\x20the\x20user\x20to\x20set\x20and\x20use\x20in\x20this\x20case.\n\n\
3113 \n\n\x03\x04\0\x01\x12\x03(\x08\r\n\x0b\n\x04\x04\0\x02\0\x12\x03)\x04\
3114 \x1d\n\x0c\n\x05\x04\0\x02\0\x06\x12\x03)\x04\r\n\x0c\n\x05\x04\0\x02\0\
3115 \x01\x12\x03)\x0e\x18\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03)\x1b\x1c\n\x0b\
3116 \n\x04\x04\0\x02\x01\x12\x03*\x04\x14\n\x0c\n\x05\x04\0\x02\x01\x05\x12\
3117 \x03*\x04\n\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03*\x0b\x0f\n\x0c\n\x05\
3118 \x04\0\x02\x01\x03\x12\x03*\x12\x13\n\x0b\n\x04\x04\0\x02\x02\x12\x03+\
3119 \x04\x15\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03+\x04\n\n\x0c\n\x05\x04\0\
3120 \x02\x02\x01\x12\x03+\x0b\x10\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03+\x13\
3121 \x14\n\x0b\n\x04\x04\0\x02\x03\x12\x03,\x04\x13\n\x0c\n\x05\x04\0\x02\
3122 \x03\x05\x12\x03,\x04\t\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03,\n\x0e\n\
3123 \x0c\n\x05\x04\0\x02\x03\x03\x12\x03,\x11\x12\n\x0b\n\x04\x04\0\x02\x04\
3124 \x12\x03-\x04\x16\n\x0c\n\x05\x04\0\x02\x04\x05\x12\x03-\x04\t\n\x0c\n\
3125 \x05\x04\0\x02\x04\x01\x12\x03-\n\x11\n\x0c\n\x05\x04\0\x02\x04\x03\x12\
3126 \x03-\x14\x15\nm\n\x04\x04\0\x02\x05\x12\x031\x04\x16\x1a`\x20Deprecated\
3127 !\x20It\x20is\x20kept\x20for\x20backward\x20compatibility.\n\x20TODO:\
3128 \x20remove\x20it\x20in\x20the\x20next\x20major\x20release.\n\n\x0c\n\x05\
3129 \x04\0\x02\x05\x05\x12\x031\x04\x08\n\x0c\n\x05\x04\0\x02\x05\x01\x12\
3130 \x031\t\x11\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x031\x14\x15\n\n\n\x02\x04\
3131 \x01\x12\x044\0;\x01\n\n\n\x03\x04\x01\x01\x12\x034\x08\x18\n'\n\x04\x04\
3132 \x01\x02\0\x12\x036\x04\x1d\x1a\x1a\x20The\x20current\x20`ConfState`.\n\
3133 \n\x0c\n\x05\x04\x01\x02\0\x06\x12\x036\x04\r\n\x0c\n\x05\x04\x01\x02\0\
3134 \x01\x12\x036\x0e\x18\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x036\x1b\x1c\n!\
3135 \n\x04\x04\x01\x02\x01\x12\x038\x04\x15\x1a\x14\x20The\x20applied\x20ind\
3136 ex.\n\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x038\x04\n\n\x0c\n\x05\x04\x01\
3137 \x02\x01\x01\x12\x038\x0b\x10\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x038\
3138 \x13\x14\n-\n\x04\x04\x01\x02\x02\x12\x03:\x04\x14\x1a\x20\x20The\x20ter\
3139 m\x20of\x20the\x20applied\x20index.\n\n\x0c\n\x05\x04\x01\x02\x02\x05\
3140 \x12\x03:\x04\n\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03:\x0b\x0f\n\x0c\n\
3141 \x05\x04\x01\x02\x02\x03\x12\x03:\x12\x13\n\n\n\x02\x04\x02\x12\x04=\0@\
3142 \x01\n\n\n\x03\x04\x02\x01\x12\x03=\x08\x10\n\x0b\n\x04\x04\x02\x02\0\
3143 \x12\x03>\x04\x13\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03>\x04\t\n\x0c\n\
3144 \x05\x04\x02\x02\0\x01\x12\x03>\n\x0e\n\x0c\n\x05\x04\x02\x02\0\x03\x12\
3145 \x03>\x11\x12\n\x0b\n\x04\x04\x02\x02\x01\x12\x03?\x04\"\n\x0c\n\x05\x04\
3146 \x02\x02\x01\x06\x12\x03?\x04\x14\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\
3147 \x03?\x15\x1d\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03?\x20!\n\n\n\x02\
3148 \x05\x01\x12\x04B\0V\x01\n\n\n\x03\x05\x01\x01\x12\x03B\x05\x10\n\x0b\n\
3149 \x04\x05\x01\x02\0\x12\x03C\x04\x0f\n\x0c\n\x05\x05\x01\x02\0\x01\x12\
3150 \x03C\x04\n\n\x0c\n\x05\x05\x01\x02\0\x02\x12\x03C\r\x0e\n\x0b\n\x04\x05\
3151 \x01\x02\x01\x12\x03D\x04\x10\n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03D\
3152 \x04\x0b\n\x0c\n\x05\x05\x01\x02\x01\x02\x12\x03D\x0e\x0f\n\x0b\n\x04\
3153 \x05\x01\x02\x02\x12\x03E\x04\x13\n\x0c\n\x05\x05\x01\x02\x02\x01\x12\
3154 \x03E\x04\x0e\n\x0c\n\x05\x05\x01\x02\x02\x02\x12\x03E\x11\x12\n\x0b\n\
3155 \x04\x05\x01\x02\x03\x12\x03F\x04\x12\n\x0c\n\x05\x05\x01\x02\x03\x01\
3156 \x12\x03F\x04\r\n\x0c\n\x05\x05\x01\x02\x03\x02\x12\x03F\x10\x11\n\x0b\n\
3157 \x04\x05\x01\x02\x04\x12\x03G\x04\x1a\n\x0c\n\x05\x05\x01\x02\x04\x01\
3158 \x12\x03G\x04\x15\n\x0c\n\x05\x05\x01\x02\x04\x02\x12\x03G\x18\x19\n\x0b\
3159 \n\x04\x05\x01\x02\x05\x12\x03H\x04\x17\n\x0c\n\x05\x05\x01\x02\x05\x01\
3160 \x12\x03H\x04\x12\n\x0c\n\x05\x05\x01\x02\x05\x02\x12\x03H\x15\x16\n\x0b\
3161 \n\x04\x05\x01\x02\x06\x12\x03I\x04\x1f\n\x0c\n\x05\x05\x01\x02\x06\x01\
3162 \x12\x03I\x04\x1a\n\x0c\n\x05\x05\x01\x02\x06\x02\x12\x03I\x1d\x1e\n\x0b\
3163 \n\x04\x05\x01\x02\x07\x12\x03J\x04\x14\n\x0c\n\x05\x05\x01\x02\x07\x01\
3164 \x12\x03J\x04\x0f\n\x0c\n\x05\x05\x01\x02\x07\x02\x12\x03J\x12\x13\n\x0b\
3165 \n\x04\x05\x01\x02\x08\x12\x03K\x04\x15\n\x0c\n\x05\x05\x01\x02\x08\x01\
3166 \x12\x03K\x04\x10\n\x0c\n\x05\x05\x01\x02\x08\x02\x12\x03K\x13\x14\n\x0b\
3167 \n\x04\x05\x01\x02\t\x12\x03L\x04\x1d\n\x0c\n\x05\x05\x01\x02\t\x01\x12\
3168 \x03L\x04\x18\n\x0c\n\x05\x05\x01\x02\t\x02\x12\x03L\x1b\x1c\n\x0b\n\x04\
3169 \x05\x01\x02\n\x12\x03M\x04\x18\n\x0c\n\x05\x05\x01\x02\n\x01\x12\x03M\
3170 \x04\x12\n\x0c\n\x05\x05\x01\x02\n\x02\x12\x03M\x15\x17\n\x0b\n\x04\x05\
3171 \x01\x02\x0b\x12\x03N\x04\x17\n\x0c\n\x05\x05\x01\x02\x0b\x01\x12\x03N\
3172 \x04\x11\n\x0c\n\x05\x05\x01\x02\x0b\x02\x12\x03N\x14\x16\n\x0b\n\x04\
3173 \x05\x01\x02\x0c\x12\x03O\x04\x18\n\x0c\n\x05\x05\x01\x02\x0c\x01\x12\
3174 \x03O\x04\x12\n\x0c\n\x05\x05\x01\x02\x0c\x02\x12\x03O\x15\x17\n\x0b\n\
3175 \x04\x05\x01\x02\r\x12\x03P\x04\x1b\n\x0c\n\x05\x05\x01\x02\r\x01\x12\
3176 \x03P\x04\x15\n\x0c\n\x05\x05\x01\x02\r\x02\x12\x03P\x18\x1a\n\x0b\n\x04\
3177 \x05\x01\x02\x0e\x12\x03Q\x04\x17\n\x0c\n\x05\x05\x01\x02\x0e\x01\x12\
3178 \x03Q\x04\x11\n\x0c\n\x05\x05\x01\x02\x0e\x02\x12\x03Q\x14\x16\n\x0b\n\
3179 \x04\x05\x01\x02\x0f\x12\x03R\x04\x16\n\x0c\n\x05\x05\x01\x02\x0f\x01\
3180 \x12\x03R\x04\x10\n\x0c\n\x05\x05\x01\x02\x0f\x02\x12\x03R\x13\x15\n\x0b\
3181 \n\x04\x05\x01\x02\x10\x12\x03S\x04\x1a\n\x0c\n\x05\x05\x01\x02\x10\x01\
3182 \x12\x03S\x04\x14\n\x0c\n\x05\x05\x01\x02\x10\x02\x12\x03S\x17\x19\n\x0b\
3183 \n\x04\x05\x01\x02\x11\x12\x03T\x04\x1b\n\x0c\n\x05\x05\x01\x02\x11\x01\
3184 \x12\x03T\x04\x15\n\x0c\n\x05\x05\x01\x02\x11\x02\x12\x03T\x18\x1a\n\x0b\
3185 \n\x04\x05\x01\x02\x12\x12\x03U\x04#\n\x0c\n\x05\x05\x01\x02\x12\x01\x12\
3186 \x03U\x04\x1d\n\x0c\n\x05\x05\x01\x02\x12\x02\x12\x03U\x20\"\n\n\n\x02\
3187 \x04\x03\x12\x04X\0s\x01\n\n\n\x03\x04\x03\x01\x12\x03X\x08\x0f\n\x0b\n\
3188 \x04\x04\x03\x02\0\x12\x03Y\x04\x1d\n\x0c\n\x05\x04\x03\x02\0\x06\x12\
3189 \x03Y\x04\x0f\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03Y\x10\x18\n\x0c\n\x05\
3190 \x04\x03\x02\0\x03\x12\x03Y\x1b\x1c\n\x0b\n\x04\x04\x03\x02\x01\x12\x03Z\
3191 \x04\x12\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03Z\x04\n\n\x0c\n\x05\x04\
3192 \x03\x02\x01\x01\x12\x03Z\x0b\r\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03Z\
3193 \x10\x11\n\x0b\n\x04\x04\x03\x02\x02\x12\x03[\x04\x14\n\x0c\n\x05\x04\
3194 \x03\x02\x02\x05\x12\x03[\x04\n\n\x0c\n\x05\x04\x03\x02\x02\x01\x12\x03[\
3195 \x0b\x0f\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03[\x12\x13\n\x0b\n\x04\
3196 \x04\x03\x02\x03\x12\x03\\\x04\x14\n\x0c\n\x05\x04\x03\x02\x03\x05\x12\
3197 \x03\\\x04\n\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03\\\x0b\x0f\n\x0c\n\
3198 \x05\x04\x03\x02\x03\x03\x12\x03\\\x12\x13\n\x86\x03\n\x04\x04\x03\x02\
3199 \x04\x12\x03b\x04\x18\x1a\xf8\x02\x20logTerm\x20is\x20generally\x20used\
3200 \x20for\x20appending\x20Raft\x20logs\x20to\x20followers.\x20For\x20examp\
3201 le,\n\x20(type=MsgAppend,index=100,log_term=5)\x20means\x20leader\x20app\
3202 ends\x20entries\x20starting\x20at\n\x20index=101,\x20and\x20the\x20term\
3203 \x20of\x20entry\x20at\x20index\x20100\x20is\x205.\n\x20(type=MsgAppendRe\
3204 sponse,reject=true,index=100,log_term=5)\x20means\x20follower\x20rejects\
3205 \x20some\n\x20entries\x20from\x20its\x20leader\x20as\x20it\x20already\
3206 \x20has\x20an\x20entry\x20with\x20term\x205\x20at\x20index\x20100.\n\n\
3207 \x0c\n\x05\x04\x03\x02\x04\x05\x12\x03b\x04\n\n\x0c\n\x05\x04\x03\x02\
3208 \x04\x01\x12\x03b\x0b\x13\n\x0c\n\x05\x04\x03\x02\x04\x03\x12\x03b\x16\
3209 \x17\n\x0b\n\x04\x04\x03\x02\x05\x12\x03c\x04\x15\n\x0c\n\x05\x04\x03\
3210 \x02\x05\x05\x12\x03c\x04\n\n\x0c\n\x05\x04\x03\x02\x05\x01\x12\x03c\x0b\
3211 \x10\n\x0c\n\x05\x04\x03\x02\x05\x03\x12\x03c\x13\x14\n\x0b\n\x04\x04\
3212 \x03\x02\x06\x12\x03d\x04\x1f\n\x0c\n\x05\x04\x03\x02\x06\x04\x12\x03d\
3213 \x04\x0c\n\x0c\n\x05\x04\x03\x02\x06\x06\x12\x03d\r\x12\n\x0c\n\x05\x04\
3214 \x03\x02\x06\x01\x12\x03d\x13\x1a\n\x0c\n\x05\x04\x03\x02\x06\x03\x12\
3215 \x03d\x1d\x1e\n\x0b\n\x04\x04\x03\x02\x07\x12\x03e\x04\x16\n\x0c\n\x05\
3216 \x04\x03\x02\x07\x05\x12\x03e\x04\n\n\x0c\n\x05\x04\x03\x02\x07\x01\x12\
3217 \x03e\x0b\x11\n\x0c\n\x05\x04\x03\x02\x07\x03\x12\x03e\x14\x15\n\x0b\n\
3218 \x04\x04\x03\x02\x08\x12\x03f\x04\x1c\n\x0c\n\x05\x04\x03\x02\x08\x05\
3219 \x12\x03f\x04\n\n\x0c\n\x05\x04\x03\x02\x08\x01\x12\x03f\x0b\x16\n\x0c\n\
3220 \x05\x04\x03\x02\x08\x03\x12\x03f\x19\x1b\n\x0b\n\x04\x04\x03\x02\t\x12\
3221 \x03g\x04\x1a\n\x0c\n\x05\x04\x03\x02\t\x06\x12\x03g\x04\x0c\n\x0c\n\x05\
3222 \x04\x03\x02\t\x01\x12\x03g\r\x15\n\x0c\n\x05\x04\x03\x02\t\x03\x12\x03g\
3223 \x18\x19\n\x0b\n\x04\x04\x03\x02\n\x12\x03h\x04!\n\x0c\n\x05\x04\x03\x02\
3224 \n\x05\x12\x03h\x04\n\n\x0c\n\x05\x04\x03\x02\n\x01\x12\x03h\x0b\x1b\n\
3225 \x0c\n\x05\x04\x03\x02\n\x03\x12\x03h\x1e\x20\n\x0b\n\x04\x04\x03\x02\
3226 \x0b\x12\x03i\x04\x15\n\x0c\n\x05\x04\x03\x02\x0b\x05\x12\x03i\x04\x08\n\
3227 \x0c\n\x05\x04\x03\x02\x0b\x01\x12\x03i\t\x0f\n\x0c\n\x05\x04\x03\x02\
3228 \x0b\x03\x12\x03i\x12\x14\n\x0b\n\x04\x04\x03\x02\x0c\x12\x03j\x04\x1c\n\
3229 \x0c\n\x05\x04\x03\x02\x0c\x05\x12\x03j\x04\n\n\x0c\n\x05\x04\x03\x02\
3230 \x0c\x01\x12\x03j\x0b\x16\n\x0c\n\x05\x04\x03\x02\x0c\x03\x12\x03j\x19\
3231 \x1b\n\x0b\n\x04\x04\x03\x02\r\x12\x03k\x04\x17\n\x0c\n\x05\x04\x03\x02\
3232 \r\x05\x12\x03k\x04\t\n\x0c\n\x05\x04\x03\x02\r\x01\x12\x03k\n\x11\n\x0c\
3233 \n\x05\x04\x03\x02\r\x03\x12\x03k\x14\x16\n\x0b\n\x04\x04\x03\x02\x0e\
3234 \x12\x03l\x04$\n\x0c\n\x05\x04\x03\x02\x0e\x05\x12\x03l\x04\n\n\x0c\n\
3235 \x05\x04\x03\x02\x0e\x01\x12\x03l\x0b\x1e\n\x0c\n\x05\x04\x03\x02\x0e\
3236 \x03\x12\x03l!#\n\xdd\x02\n\x04\x04\x03\x02\x0f\x12\x03r\x04\x18\x1a\xcf\
3237 \x02\x20If\x20this\x20new\x20field\x20is\x20not\x20set,\x20then\x20use\
3238 \x20the\x20above\x20old\x20field;\x20otherwise\n\x20use\x20the\x20new\
3239 \x20field.\x20When\x20broadcasting\x20request\x20vote,\x20both\x20fields\
3240 \x20are\n\x20set\x20if\x20the\x20priority\x20is\x20larger\x20than\x200.\
3241 \x20This\x20change\x20is\x20not\x20a\x20fully\n\x20compatible\x20change,\
3242 \x20but\x20it\x20makes\x20minimal\x20impact\x20that\x20only\x20new\x20pr\
3243 iority\n\x20is\x20not\x20recognized\x20by\x20the\x20old\x20nodes\x20duri\
3244 ng\x20rolling\x20update.\n\n\x0c\n\x05\x04\x03\x02\x0f\x05\x12\x03r\x04\
3245 \t\n\x0c\n\x05\x04\x03\x02\x0f\x01\x12\x03r\n\x12\n\x0c\n\x05\x04\x03\
3246 \x02\x0f\x03\x12\x03r\x15\x17\n\n\n\x02\x04\x04\x12\x04u\0y\x01\n\n\n\
3247 \x03\x04\x04\x01\x12\x03u\x08\x11\n\x0b\n\x04\x04\x04\x02\0\x12\x03v\x04\
3248 \x14\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03v\x04\n\n\x0c\n\x05\x04\x04\
3249 \x02\0\x01\x12\x03v\x0b\x0f\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03v\x12\
3250 \x13\n\x0b\n\x04\x04\x04\x02\x01\x12\x03w\x04\x14\n\x0c\n\x05\x04\x04\
3251 \x02\x01\x05\x12\x03w\x04\n\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03w\x0b\
3252 \x0f\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03w\x12\x13\n\x0b\n\x04\x04\
3253 \x04\x02\x02\x12\x03x\x04\x16\n\x0c\n\x05\x04\x04\x02\x02\x05\x12\x03x\
3254 \x04\n\n\x0c\n\x05\x04\x04\x02\x02\x01\x12\x03x\x0b\x11\n\x0c\n\x05\x04\
3255 \x04\x02\x02\x03\x12\x03x\x14\x15\n\x0b\n\x02\x05\x02\x12\x05{\0\x8b\x01\
3256 \x01\n\n\n\x03\x05\x02\x01\x12\x03{\x05\x19\n\x9d\x01\n\x04\x05\x02\x02\
3257 \0\x12\x03~\x04\r\x1a\x8f\x01\x20Automatically\x20use\x20the\x20simple\
3258 \x20protocol\x20if\x20possible,\x20otherwise\x20fall\x20back\n\x20to\x20\
3259 ConfChangeType::Implicit.\x20Most\x20applications\x20will\x20want\x20to\
3260 \x20use\x20this.\n\n\x0c\n\x05\x05\x02\x02\0\x01\x12\x03~\x04\x08\n\x0c\
3261 \n\x05\x05\x02\x02\0\x02\x12\x03~\x0b\x0c\n\xd1\x02\n\x04\x05\x02\x02\
3262 \x01\x12\x04\x85\x01\x04\x11\x1a\xc2\x02\x20Use\x20joint\x20consensus\
3263 \x20unconditionally,\x20and\x20transition\x20out\x20of\x20them\n\x20auto\
3264 matically\x20(by\x20proposing\x20a\x20zero\x20configuration\x20change).\
3265 \n\n\x20This\x20option\x20is\x20suitable\x20for\x20applications\x20that\
3266 \x20want\x20to\x20minimize\x20the\x20time\n\x20spent\x20in\x20the\x20joi\
3267 nt\x20configuration\x20and\x20do\x20not\x20store\x20the\x20joint\x20conf\
3268 iguration\n\x20in\x20the\x20state\x20machine\x20(outside\x20of\x20Initia\
3269 lState).\n\n\r\n\x05\x05\x02\x02\x01\x01\x12\x04\x85\x01\x04\x0c\n\r\n\
3270 \x05\x05\x02\x02\x01\x02\x12\x04\x85\x01\x0f\x10\n\x9a\x02\n\x04\x05\x02\
3271 \x02\x02\x12\x04\x8a\x01\x04\x11\x1a\x8b\x02\x20Use\x20joint\x20consensu\
3272 s\x20and\x20remain\x20in\x20the\x20joint\x20configuration\x20until\x20th\
3273 e\n\x20application\x20proposes\x20a\x20no-op\x20configuration\x20change.\
3274 \x20This\x20is\x20suitable\x20for\n\x20applications\x20that\x20want\x20t\
3275 o\x20explicitly\x20control\x20the\x20transitions,\x20for\x20example\n\
3276 \x20to\x20use\x20a\x20custom\x20payload\x20(via\x20the\x20Context\x20fie\
3277 ld).\n\n\r\n\x05\x05\x02\x02\x02\x01\x12\x04\x8a\x01\x04\x0c\n\r\n\x05\
3278 \x05\x02\x02\x02\x02\x12\x04\x8a\x01\x0f\x10\n\x0c\n\x02\x04\x05\x12\x06\
3279 \x8d\x01\0\x9a\x01\x01\n\x0b\n\x03\x04\x05\x01\x12\x04\x8d\x01\x08\x11\n\
3280 \x0c\n\x04\x04\x05\x02\0\x12\x04\x8e\x01\x04\x1f\n\r\n\x05\x04\x05\x02\0\
3281 \x04\x12\x04\x8e\x01\x04\x0c\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\x8e\x01\
3282 \r\x13\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\x8e\x01\x14\x1a\n\r\n\x05\x04\
3283 \x05\x02\0\x03\x12\x04\x8e\x01\x1d\x1e\n\x0c\n\x04\x04\x05\x02\x01\x12\
3284 \x04\x8f\x01\x04!\n\r\n\x05\x04\x05\x02\x01\x04\x12\x04\x8f\x01\x04\x0c\
3285 \n\r\n\x05\x04\x05\x02\x01\x05\x12\x04\x8f\x01\r\x13\n\r\n\x05\x04\x05\
3286 \x02\x01\x01\x12\x04\x8f\x01\x14\x1c\n\r\n\x05\x04\x05\x02\x01\x03\x12\
3287 \x04\x8f\x01\x1f\x20\n_\n\x04\x04\x05\x02\x02\x12\x04\x92\x01\x04(\x1aQ\
3288 \x20The\x20voters\x20in\x20the\x20outgoing\x20config.\x20If\x20not\x20em\
3289 pty\x20the\x20node\x20is\x20in\x20joint\x20consensus.\n\n\r\n\x05\x04\
3290 \x05\x02\x02\x04\x12\x04\x92\x01\x04\x0c\n\r\n\x05\x04\x05\x02\x02\x05\
3291 \x12\x04\x92\x01\r\x13\n\r\n\x05\x04\x05\x02\x02\x01\x12\x04\x92\x01\x14\
3292 #\n\r\n\x05\x04\x05\x02\x02\x03\x12\x04\x92\x01&'\n\xd3\x01\n\x04\x04\
3293 \x05\x02\x03\x12\x04\x96\x01\x04&\x1a\xc4\x01\x20The\x20nodes\x20that\
3294 \x20will\x20become\x20learners\x20when\x20the\x20outgoing\x20config\x20i\
3295 s\x20removed.\n\x20These\x20nodes\x20are\x20necessarily\x20currently\x20\
3296 in\x20nodes_joint\x20(or\x20they\x20would\x20have\n\x20been\x20added\x20\
3297 to\x20the\x20incoming\x20config\x20right\x20away).\n\n\r\n\x05\x04\x05\
3298 \x02\x03\x04\x12\x04\x96\x01\x04\x0c\n\r\n\x05\x04\x05\x02\x03\x05\x12\
3299 \x04\x96\x01\r\x13\n\r\n\x05\x04\x05\x02\x03\x01\x12\x04\x96\x01\x14!\n\
3300 \r\n\x05\x04\x05\x02\x03\x03\x12\x04\x96\x01$%\n\x9f\x01\n\x04\x04\x05\
3301 \x02\x04\x12\x04\x99\x01\x04\x18\x1a\x90\x01\x20If\x20set,\x20the\x20con\
3302 fig\x20is\x20joint\x20and\x20Raft\x20will\x20automatically\x20transition\
3303 \x20into\n\x20the\x20final\x20config\x20(i.e.\x20remove\x20the\x20outgoi\
3304 ng\x20config)\x20when\x20this\x20is\x20safe.\n\n\r\n\x05\x04\x05\x02\x04\
3305 \x05\x12\x04\x99\x01\x04\x08\n\r\n\x05\x04\x05\x02\x04\x01\x12\x04\x99\
3306 \x01\t\x13\n\r\n\x05\x04\x05\x02\x04\x03\x12\x04\x99\x01\x16\x17\n\x0c\n\
3307 \x02\x05\x03\x12\x06\x9c\x01\0\xa0\x01\x01\n\x0b\n\x03\x05\x03\x01\x12\
3308 \x04\x9c\x01\x05\x13\n\x0c\n\x04\x05\x03\x02\0\x12\x04\x9d\x01\x04\x13\n\
3309 \r\n\x05\x05\x03\x02\0\x01\x12\x04\x9d\x01\x04\x0b\n\r\n\x05\x05\x03\x02\
3310 \0\x02\x12\x04\x9d\x01\x11\x12\n\x0c\n\x04\x05\x03\x02\x01\x12\x04\x9e\
3311 \x01\x04\x13\n\r\n\x05\x05\x03\x02\x01\x01\x12\x04\x9e\x01\x04\x0e\n\r\n\
3312 \x05\x05\x03\x02\x01\x02\x12\x04\x9e\x01\x11\x12\n\x0c\n\x04\x05\x03\x02\
3313 \x02\x12\x04\x9f\x01\x04\x17\n\r\n\x05\x05\x03\x02\x02\x01\x12\x04\x9f\
3314 \x01\x04\x12\n\r\n\x05\x05\x03\x02\x02\x02\x12\x04\x9f\x01\x15\x16\n\x0c\
3315 \n\x02\x04\x06\x12\x06\xa2\x01\0\xa8\x01\x01\n\x0b\n\x03\x04\x06\x01\x12\
3316 \x04\xa2\x01\x08\x12\n\x0c\n\x04\x04\x06\x02\0\x12\x04\xa3\x01\x04#\n\r\
3317 \n\x05\x04\x06\x02\0\x06\x12\x04\xa3\x01\x04\x12\n\r\n\x05\x04\x06\x02\0\
3318 \x01\x12\x04\xa3\x01\x13\x1e\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xa3\x01\
3319 !\"\n\x0c\n\x04\x04\x06\x02\x01\x12\x04\xa4\x01\x04\x17\n\r\n\x05\x04\
3320 \x06\x02\x01\x05\x12\x04\xa4\x01\x04\n\n\r\n\x05\x04\x06\x02\x01\x01\x12\
3321 \x04\xa4\x01\x0b\x12\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\xa4\x01\x15\
3322 \x16\n\x0c\n\x04\x04\x06\x02\x02\x12\x04\xa5\x01\x04\x16\n\r\n\x05\x04\
3323 \x06\x02\x02\x05\x12\x04\xa5\x01\x04\t\n\r\n\x05\x04\x06\x02\x02\x01\x12\
3324 \x04\xa5\x01\n\x11\n\r\n\x05\x04\x06\x02\x02\x03\x12\x04\xa5\x01\x14\x15\
3325 \n\x0c\n\x04\x04\x06\x02\x03\x12\x04\xa7\x01\x04\x12\n\r\n\x05\x04\x06\
3326 \x02\x03\x05\x12\x04\xa7\x01\x04\n\n\r\n\x05\x04\x06\x02\x03\x01\x12\x04\
3327 \xa7\x01\x0b\r\n\r\n\x05\x04\x06\x02\x03\x03\x12\x04\xa7\x01\x10\x11\n\
3328 \x9e\x01\n\x02\x04\x07\x12\x06\xac\x01\0\xaf\x01\x01\x1a\x8f\x01\x20Conf\
3329 ChangeSingle\x20is\x20an\x20individual\x20configuration\x20change\x20ope\
3330 ration.\x20Multiple\n\x20such\x20operations\x20can\x20be\x20carried\x20o\
3331 ut\x20atomically\x20via\x20a\x20ConfChangeV2.\n\n\x0b\n\x03\x04\x07\x01\
3332 \x12\x04\xac\x01\x08\x18\n\x0c\n\x04\x04\x07\x02\0\x12\x04\xad\x01\x04#\
3333 \n\r\n\x05\x04\x07\x02\0\x06\x12\x04\xad\x01\x04\x12\n\r\n\x05\x04\x07\
3334 \x02\0\x01\x12\x04\xad\x01\x13\x1e\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\
3335 \xad\x01!\"\n\x0c\n\x04\x04\x07\x02\x01\x12\x04\xae\x01\x04\x17\n\r\n\
3336 \x05\x04\x07\x02\x01\x05\x12\x04\xae\x01\x04\n\n\r\n\x05\x04\x07\x02\x01\
3337 \x01\x12\x04\xae\x01\x0b\x12\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\xae\
3338 \x01\x15\x16\n\xfb\r\n\x02\x04\x08\x12\x06\xd1\x01\0\xd5\x01\x01\x1a\xec\
3339 \r\x20ConfChangeV2\x20messages\x20initiate\x20configuration\x20changes.\
3340 \x20They\x20support\x20both\x20the\n\x20simple\x20\"one\x20at\x20a\x20ti\
3341 me\"\x20membership\x20change\x20protocol\x20and\x20full\x20Joint\x20Cons\
3342 ensus\n\x20allowing\x20for\x20arbitrary\x20changes\x20in\x20membership.\
3343 \n\n\x20The\x20supplied\x20context\x20is\x20treated\x20as\x20an\x20opaqu\
3344 e\x20payload\x20and\x20can\x20be\x20used\x20to\n\x20attach\x20an\x20acti\
3345 on\x20on\x20the\x20state\x20machine\x20to\x20the\x20application\x20of\
3346 \x20the\x20config\x20change\n\x20proposal.\x20Note\x20that\x20contrary\
3347 \x20to\x20Joint\x20Consensus\x20as\x20outlined\x20in\x20the\x20Raft\n\
3348 \x20paper[1],\x20configuration\x20changes\x20become\x20active\x20when\
3349 \x20they\x20are\x20*applied*\x20to\x20the\n\x20state\x20machine\x20(not\
3350 \x20when\x20they\x20are\x20appended\x20to\x20the\x20log).\n\n\x20The\x20\
3351 simple\x20protocol\x20can\x20be\x20used\x20whenever\x20only\x20a\x20sing\
3352 le\x20change\x20is\x20made.\n\n\x20Non-simple\x20changes\x20require\x20t\
3353 he\x20use\x20of\x20Joint\x20Consensus,\x20for\x20which\x20two\n\x20confi\
3354 guration\x20changes\x20are\x20run.\x20The\x20first\x20configuration\x20c\
3355 hange\x20specifies\x20the\n\x20desired\x20changes\x20and\x20transitions\
3356 \x20the\x20Raft\x20group\x20into\x20the\x20joint\x20configuration,\n\x20\
3357 in\x20which\x20quorum\x20requires\x20a\x20majority\x20of\x20both\x20the\
3358 \x20pre-changes\x20and\x20post-changes\n\x20configuration.\x20Joint\x20C\
3359 onsensus\x20avoids\x20entering\x20fragile\x20intermediate\n\x20configura\
3360 tions\x20that\x20could\x20compromise\x20survivability.\x20For\x20example\
3361 ,\x20without\x20the\n\x20use\x20of\x20Joint\x20Consensus\x20and\x20runni\
3362 ng\x20across\x20three\x20availability\x20zones\x20with\x20a\n\x20replica\
3363 tion\x20factor\x20of\x20three,\x20it\x20is\x20not\x20possible\x20to\x20r\
3364 eplace\x20a\x20voter\x20without\n\x20entering\x20an\x20intermediate\x20c\
3365 onfiguration\x20that\x20does\x20not\x20survive\x20the\x20outage\x20of\n\
3366 \x20one\x20availability\x20zone.\n\n\x20The\x20provided\x20ConfChangeTra\
3367 nsition\x20specifies\x20how\x20(and\x20whether)\x20Joint\x20Consensus\n\
3368 \x20is\x20used,\x20and\x20assigns\x20the\x20task\x20of\x20leaving\x20the\
3369 \x20joint\x20configuration\x20either\x20to\n\x20Raft\x20or\x20the\x20app\
3370 lication.\x20Leaving\x20the\x20joint\x20configuration\x20is\x20accomplis\
3371 hed\x20by\n\x20proposing\x20a\x20ConfChangeV2\x20with\x20only\x20and\x20\
3372 optionally\x20the\x20Context\x20field\n\x20populated.\n\n\x20For\x20deta\
3373 ils\x20on\x20Raft\x20membership\x20changes,\x20see:\n\n\x20[1]:\x20https\
3374 ://github.com/ongardie/dissertation/blob/master/online-trim.pdf\n\n\x0b\
3375 \n\x03\x04\x08\x01\x12\x04\xd1\x01\x08\x14\n\x0c\n\x04\x04\x08\x02\0\x12\
3376 \x04\xd2\x01\x04(\n\r\n\x05\x04\x08\x02\0\x06\x12\x04\xd2\x01\x04\x18\n\
3377 \r\n\x05\x04\x08\x02\0\x01\x12\x04\xd2\x01\x19#\n\r\n\x05\x04\x08\x02\0\
3378 \x03\x12\x04\xd2\x01&'\n\x0c\n\x04\x04\x08\x02\x01\x12\x04\xd3\x01\x04*\
3379 \n\r\n\x05\x04\x08\x02\x01\x04\x12\x04\xd3\x01\x04\x0c\n\r\n\x05\x04\x08\
3380 \x02\x01\x06\x12\x04\xd3\x01\r\x1d\n\r\n\x05\x04\x08\x02\x01\x01\x12\x04\
3381 \xd3\x01\x1e%\n\r\n\x05\x04\x08\x02\x01\x03\x12\x04\xd3\x01()\n\x0c\n\
3382 \x04\x04\x08\x02\x02\x12\x04\xd4\x01\x04\x16\n\r\n\x05\x04\x08\x02\x02\
3383 \x05\x12\x04\xd4\x01\x04\t\n\r\n\x05\x04\x08\x02\x02\x01\x12\x04\xd4\x01\
3384 \n\x11\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\xd4\x01\x14\x15b\x06proto3\
3385";
3386
3387static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
3388
3389fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
3390 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
3391}
3392
3393pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
3394 file_descriptor_proto_lazy.get(|| {
3395 parse_descriptor_proto()
3396 })
3397}