blob: fcf259c89beca2a6e22ab44ab93a7e36f996be9f [file] [log] [blame]
Scott Baker2c1c4822019-10-16 11:02:41 -07001// Code generated by protoc-gen-gogo. DO NOT EDIT.
2// source: raft.proto
3
4/*
5 Package raftpb is a generated protocol buffer package.
6
7 It is generated from these files:
8 raft.proto
9
10 It has these top-level messages:
11 Entry
12 SnapshotMetadata
13 Snapshot
14 Message
15 HardState
16 ConfState
17 ConfChange
18 ConfChangeSingle
19 ConfChangeV2
20*/
21package raftpb
22
23import (
24 "fmt"
25
26 proto "github.com/golang/protobuf/proto"
27
28 math "math"
29
30 _ "github.com/gogo/protobuf/gogoproto"
31
32 io "io"
33)
34
35// Reference imports to suppress errors if they are not otherwise used.
36var _ = proto.Marshal
37var _ = fmt.Errorf
38var _ = math.Inf
39
40// This is a compile-time assertion to ensure that this generated file
41// is compatible with the proto package it is being compiled against.
42// A compilation error at this line likely means your copy of the
43// proto package needs to be updated.
44const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
45
46type EntryType int32
47
48const (
49 EntryNormal EntryType = 0
50 EntryConfChange EntryType = 1
51 EntryConfChangeV2 EntryType = 2
52)
53
54var EntryType_name = map[int32]string{
55 0: "EntryNormal",
56 1: "EntryConfChange",
57 2: "EntryConfChangeV2",
58}
59var EntryType_value = map[string]int32{
60 "EntryNormal": 0,
61 "EntryConfChange": 1,
62 "EntryConfChangeV2": 2,
63}
64
65func (x EntryType) Enum() *EntryType {
66 p := new(EntryType)
67 *p = x
68 return p
69}
70func (x EntryType) String() string {
71 return proto.EnumName(EntryType_name, int32(x))
72}
73func (x *EntryType) UnmarshalJSON(data []byte) error {
74 value, err := proto.UnmarshalJSONEnum(EntryType_value, data, "EntryType")
75 if err != nil {
76 return err
77 }
78 *x = EntryType(value)
79 return nil
80}
81func (EntryType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{0} }
82
83type MessageType int32
84
85const (
86 MsgHup MessageType = 0
87 MsgBeat MessageType = 1
88 MsgProp MessageType = 2
89 MsgApp MessageType = 3
90 MsgAppResp MessageType = 4
91 MsgVote MessageType = 5
92 MsgVoteResp MessageType = 6
93 MsgSnap MessageType = 7
94 MsgHeartbeat MessageType = 8
95 MsgHeartbeatResp MessageType = 9
96 MsgUnreachable MessageType = 10
97 MsgSnapStatus MessageType = 11
98 MsgCheckQuorum MessageType = 12
99 MsgTransferLeader MessageType = 13
100 MsgTimeoutNow MessageType = 14
101 MsgReadIndex MessageType = 15
102 MsgReadIndexResp MessageType = 16
103 MsgPreVote MessageType = 17
104 MsgPreVoteResp MessageType = 18
105)
106
107var MessageType_name = map[int32]string{
108 0: "MsgHup",
109 1: "MsgBeat",
110 2: "MsgProp",
111 3: "MsgApp",
112 4: "MsgAppResp",
113 5: "MsgVote",
114 6: "MsgVoteResp",
115 7: "MsgSnap",
116 8: "MsgHeartbeat",
117 9: "MsgHeartbeatResp",
118 10: "MsgUnreachable",
119 11: "MsgSnapStatus",
120 12: "MsgCheckQuorum",
121 13: "MsgTransferLeader",
122 14: "MsgTimeoutNow",
123 15: "MsgReadIndex",
124 16: "MsgReadIndexResp",
125 17: "MsgPreVote",
126 18: "MsgPreVoteResp",
127}
128var MessageType_value = map[string]int32{
129 "MsgHup": 0,
130 "MsgBeat": 1,
131 "MsgProp": 2,
132 "MsgApp": 3,
133 "MsgAppResp": 4,
134 "MsgVote": 5,
135 "MsgVoteResp": 6,
136 "MsgSnap": 7,
137 "MsgHeartbeat": 8,
138 "MsgHeartbeatResp": 9,
139 "MsgUnreachable": 10,
140 "MsgSnapStatus": 11,
141 "MsgCheckQuorum": 12,
142 "MsgTransferLeader": 13,
143 "MsgTimeoutNow": 14,
144 "MsgReadIndex": 15,
145 "MsgReadIndexResp": 16,
146 "MsgPreVote": 17,
147 "MsgPreVoteResp": 18,
148}
149
150func (x MessageType) Enum() *MessageType {
151 p := new(MessageType)
152 *p = x
153 return p
154}
155func (x MessageType) String() string {
156 return proto.EnumName(MessageType_name, int32(x))
157}
158func (x *MessageType) UnmarshalJSON(data []byte) error {
159 value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
160 if err != nil {
161 return err
162 }
163 *x = MessageType(value)
164 return nil
165}
166func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{1} }
167
168// ConfChangeTransition specifies the behavior of a configuration change with
169// respect to joint consensus.
170type ConfChangeTransition int32
171
172const (
173 // Automatically use the simple protocol if possible, otherwise fall back
174 // to ConfChangeJointImplicit. Most applications will want to use this.
175 ConfChangeTransitionAuto ConfChangeTransition = 0
176 // Use joint consensus unconditionally, and transition out of them
177 // automatically (by proposing a zero configuration change).
178 //
179 // This option is suitable for applications that want to minimize the time
180 // spent in the joint configuration and do not store the joint configuration
181 // in the state machine (outside of InitialState).
182 ConfChangeTransitionJointImplicit ConfChangeTransition = 1
183 // Use joint consensus and remain in the joint configuration until the
184 // application proposes a no-op configuration change. This is suitable for
185 // applications that want to explicitly control the transitions, for example
186 // to use a custom payload (via the Context field).
187 ConfChangeTransitionJointExplicit ConfChangeTransition = 2
188)
189
190var ConfChangeTransition_name = map[int32]string{
191 0: "ConfChangeTransitionAuto",
192 1: "ConfChangeTransitionJointImplicit",
193 2: "ConfChangeTransitionJointExplicit",
194}
195var ConfChangeTransition_value = map[string]int32{
196 "ConfChangeTransitionAuto": 0,
197 "ConfChangeTransitionJointImplicit": 1,
198 "ConfChangeTransitionJointExplicit": 2,
199}
200
201func (x ConfChangeTransition) Enum() *ConfChangeTransition {
202 p := new(ConfChangeTransition)
203 *p = x
204 return p
205}
206func (x ConfChangeTransition) String() string {
207 return proto.EnumName(ConfChangeTransition_name, int32(x))
208}
209func (x *ConfChangeTransition) UnmarshalJSON(data []byte) error {
210 value, err := proto.UnmarshalJSONEnum(ConfChangeTransition_value, data, "ConfChangeTransition")
211 if err != nil {
212 return err
213 }
214 *x = ConfChangeTransition(value)
215 return nil
216}
217func (ConfChangeTransition) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{2} }
218
219type ConfChangeType int32
220
221const (
222 ConfChangeAddNode ConfChangeType = 0
223 ConfChangeRemoveNode ConfChangeType = 1
224 ConfChangeUpdateNode ConfChangeType = 2
225 ConfChangeAddLearnerNode ConfChangeType = 3
226)
227
228var ConfChangeType_name = map[int32]string{
229 0: "ConfChangeAddNode",
230 1: "ConfChangeRemoveNode",
231 2: "ConfChangeUpdateNode",
232 3: "ConfChangeAddLearnerNode",
233}
234var ConfChangeType_value = map[string]int32{
235 "ConfChangeAddNode": 0,
236 "ConfChangeRemoveNode": 1,
237 "ConfChangeUpdateNode": 2,
238 "ConfChangeAddLearnerNode": 3,
239}
240
241func (x ConfChangeType) Enum() *ConfChangeType {
242 p := new(ConfChangeType)
243 *p = x
244 return p
245}
246func (x ConfChangeType) String() string {
247 return proto.EnumName(ConfChangeType_name, int32(x))
248}
249func (x *ConfChangeType) UnmarshalJSON(data []byte) error {
250 value, err := proto.UnmarshalJSONEnum(ConfChangeType_value, data, "ConfChangeType")
251 if err != nil {
252 return err
253 }
254 *x = ConfChangeType(value)
255 return nil
256}
257func (ConfChangeType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{3} }
258
259type Entry struct {
260 Term uint64 `protobuf:"varint,2,opt,name=Term" json:"Term"`
261 Index uint64 `protobuf:"varint,3,opt,name=Index" json:"Index"`
262 Type EntryType `protobuf:"varint,1,opt,name=Type,enum=raftpb.EntryType" json:"Type"`
263 Data []byte `protobuf:"bytes,4,opt,name=Data" json:"Data,omitempty"`
264 XXX_unrecognized []byte `json:"-"`
265}
266
267func (m *Entry) Reset() { *m = Entry{} }
268func (m *Entry) String() string { return proto.CompactTextString(m) }
269func (*Entry) ProtoMessage() {}
270func (*Entry) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{0} }
271
272type SnapshotMetadata struct {
273 ConfState ConfState `protobuf:"bytes,1,opt,name=conf_state,json=confState" json:"conf_state"`
274 Index uint64 `protobuf:"varint,2,opt,name=index" json:"index"`
275 Term uint64 `protobuf:"varint,3,opt,name=term" json:"term"`
276 XXX_unrecognized []byte `json:"-"`
277}
278
279func (m *SnapshotMetadata) Reset() { *m = SnapshotMetadata{} }
280func (m *SnapshotMetadata) String() string { return proto.CompactTextString(m) }
281func (*SnapshotMetadata) ProtoMessage() {}
282func (*SnapshotMetadata) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{1} }
283
284type Snapshot struct {
285 Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
286 Metadata SnapshotMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata"`
287 XXX_unrecognized []byte `json:"-"`
288}
289
290func (m *Snapshot) Reset() { *m = Snapshot{} }
291func (m *Snapshot) String() string { return proto.CompactTextString(m) }
292func (*Snapshot) ProtoMessage() {}
293func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{2} }
294
295type Message struct {
296 Type MessageType `protobuf:"varint,1,opt,name=type,enum=raftpb.MessageType" json:"type"`
297 To uint64 `protobuf:"varint,2,opt,name=to" json:"to"`
298 From uint64 `protobuf:"varint,3,opt,name=from" json:"from"`
299 Term uint64 `protobuf:"varint,4,opt,name=term" json:"term"`
300 LogTerm uint64 `protobuf:"varint,5,opt,name=logTerm" json:"logTerm"`
301 Index uint64 `protobuf:"varint,6,opt,name=index" json:"index"`
302 Entries []Entry `protobuf:"bytes,7,rep,name=entries" json:"entries"`
303 Commit uint64 `protobuf:"varint,8,opt,name=commit" json:"commit"`
304 Snapshot Snapshot `protobuf:"bytes,9,opt,name=snapshot" json:"snapshot"`
305 Reject bool `protobuf:"varint,10,opt,name=reject" json:"reject"`
306 RejectHint uint64 `protobuf:"varint,11,opt,name=rejectHint" json:"rejectHint"`
307 Context []byte `protobuf:"bytes,12,opt,name=context" json:"context,omitempty"`
308 XXX_unrecognized []byte `json:"-"`
309}
310
311func (m *Message) Reset() { *m = Message{} }
312func (m *Message) String() string { return proto.CompactTextString(m) }
313func (*Message) ProtoMessage() {}
314func (*Message) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{3} }
315
316type HardState struct {
317 Term uint64 `protobuf:"varint,1,opt,name=term" json:"term"`
318 Vote uint64 `protobuf:"varint,2,opt,name=vote" json:"vote"`
319 Commit uint64 `protobuf:"varint,3,opt,name=commit" json:"commit"`
320 XXX_unrecognized []byte `json:"-"`
321}
322
323func (m *HardState) Reset() { *m = HardState{} }
324func (m *HardState) String() string { return proto.CompactTextString(m) }
325func (*HardState) ProtoMessage() {}
326func (*HardState) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{4} }
327
328type ConfState struct {
329 // The voters in the incoming config. (If the configuration is not joint,
330 // then the outgoing config is empty).
331 Voters []uint64 `protobuf:"varint,1,rep,name=voters" json:"voters,omitempty"`
332 // The learners in the incoming config.
333 Learners []uint64 `protobuf:"varint,2,rep,name=learners" json:"learners,omitempty"`
334 // The voters in the outgoing config.
335 VotersOutgoing []uint64 `protobuf:"varint,3,rep,name=voters_outgoing,json=votersOutgoing" json:"voters_outgoing,omitempty"`
336 // The nodes that will become learners when the outgoing config is removed.
337 // These nodes are necessarily currently in nodes_joint (or they would have
338 // been added to the incoming config right away).
339 LearnersNext []uint64 `protobuf:"varint,4,rep,name=learners_next,json=learnersNext" json:"learners_next,omitempty"`
340 // If set, the config is joint and Raft will automatically transition into
341 // the final config (i.e. remove the outgoing config) when this is safe.
342 AutoLeave bool `protobuf:"varint,5,opt,name=auto_leave,json=autoLeave" json:"auto_leave"`
343 XXX_unrecognized []byte `json:"-"`
344}
345
346func (m *ConfState) Reset() { *m = ConfState{} }
347func (m *ConfState) String() string { return proto.CompactTextString(m) }
348func (*ConfState) ProtoMessage() {}
349func (*ConfState) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{5} }
350
351type ConfChange struct {
352 Type ConfChangeType `protobuf:"varint,2,opt,name=type,enum=raftpb.ConfChangeType" json:"type"`
353 NodeID uint64 `protobuf:"varint,3,opt,name=node_id,json=nodeId" json:"node_id"`
354 Context []byte `protobuf:"bytes,4,opt,name=context" json:"context,omitempty"`
355 // NB: this is used only by etcd to thread through a unique identifier.
356 // Ideally it should really use the Context instead. No counterpart to
357 // this field exists in ConfChangeV2.
358 ID uint64 `protobuf:"varint,1,opt,name=id" json:"id"`
359 XXX_unrecognized []byte `json:"-"`
360}
361
362func (m *ConfChange) Reset() { *m = ConfChange{} }
363func (m *ConfChange) String() string { return proto.CompactTextString(m) }
364func (*ConfChange) ProtoMessage() {}
365func (*ConfChange) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{6} }
366
367// ConfChangeSingle is an individual configuration change operation. Multiple
368// such operations can be carried out atomically via a ConfChangeV2.
369type ConfChangeSingle struct {
370 Type ConfChangeType `protobuf:"varint,1,opt,name=type,enum=raftpb.ConfChangeType" json:"type"`
371 NodeID uint64 `protobuf:"varint,2,opt,name=node_id,json=nodeId" json:"node_id"`
372 XXX_unrecognized []byte `json:"-"`
373}
374
375func (m *ConfChangeSingle) Reset() { *m = ConfChangeSingle{} }
376func (m *ConfChangeSingle) String() string { return proto.CompactTextString(m) }
377func (*ConfChangeSingle) ProtoMessage() {}
378func (*ConfChangeSingle) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{7} }
379
380// ConfChangeV2 messages initiate configuration changes. They support both the
381// simple "one at a time" membership change protocol and full Joint Consensus
382// allowing for arbitrary changes in membership.
383//
384// The supplied context is treated as an opaque payload and can be used to
385// attach an action on the state machine to the application of the config change
386// proposal. Note that contrary to Joint Consensus as outlined in the Raft
387// paper[1], configuration changes become active when they are *applied* to the
388// state machine (not when they are appended to the log).
389//
390// The simple protocol can be used whenever only a single change is made.
391//
392// Non-simple changes require the use of Joint Consensus, for which two
393// configuration changes are run. The first configuration change specifies the
394// desired changes and transitions the Raft group into the joint configuration,
395// in which quorum requires a majority of both the pre-changes and post-changes
396// configuration. Joint Consensus avoids entering fragile intermediate
397// configurations that could compromise survivability. For example, without the
398// use of Joint Consensus and running across three availability zones with a
399// replication factor of three, it is not possible to replace a voter without
400// entering an intermediate configuration that does not survive the outage of
401// one availability zone.
402//
403// The provided ConfChangeTransition specifies how (and whether) Joint Consensus
404// is used, and assigns the task of leaving the joint configuration either to
405// Raft or the application. Leaving the joint configuration is accomplished by
406// proposing a ConfChangeV2 with only and optionally the Context field
407// populated.
408//
409// For details on Raft membership changes, see:
410//
411// [1]: https://github.com/ongardie/dissertation/blob/master/online-trim.pdf
412type ConfChangeV2 struct {
413 Transition ConfChangeTransition `protobuf:"varint,1,opt,name=transition,enum=raftpb.ConfChangeTransition" json:"transition"`
414 Changes []ConfChangeSingle `protobuf:"bytes,2,rep,name=changes" json:"changes"`
415 Context []byte `protobuf:"bytes,3,opt,name=context" json:"context,omitempty"`
416 XXX_unrecognized []byte `json:"-"`
417}
418
419func (m *ConfChangeV2) Reset() { *m = ConfChangeV2{} }
420func (m *ConfChangeV2) String() string { return proto.CompactTextString(m) }
421func (*ConfChangeV2) ProtoMessage() {}
422func (*ConfChangeV2) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{8} }
423
424func init() {
425 proto.RegisterType((*Entry)(nil), "raftpb.Entry")
426 proto.RegisterType((*SnapshotMetadata)(nil), "raftpb.SnapshotMetadata")
427 proto.RegisterType((*Snapshot)(nil), "raftpb.Snapshot")
428 proto.RegisterType((*Message)(nil), "raftpb.Message")
429 proto.RegisterType((*HardState)(nil), "raftpb.HardState")
430 proto.RegisterType((*ConfState)(nil), "raftpb.ConfState")
431 proto.RegisterType((*ConfChange)(nil), "raftpb.ConfChange")
432 proto.RegisterType((*ConfChangeSingle)(nil), "raftpb.ConfChangeSingle")
433 proto.RegisterType((*ConfChangeV2)(nil), "raftpb.ConfChangeV2")
434 proto.RegisterEnum("raftpb.EntryType", EntryType_name, EntryType_value)
435 proto.RegisterEnum("raftpb.MessageType", MessageType_name, MessageType_value)
436 proto.RegisterEnum("raftpb.ConfChangeTransition", ConfChangeTransition_name, ConfChangeTransition_value)
437 proto.RegisterEnum("raftpb.ConfChangeType", ConfChangeType_name, ConfChangeType_value)
438}
439func (m *Entry) Marshal() (dAtA []byte, err error) {
440 size := m.Size()
441 dAtA = make([]byte, size)
442 n, err := m.MarshalTo(dAtA)
443 if err != nil {
444 return nil, err
445 }
446 return dAtA[:n], nil
447}
448
449func (m *Entry) MarshalTo(dAtA []byte) (int, error) {
450 var i int
451 _ = i
452 var l int
453 _ = l
454 dAtA[i] = 0x8
455 i++
456 i = encodeVarintRaft(dAtA, i, uint64(m.Type))
457 dAtA[i] = 0x10
458 i++
459 i = encodeVarintRaft(dAtA, i, uint64(m.Term))
460 dAtA[i] = 0x18
461 i++
462 i = encodeVarintRaft(dAtA, i, uint64(m.Index))
463 if m.Data != nil {
464 dAtA[i] = 0x22
465 i++
466 i = encodeVarintRaft(dAtA, i, uint64(len(m.Data)))
467 i += copy(dAtA[i:], m.Data)
468 }
469 if m.XXX_unrecognized != nil {
470 i += copy(dAtA[i:], m.XXX_unrecognized)
471 }
472 return i, nil
473}
474
475func (m *SnapshotMetadata) Marshal() (dAtA []byte, err error) {
476 size := m.Size()
477 dAtA = make([]byte, size)
478 n, err := m.MarshalTo(dAtA)
479 if err != nil {
480 return nil, err
481 }
482 return dAtA[:n], nil
483}
484
485func (m *SnapshotMetadata) MarshalTo(dAtA []byte) (int, error) {
486 var i int
487 _ = i
488 var l int
489 _ = l
490 dAtA[i] = 0xa
491 i++
492 i = encodeVarintRaft(dAtA, i, uint64(m.ConfState.Size()))
493 n1, err := m.ConfState.MarshalTo(dAtA[i:])
494 if err != nil {
495 return 0, err
496 }
497 i += n1
498 dAtA[i] = 0x10
499 i++
500 i = encodeVarintRaft(dAtA, i, uint64(m.Index))
501 dAtA[i] = 0x18
502 i++
503 i = encodeVarintRaft(dAtA, i, uint64(m.Term))
504 if m.XXX_unrecognized != nil {
505 i += copy(dAtA[i:], m.XXX_unrecognized)
506 }
507 return i, nil
508}
509
510func (m *Snapshot) Marshal() (dAtA []byte, err error) {
511 size := m.Size()
512 dAtA = make([]byte, size)
513 n, err := m.MarshalTo(dAtA)
514 if err != nil {
515 return nil, err
516 }
517 return dAtA[:n], nil
518}
519
520func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) {
521 var i int
522 _ = i
523 var l int
524 _ = l
525 if m.Data != nil {
526 dAtA[i] = 0xa
527 i++
528 i = encodeVarintRaft(dAtA, i, uint64(len(m.Data)))
529 i += copy(dAtA[i:], m.Data)
530 }
531 dAtA[i] = 0x12
532 i++
533 i = encodeVarintRaft(dAtA, i, uint64(m.Metadata.Size()))
534 n2, err := m.Metadata.MarshalTo(dAtA[i:])
535 if err != nil {
536 return 0, err
537 }
538 i += n2
539 if m.XXX_unrecognized != nil {
540 i += copy(dAtA[i:], m.XXX_unrecognized)
541 }
542 return i, nil
543}
544
545func (m *Message) Marshal() (dAtA []byte, err error) {
546 size := m.Size()
547 dAtA = make([]byte, size)
548 n, err := m.MarshalTo(dAtA)
549 if err != nil {
550 return nil, err
551 }
552 return dAtA[:n], nil
553}
554
555func (m *Message) MarshalTo(dAtA []byte) (int, error) {
556 var i int
557 _ = i
558 var l int
559 _ = l
560 dAtA[i] = 0x8
561 i++
562 i = encodeVarintRaft(dAtA, i, uint64(m.Type))
563 dAtA[i] = 0x10
564 i++
565 i = encodeVarintRaft(dAtA, i, uint64(m.To))
566 dAtA[i] = 0x18
567 i++
568 i = encodeVarintRaft(dAtA, i, uint64(m.From))
569 dAtA[i] = 0x20
570 i++
571 i = encodeVarintRaft(dAtA, i, uint64(m.Term))
572 dAtA[i] = 0x28
573 i++
574 i = encodeVarintRaft(dAtA, i, uint64(m.LogTerm))
575 dAtA[i] = 0x30
576 i++
577 i = encodeVarintRaft(dAtA, i, uint64(m.Index))
578 if len(m.Entries) > 0 {
579 for _, msg := range m.Entries {
580 dAtA[i] = 0x3a
581 i++
582 i = encodeVarintRaft(dAtA, i, uint64(msg.Size()))
583 n, err := msg.MarshalTo(dAtA[i:])
584 if err != nil {
585 return 0, err
586 }
587 i += n
588 }
589 }
590 dAtA[i] = 0x40
591 i++
592 i = encodeVarintRaft(dAtA, i, uint64(m.Commit))
593 dAtA[i] = 0x4a
594 i++
595 i = encodeVarintRaft(dAtA, i, uint64(m.Snapshot.Size()))
596 n3, err := m.Snapshot.MarshalTo(dAtA[i:])
597 if err != nil {
598 return 0, err
599 }
600 i += n3
601 dAtA[i] = 0x50
602 i++
603 if m.Reject {
604 dAtA[i] = 1
605 } else {
606 dAtA[i] = 0
607 }
608 i++
609 dAtA[i] = 0x58
610 i++
611 i = encodeVarintRaft(dAtA, i, uint64(m.RejectHint))
612 if m.Context != nil {
613 dAtA[i] = 0x62
614 i++
615 i = encodeVarintRaft(dAtA, i, uint64(len(m.Context)))
616 i += copy(dAtA[i:], m.Context)
617 }
618 if m.XXX_unrecognized != nil {
619 i += copy(dAtA[i:], m.XXX_unrecognized)
620 }
621 return i, nil
622}
623
624func (m *HardState) Marshal() (dAtA []byte, err error) {
625 size := m.Size()
626 dAtA = make([]byte, size)
627 n, err := m.MarshalTo(dAtA)
628 if err != nil {
629 return nil, err
630 }
631 return dAtA[:n], nil
632}
633
634func (m *HardState) MarshalTo(dAtA []byte) (int, error) {
635 var i int
636 _ = i
637 var l int
638 _ = l
639 dAtA[i] = 0x8
640 i++
641 i = encodeVarintRaft(dAtA, i, uint64(m.Term))
642 dAtA[i] = 0x10
643 i++
644 i = encodeVarintRaft(dAtA, i, uint64(m.Vote))
645 dAtA[i] = 0x18
646 i++
647 i = encodeVarintRaft(dAtA, i, uint64(m.Commit))
648 if m.XXX_unrecognized != nil {
649 i += copy(dAtA[i:], m.XXX_unrecognized)
650 }
651 return i, nil
652}
653
654func (m *ConfState) Marshal() (dAtA []byte, err error) {
655 size := m.Size()
656 dAtA = make([]byte, size)
657 n, err := m.MarshalTo(dAtA)
658 if err != nil {
659 return nil, err
660 }
661 return dAtA[:n], nil
662}
663
664func (m *ConfState) MarshalTo(dAtA []byte) (int, error) {
665 var i int
666 _ = i
667 var l int
668 _ = l
669 if len(m.Voters) > 0 {
670 for _, num := range m.Voters {
671 dAtA[i] = 0x8
672 i++
673 i = encodeVarintRaft(dAtA, i, uint64(num))
674 }
675 }
676 if len(m.Learners) > 0 {
677 for _, num := range m.Learners {
678 dAtA[i] = 0x10
679 i++
680 i = encodeVarintRaft(dAtA, i, uint64(num))
681 }
682 }
683 if len(m.VotersOutgoing) > 0 {
684 for _, num := range m.VotersOutgoing {
685 dAtA[i] = 0x18
686 i++
687 i = encodeVarintRaft(dAtA, i, uint64(num))
688 }
689 }
690 if len(m.LearnersNext) > 0 {
691 for _, num := range m.LearnersNext {
692 dAtA[i] = 0x20
693 i++
694 i = encodeVarintRaft(dAtA, i, uint64(num))
695 }
696 }
697 dAtA[i] = 0x28
698 i++
699 if m.AutoLeave {
700 dAtA[i] = 1
701 } else {
702 dAtA[i] = 0
703 }
704 i++
705 if m.XXX_unrecognized != nil {
706 i += copy(dAtA[i:], m.XXX_unrecognized)
707 }
708 return i, nil
709}
710
711func (m *ConfChange) Marshal() (dAtA []byte, err error) {
712 size := m.Size()
713 dAtA = make([]byte, size)
714 n, err := m.MarshalTo(dAtA)
715 if err != nil {
716 return nil, err
717 }
718 return dAtA[:n], nil
719}
720
721func (m *ConfChange) MarshalTo(dAtA []byte) (int, error) {
722 var i int
723 _ = i
724 var l int
725 _ = l
726 dAtA[i] = 0x8
727 i++
728 i = encodeVarintRaft(dAtA, i, uint64(m.ID))
729 dAtA[i] = 0x10
730 i++
731 i = encodeVarintRaft(dAtA, i, uint64(m.Type))
732 dAtA[i] = 0x18
733 i++
734 i = encodeVarintRaft(dAtA, i, uint64(m.NodeID))
735 if m.Context != nil {
736 dAtA[i] = 0x22
737 i++
738 i = encodeVarintRaft(dAtA, i, uint64(len(m.Context)))
739 i += copy(dAtA[i:], m.Context)
740 }
741 if m.XXX_unrecognized != nil {
742 i += copy(dAtA[i:], m.XXX_unrecognized)
743 }
744 return i, nil
745}
746
747func (m *ConfChangeSingle) Marshal() (dAtA []byte, err error) {
748 size := m.Size()
749 dAtA = make([]byte, size)
750 n, err := m.MarshalTo(dAtA)
751 if err != nil {
752 return nil, err
753 }
754 return dAtA[:n], nil
755}
756
757func (m *ConfChangeSingle) MarshalTo(dAtA []byte) (int, error) {
758 var i int
759 _ = i
760 var l int
761 _ = l
762 dAtA[i] = 0x8
763 i++
764 i = encodeVarintRaft(dAtA, i, uint64(m.Type))
765 dAtA[i] = 0x10
766 i++
767 i = encodeVarintRaft(dAtA, i, uint64(m.NodeID))
768 if m.XXX_unrecognized != nil {
769 i += copy(dAtA[i:], m.XXX_unrecognized)
770 }
771 return i, nil
772}
773
774func (m *ConfChangeV2) Marshal() (dAtA []byte, err error) {
775 size := m.Size()
776 dAtA = make([]byte, size)
777 n, err := m.MarshalTo(dAtA)
778 if err != nil {
779 return nil, err
780 }
781 return dAtA[:n], nil
782}
783
784func (m *ConfChangeV2) MarshalTo(dAtA []byte) (int, error) {
785 var i int
786 _ = i
787 var l int
788 _ = l
789 dAtA[i] = 0x8
790 i++
791 i = encodeVarintRaft(dAtA, i, uint64(m.Transition))
792 if len(m.Changes) > 0 {
793 for _, msg := range m.Changes {
794 dAtA[i] = 0x12
795 i++
796 i = encodeVarintRaft(dAtA, i, uint64(msg.Size()))
797 n, err := msg.MarshalTo(dAtA[i:])
798 if err != nil {
799 return 0, err
800 }
801 i += n
802 }
803 }
804 if m.Context != nil {
805 dAtA[i] = 0x1a
806 i++
807 i = encodeVarintRaft(dAtA, i, uint64(len(m.Context)))
808 i += copy(dAtA[i:], m.Context)
809 }
810 if m.XXX_unrecognized != nil {
811 i += copy(dAtA[i:], m.XXX_unrecognized)
812 }
813 return i, nil
814}
815
816func encodeVarintRaft(dAtA []byte, offset int, v uint64) int {
817 for v >= 1<<7 {
818 dAtA[offset] = uint8(v&0x7f | 0x80)
819 v >>= 7
820 offset++
821 }
822 dAtA[offset] = uint8(v)
823 return offset + 1
824}
825func (m *Entry) Size() (n int) {
826 var l int
827 _ = l
828 n += 1 + sovRaft(uint64(m.Type))
829 n += 1 + sovRaft(uint64(m.Term))
830 n += 1 + sovRaft(uint64(m.Index))
831 if m.Data != nil {
832 l = len(m.Data)
833 n += 1 + l + sovRaft(uint64(l))
834 }
835 if m.XXX_unrecognized != nil {
836 n += len(m.XXX_unrecognized)
837 }
838 return n
839}
840
841func (m *SnapshotMetadata) Size() (n int) {
842 var l int
843 _ = l
844 l = m.ConfState.Size()
845 n += 1 + l + sovRaft(uint64(l))
846 n += 1 + sovRaft(uint64(m.Index))
847 n += 1 + sovRaft(uint64(m.Term))
848 if m.XXX_unrecognized != nil {
849 n += len(m.XXX_unrecognized)
850 }
851 return n
852}
853
854func (m *Snapshot) Size() (n int) {
855 var l int
856 _ = l
857 if m.Data != nil {
858 l = len(m.Data)
859 n += 1 + l + sovRaft(uint64(l))
860 }
861 l = m.Metadata.Size()
862 n += 1 + l + sovRaft(uint64(l))
863 if m.XXX_unrecognized != nil {
864 n += len(m.XXX_unrecognized)
865 }
866 return n
867}
868
869func (m *Message) Size() (n int) {
870 var l int
871 _ = l
872 n += 1 + sovRaft(uint64(m.Type))
873 n += 1 + sovRaft(uint64(m.To))
874 n += 1 + sovRaft(uint64(m.From))
875 n += 1 + sovRaft(uint64(m.Term))
876 n += 1 + sovRaft(uint64(m.LogTerm))
877 n += 1 + sovRaft(uint64(m.Index))
878 if len(m.Entries) > 0 {
879 for _, e := range m.Entries {
880 l = e.Size()
881 n += 1 + l + sovRaft(uint64(l))
882 }
883 }
884 n += 1 + sovRaft(uint64(m.Commit))
885 l = m.Snapshot.Size()
886 n += 1 + l + sovRaft(uint64(l))
887 n += 2
888 n += 1 + sovRaft(uint64(m.RejectHint))
889 if m.Context != nil {
890 l = len(m.Context)
891 n += 1 + l + sovRaft(uint64(l))
892 }
893 if m.XXX_unrecognized != nil {
894 n += len(m.XXX_unrecognized)
895 }
896 return n
897}
898
899func (m *HardState) Size() (n int) {
900 var l int
901 _ = l
902 n += 1 + sovRaft(uint64(m.Term))
903 n += 1 + sovRaft(uint64(m.Vote))
904 n += 1 + sovRaft(uint64(m.Commit))
905 if m.XXX_unrecognized != nil {
906 n += len(m.XXX_unrecognized)
907 }
908 return n
909}
910
911func (m *ConfState) Size() (n int) {
912 var l int
913 _ = l
914 if len(m.Voters) > 0 {
915 for _, e := range m.Voters {
916 n += 1 + sovRaft(uint64(e))
917 }
918 }
919 if len(m.Learners) > 0 {
920 for _, e := range m.Learners {
921 n += 1 + sovRaft(uint64(e))
922 }
923 }
924 if len(m.VotersOutgoing) > 0 {
925 for _, e := range m.VotersOutgoing {
926 n += 1 + sovRaft(uint64(e))
927 }
928 }
929 if len(m.LearnersNext) > 0 {
930 for _, e := range m.LearnersNext {
931 n += 1 + sovRaft(uint64(e))
932 }
933 }
934 n += 2
935 if m.XXX_unrecognized != nil {
936 n += len(m.XXX_unrecognized)
937 }
938 return n
939}
940
941func (m *ConfChange) Size() (n int) {
942 var l int
943 _ = l
944 n += 1 + sovRaft(uint64(m.ID))
945 n += 1 + sovRaft(uint64(m.Type))
946 n += 1 + sovRaft(uint64(m.NodeID))
947 if m.Context != nil {
948 l = len(m.Context)
949 n += 1 + l + sovRaft(uint64(l))
950 }
951 if m.XXX_unrecognized != nil {
952 n += len(m.XXX_unrecognized)
953 }
954 return n
955}
956
957func (m *ConfChangeSingle) Size() (n int) {
958 var l int
959 _ = l
960 n += 1 + sovRaft(uint64(m.Type))
961 n += 1 + sovRaft(uint64(m.NodeID))
962 if m.XXX_unrecognized != nil {
963 n += len(m.XXX_unrecognized)
964 }
965 return n
966}
967
968func (m *ConfChangeV2) Size() (n int) {
969 var l int
970 _ = l
971 n += 1 + sovRaft(uint64(m.Transition))
972 if len(m.Changes) > 0 {
973 for _, e := range m.Changes {
974 l = e.Size()
975 n += 1 + l + sovRaft(uint64(l))
976 }
977 }
978 if m.Context != nil {
979 l = len(m.Context)
980 n += 1 + l + sovRaft(uint64(l))
981 }
982 if m.XXX_unrecognized != nil {
983 n += len(m.XXX_unrecognized)
984 }
985 return n
986}
987
988func sovRaft(x uint64) (n int) {
989 for {
990 n++
991 x >>= 7
992 if x == 0 {
993 break
994 }
995 }
996 return n
997}
998func sozRaft(x uint64) (n int) {
999 return sovRaft(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1000}
1001func (m *Entry) Unmarshal(dAtA []byte) error {
1002 l := len(dAtA)
1003 iNdEx := 0
1004 for iNdEx < l {
1005 preIndex := iNdEx
1006 var wire uint64
1007 for shift := uint(0); ; shift += 7 {
1008 if shift >= 64 {
1009 return ErrIntOverflowRaft
1010 }
1011 if iNdEx >= l {
1012 return io.ErrUnexpectedEOF
1013 }
1014 b := dAtA[iNdEx]
1015 iNdEx++
1016 wire |= (uint64(b) & 0x7F) << shift
1017 if b < 0x80 {
1018 break
1019 }
1020 }
1021 fieldNum := int32(wire >> 3)
1022 wireType := int(wire & 0x7)
1023 if wireType == 4 {
1024 return fmt.Errorf("proto: Entry: wiretype end group for non-group")
1025 }
1026 if fieldNum <= 0 {
1027 return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire)
1028 }
1029 switch fieldNum {
1030 case 1:
1031 if wireType != 0 {
1032 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
1033 }
1034 m.Type = 0
1035 for shift := uint(0); ; shift += 7 {
1036 if shift >= 64 {
1037 return ErrIntOverflowRaft
1038 }
1039 if iNdEx >= l {
1040 return io.ErrUnexpectedEOF
1041 }
1042 b := dAtA[iNdEx]
1043 iNdEx++
1044 m.Type |= (EntryType(b) & 0x7F) << shift
1045 if b < 0x80 {
1046 break
1047 }
1048 }
1049 case 2:
1050 if wireType != 0 {
1051 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
1052 }
1053 m.Term = 0
1054 for shift := uint(0); ; shift += 7 {
1055 if shift >= 64 {
1056 return ErrIntOverflowRaft
1057 }
1058 if iNdEx >= l {
1059 return io.ErrUnexpectedEOF
1060 }
1061 b := dAtA[iNdEx]
1062 iNdEx++
1063 m.Term |= (uint64(b) & 0x7F) << shift
1064 if b < 0x80 {
1065 break
1066 }
1067 }
1068 case 3:
1069 if wireType != 0 {
1070 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
1071 }
1072 m.Index = 0
1073 for shift := uint(0); ; shift += 7 {
1074 if shift >= 64 {
1075 return ErrIntOverflowRaft
1076 }
1077 if iNdEx >= l {
1078 return io.ErrUnexpectedEOF
1079 }
1080 b := dAtA[iNdEx]
1081 iNdEx++
1082 m.Index |= (uint64(b) & 0x7F) << shift
1083 if b < 0x80 {
1084 break
1085 }
1086 }
1087 case 4:
1088 if wireType != 2 {
1089 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
1090 }
1091 var byteLen int
1092 for shift := uint(0); ; shift += 7 {
1093 if shift >= 64 {
1094 return ErrIntOverflowRaft
1095 }
1096 if iNdEx >= l {
1097 return io.ErrUnexpectedEOF
1098 }
1099 b := dAtA[iNdEx]
1100 iNdEx++
1101 byteLen |= (int(b) & 0x7F) << shift
1102 if b < 0x80 {
1103 break
1104 }
1105 }
1106 if byteLen < 0 {
1107 return ErrInvalidLengthRaft
1108 }
1109 postIndex := iNdEx + byteLen
1110 if postIndex > l {
1111 return io.ErrUnexpectedEOF
1112 }
1113 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
1114 if m.Data == nil {
1115 m.Data = []byte{}
1116 }
1117 iNdEx = postIndex
1118 default:
1119 iNdEx = preIndex
1120 skippy, err := skipRaft(dAtA[iNdEx:])
1121 if err != nil {
1122 return err
1123 }
1124 if skippy < 0 {
1125 return ErrInvalidLengthRaft
1126 }
1127 if (iNdEx + skippy) > l {
1128 return io.ErrUnexpectedEOF
1129 }
1130 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1131 iNdEx += skippy
1132 }
1133 }
1134
1135 if iNdEx > l {
1136 return io.ErrUnexpectedEOF
1137 }
1138 return nil
1139}
1140func (m *SnapshotMetadata) Unmarshal(dAtA []byte) error {
1141 l := len(dAtA)
1142 iNdEx := 0
1143 for iNdEx < l {
1144 preIndex := iNdEx
1145 var wire uint64
1146 for shift := uint(0); ; shift += 7 {
1147 if shift >= 64 {
1148 return ErrIntOverflowRaft
1149 }
1150 if iNdEx >= l {
1151 return io.ErrUnexpectedEOF
1152 }
1153 b := dAtA[iNdEx]
1154 iNdEx++
1155 wire |= (uint64(b) & 0x7F) << shift
1156 if b < 0x80 {
1157 break
1158 }
1159 }
1160 fieldNum := int32(wire >> 3)
1161 wireType := int(wire & 0x7)
1162 if wireType == 4 {
1163 return fmt.Errorf("proto: SnapshotMetadata: wiretype end group for non-group")
1164 }
1165 if fieldNum <= 0 {
1166 return fmt.Errorf("proto: SnapshotMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
1167 }
1168 switch fieldNum {
1169 case 1:
1170 if wireType != 2 {
1171 return fmt.Errorf("proto: wrong wireType = %d for field ConfState", wireType)
1172 }
1173 var msglen int
1174 for shift := uint(0); ; shift += 7 {
1175 if shift >= 64 {
1176 return ErrIntOverflowRaft
1177 }
1178 if iNdEx >= l {
1179 return io.ErrUnexpectedEOF
1180 }
1181 b := dAtA[iNdEx]
1182 iNdEx++
1183 msglen |= (int(b) & 0x7F) << shift
1184 if b < 0x80 {
1185 break
1186 }
1187 }
1188 if msglen < 0 {
1189 return ErrInvalidLengthRaft
1190 }
1191 postIndex := iNdEx + msglen
1192 if postIndex > l {
1193 return io.ErrUnexpectedEOF
1194 }
1195 if err := m.ConfState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1196 return err
1197 }
1198 iNdEx = postIndex
1199 case 2:
1200 if wireType != 0 {
1201 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
1202 }
1203 m.Index = 0
1204 for shift := uint(0); ; shift += 7 {
1205 if shift >= 64 {
1206 return ErrIntOverflowRaft
1207 }
1208 if iNdEx >= l {
1209 return io.ErrUnexpectedEOF
1210 }
1211 b := dAtA[iNdEx]
1212 iNdEx++
1213 m.Index |= (uint64(b) & 0x7F) << shift
1214 if b < 0x80 {
1215 break
1216 }
1217 }
1218 case 3:
1219 if wireType != 0 {
1220 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
1221 }
1222 m.Term = 0
1223 for shift := uint(0); ; shift += 7 {
1224 if shift >= 64 {
1225 return ErrIntOverflowRaft
1226 }
1227 if iNdEx >= l {
1228 return io.ErrUnexpectedEOF
1229 }
1230 b := dAtA[iNdEx]
1231 iNdEx++
1232 m.Term |= (uint64(b) & 0x7F) << shift
1233 if b < 0x80 {
1234 break
1235 }
1236 }
1237 default:
1238 iNdEx = preIndex
1239 skippy, err := skipRaft(dAtA[iNdEx:])
1240 if err != nil {
1241 return err
1242 }
1243 if skippy < 0 {
1244 return ErrInvalidLengthRaft
1245 }
1246 if (iNdEx + skippy) > l {
1247 return io.ErrUnexpectedEOF
1248 }
1249 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1250 iNdEx += skippy
1251 }
1252 }
1253
1254 if iNdEx > l {
1255 return io.ErrUnexpectedEOF
1256 }
1257 return nil
1258}
1259func (m *Snapshot) Unmarshal(dAtA []byte) error {
1260 l := len(dAtA)
1261 iNdEx := 0
1262 for iNdEx < l {
1263 preIndex := iNdEx
1264 var wire uint64
1265 for shift := uint(0); ; shift += 7 {
1266 if shift >= 64 {
1267 return ErrIntOverflowRaft
1268 }
1269 if iNdEx >= l {
1270 return io.ErrUnexpectedEOF
1271 }
1272 b := dAtA[iNdEx]
1273 iNdEx++
1274 wire |= (uint64(b) & 0x7F) << shift
1275 if b < 0x80 {
1276 break
1277 }
1278 }
1279 fieldNum := int32(wire >> 3)
1280 wireType := int(wire & 0x7)
1281 if wireType == 4 {
1282 return fmt.Errorf("proto: Snapshot: wiretype end group for non-group")
1283 }
1284 if fieldNum <= 0 {
1285 return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire)
1286 }
1287 switch fieldNum {
1288 case 1:
1289 if wireType != 2 {
1290 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
1291 }
1292 var byteLen int
1293 for shift := uint(0); ; shift += 7 {
1294 if shift >= 64 {
1295 return ErrIntOverflowRaft
1296 }
1297 if iNdEx >= l {
1298 return io.ErrUnexpectedEOF
1299 }
1300 b := dAtA[iNdEx]
1301 iNdEx++
1302 byteLen |= (int(b) & 0x7F) << shift
1303 if b < 0x80 {
1304 break
1305 }
1306 }
1307 if byteLen < 0 {
1308 return ErrInvalidLengthRaft
1309 }
1310 postIndex := iNdEx + byteLen
1311 if postIndex > l {
1312 return io.ErrUnexpectedEOF
1313 }
1314 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
1315 if m.Data == nil {
1316 m.Data = []byte{}
1317 }
1318 iNdEx = postIndex
1319 case 2:
1320 if wireType != 2 {
1321 return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
1322 }
1323 var msglen int
1324 for shift := uint(0); ; shift += 7 {
1325 if shift >= 64 {
1326 return ErrIntOverflowRaft
1327 }
1328 if iNdEx >= l {
1329 return io.ErrUnexpectedEOF
1330 }
1331 b := dAtA[iNdEx]
1332 iNdEx++
1333 msglen |= (int(b) & 0x7F) << shift
1334 if b < 0x80 {
1335 break
1336 }
1337 }
1338 if msglen < 0 {
1339 return ErrInvalidLengthRaft
1340 }
1341 postIndex := iNdEx + msglen
1342 if postIndex > l {
1343 return io.ErrUnexpectedEOF
1344 }
1345 if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1346 return err
1347 }
1348 iNdEx = postIndex
1349 default:
1350 iNdEx = preIndex
1351 skippy, err := skipRaft(dAtA[iNdEx:])
1352 if err != nil {
1353 return err
1354 }
1355 if skippy < 0 {
1356 return ErrInvalidLengthRaft
1357 }
1358 if (iNdEx + skippy) > l {
1359 return io.ErrUnexpectedEOF
1360 }
1361 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1362 iNdEx += skippy
1363 }
1364 }
1365
1366 if iNdEx > l {
1367 return io.ErrUnexpectedEOF
1368 }
1369 return nil
1370}
1371func (m *Message) Unmarshal(dAtA []byte) error {
1372 l := len(dAtA)
1373 iNdEx := 0
1374 for iNdEx < l {
1375 preIndex := iNdEx
1376 var wire uint64
1377 for shift := uint(0); ; shift += 7 {
1378 if shift >= 64 {
1379 return ErrIntOverflowRaft
1380 }
1381 if iNdEx >= l {
1382 return io.ErrUnexpectedEOF
1383 }
1384 b := dAtA[iNdEx]
1385 iNdEx++
1386 wire |= (uint64(b) & 0x7F) << shift
1387 if b < 0x80 {
1388 break
1389 }
1390 }
1391 fieldNum := int32(wire >> 3)
1392 wireType := int(wire & 0x7)
1393 if wireType == 4 {
1394 return fmt.Errorf("proto: Message: wiretype end group for non-group")
1395 }
1396 if fieldNum <= 0 {
1397 return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
1398 }
1399 switch fieldNum {
1400 case 1:
1401 if wireType != 0 {
1402 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
1403 }
1404 m.Type = 0
1405 for shift := uint(0); ; shift += 7 {
1406 if shift >= 64 {
1407 return ErrIntOverflowRaft
1408 }
1409 if iNdEx >= l {
1410 return io.ErrUnexpectedEOF
1411 }
1412 b := dAtA[iNdEx]
1413 iNdEx++
1414 m.Type |= (MessageType(b) & 0x7F) << shift
1415 if b < 0x80 {
1416 break
1417 }
1418 }
1419 case 2:
1420 if wireType != 0 {
1421 return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
1422 }
1423 m.To = 0
1424 for shift := uint(0); ; shift += 7 {
1425 if shift >= 64 {
1426 return ErrIntOverflowRaft
1427 }
1428 if iNdEx >= l {
1429 return io.ErrUnexpectedEOF
1430 }
1431 b := dAtA[iNdEx]
1432 iNdEx++
1433 m.To |= (uint64(b) & 0x7F) << shift
1434 if b < 0x80 {
1435 break
1436 }
1437 }
1438 case 3:
1439 if wireType != 0 {
1440 return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
1441 }
1442 m.From = 0
1443 for shift := uint(0); ; shift += 7 {
1444 if shift >= 64 {
1445 return ErrIntOverflowRaft
1446 }
1447 if iNdEx >= l {
1448 return io.ErrUnexpectedEOF
1449 }
1450 b := dAtA[iNdEx]
1451 iNdEx++
1452 m.From |= (uint64(b) & 0x7F) << shift
1453 if b < 0x80 {
1454 break
1455 }
1456 }
1457 case 4:
1458 if wireType != 0 {
1459 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
1460 }
1461 m.Term = 0
1462 for shift := uint(0); ; shift += 7 {
1463 if shift >= 64 {
1464 return ErrIntOverflowRaft
1465 }
1466 if iNdEx >= l {
1467 return io.ErrUnexpectedEOF
1468 }
1469 b := dAtA[iNdEx]
1470 iNdEx++
1471 m.Term |= (uint64(b) & 0x7F) << shift
1472 if b < 0x80 {
1473 break
1474 }
1475 }
1476 case 5:
1477 if wireType != 0 {
1478 return fmt.Errorf("proto: wrong wireType = %d for field LogTerm", wireType)
1479 }
1480 m.LogTerm = 0
1481 for shift := uint(0); ; shift += 7 {
1482 if shift >= 64 {
1483 return ErrIntOverflowRaft
1484 }
1485 if iNdEx >= l {
1486 return io.ErrUnexpectedEOF
1487 }
1488 b := dAtA[iNdEx]
1489 iNdEx++
1490 m.LogTerm |= (uint64(b) & 0x7F) << shift
1491 if b < 0x80 {
1492 break
1493 }
1494 }
1495 case 6:
1496 if wireType != 0 {
1497 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
1498 }
1499 m.Index = 0
1500 for shift := uint(0); ; shift += 7 {
1501 if shift >= 64 {
1502 return ErrIntOverflowRaft
1503 }
1504 if iNdEx >= l {
1505 return io.ErrUnexpectedEOF
1506 }
1507 b := dAtA[iNdEx]
1508 iNdEx++
1509 m.Index |= (uint64(b) & 0x7F) << shift
1510 if b < 0x80 {
1511 break
1512 }
1513 }
1514 case 7:
1515 if wireType != 2 {
1516 return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
1517 }
1518 var msglen int
1519 for shift := uint(0); ; shift += 7 {
1520 if shift >= 64 {
1521 return ErrIntOverflowRaft
1522 }
1523 if iNdEx >= l {
1524 return io.ErrUnexpectedEOF
1525 }
1526 b := dAtA[iNdEx]
1527 iNdEx++
1528 msglen |= (int(b) & 0x7F) << shift
1529 if b < 0x80 {
1530 break
1531 }
1532 }
1533 if msglen < 0 {
1534 return ErrInvalidLengthRaft
1535 }
1536 postIndex := iNdEx + msglen
1537 if postIndex > l {
1538 return io.ErrUnexpectedEOF
1539 }
1540 m.Entries = append(m.Entries, Entry{})
1541 if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1542 return err
1543 }
1544 iNdEx = postIndex
1545 case 8:
1546 if wireType != 0 {
1547 return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
1548 }
1549 m.Commit = 0
1550 for shift := uint(0); ; shift += 7 {
1551 if shift >= 64 {
1552 return ErrIntOverflowRaft
1553 }
1554 if iNdEx >= l {
1555 return io.ErrUnexpectedEOF
1556 }
1557 b := dAtA[iNdEx]
1558 iNdEx++
1559 m.Commit |= (uint64(b) & 0x7F) << shift
1560 if b < 0x80 {
1561 break
1562 }
1563 }
1564 case 9:
1565 if wireType != 2 {
1566 return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
1567 }
1568 var msglen int
1569 for shift := uint(0); ; shift += 7 {
1570 if shift >= 64 {
1571 return ErrIntOverflowRaft
1572 }
1573 if iNdEx >= l {
1574 return io.ErrUnexpectedEOF
1575 }
1576 b := dAtA[iNdEx]
1577 iNdEx++
1578 msglen |= (int(b) & 0x7F) << shift
1579 if b < 0x80 {
1580 break
1581 }
1582 }
1583 if msglen < 0 {
1584 return ErrInvalidLengthRaft
1585 }
1586 postIndex := iNdEx + msglen
1587 if postIndex > l {
1588 return io.ErrUnexpectedEOF
1589 }
1590 if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1591 return err
1592 }
1593 iNdEx = postIndex
1594 case 10:
1595 if wireType != 0 {
1596 return fmt.Errorf("proto: wrong wireType = %d for field Reject", wireType)
1597 }
1598 var v int
1599 for shift := uint(0); ; shift += 7 {
1600 if shift >= 64 {
1601 return ErrIntOverflowRaft
1602 }
1603 if iNdEx >= l {
1604 return io.ErrUnexpectedEOF
1605 }
1606 b := dAtA[iNdEx]
1607 iNdEx++
1608 v |= (int(b) & 0x7F) << shift
1609 if b < 0x80 {
1610 break
1611 }
1612 }
1613 m.Reject = bool(v != 0)
1614 case 11:
1615 if wireType != 0 {
1616 return fmt.Errorf("proto: wrong wireType = %d for field RejectHint", wireType)
1617 }
1618 m.RejectHint = 0
1619 for shift := uint(0); ; shift += 7 {
1620 if shift >= 64 {
1621 return ErrIntOverflowRaft
1622 }
1623 if iNdEx >= l {
1624 return io.ErrUnexpectedEOF
1625 }
1626 b := dAtA[iNdEx]
1627 iNdEx++
1628 m.RejectHint |= (uint64(b) & 0x7F) << shift
1629 if b < 0x80 {
1630 break
1631 }
1632 }
1633 case 12:
1634 if wireType != 2 {
1635 return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
1636 }
1637 var byteLen int
1638 for shift := uint(0); ; shift += 7 {
1639 if shift >= 64 {
1640 return ErrIntOverflowRaft
1641 }
1642 if iNdEx >= l {
1643 return io.ErrUnexpectedEOF
1644 }
1645 b := dAtA[iNdEx]
1646 iNdEx++
1647 byteLen |= (int(b) & 0x7F) << shift
1648 if b < 0x80 {
1649 break
1650 }
1651 }
1652 if byteLen < 0 {
1653 return ErrInvalidLengthRaft
1654 }
1655 postIndex := iNdEx + byteLen
1656 if postIndex > l {
1657 return io.ErrUnexpectedEOF
1658 }
1659 m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...)
1660 if m.Context == nil {
1661 m.Context = []byte{}
1662 }
1663 iNdEx = postIndex
1664 default:
1665 iNdEx = preIndex
1666 skippy, err := skipRaft(dAtA[iNdEx:])
1667 if err != nil {
1668 return err
1669 }
1670 if skippy < 0 {
1671 return ErrInvalidLengthRaft
1672 }
1673 if (iNdEx + skippy) > l {
1674 return io.ErrUnexpectedEOF
1675 }
1676 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1677 iNdEx += skippy
1678 }
1679 }
1680
1681 if iNdEx > l {
1682 return io.ErrUnexpectedEOF
1683 }
1684 return nil
1685}
1686func (m *HardState) Unmarshal(dAtA []byte) error {
1687 l := len(dAtA)
1688 iNdEx := 0
1689 for iNdEx < l {
1690 preIndex := iNdEx
1691 var wire uint64
1692 for shift := uint(0); ; shift += 7 {
1693 if shift >= 64 {
1694 return ErrIntOverflowRaft
1695 }
1696 if iNdEx >= l {
1697 return io.ErrUnexpectedEOF
1698 }
1699 b := dAtA[iNdEx]
1700 iNdEx++
1701 wire |= (uint64(b) & 0x7F) << shift
1702 if b < 0x80 {
1703 break
1704 }
1705 }
1706 fieldNum := int32(wire >> 3)
1707 wireType := int(wire & 0x7)
1708 if wireType == 4 {
1709 return fmt.Errorf("proto: HardState: wiretype end group for non-group")
1710 }
1711 if fieldNum <= 0 {
1712 return fmt.Errorf("proto: HardState: illegal tag %d (wire type %d)", fieldNum, wire)
1713 }
1714 switch fieldNum {
1715 case 1:
1716 if wireType != 0 {
1717 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
1718 }
1719 m.Term = 0
1720 for shift := uint(0); ; shift += 7 {
1721 if shift >= 64 {
1722 return ErrIntOverflowRaft
1723 }
1724 if iNdEx >= l {
1725 return io.ErrUnexpectedEOF
1726 }
1727 b := dAtA[iNdEx]
1728 iNdEx++
1729 m.Term |= (uint64(b) & 0x7F) << shift
1730 if b < 0x80 {
1731 break
1732 }
1733 }
1734 case 2:
1735 if wireType != 0 {
1736 return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType)
1737 }
1738 m.Vote = 0
1739 for shift := uint(0); ; shift += 7 {
1740 if shift >= 64 {
1741 return ErrIntOverflowRaft
1742 }
1743 if iNdEx >= l {
1744 return io.ErrUnexpectedEOF
1745 }
1746 b := dAtA[iNdEx]
1747 iNdEx++
1748 m.Vote |= (uint64(b) & 0x7F) << shift
1749 if b < 0x80 {
1750 break
1751 }
1752 }
1753 case 3:
1754 if wireType != 0 {
1755 return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
1756 }
1757 m.Commit = 0
1758 for shift := uint(0); ; shift += 7 {
1759 if shift >= 64 {
1760 return ErrIntOverflowRaft
1761 }
1762 if iNdEx >= l {
1763 return io.ErrUnexpectedEOF
1764 }
1765 b := dAtA[iNdEx]
1766 iNdEx++
1767 m.Commit |= (uint64(b) & 0x7F) << shift
1768 if b < 0x80 {
1769 break
1770 }
1771 }
1772 default:
1773 iNdEx = preIndex
1774 skippy, err := skipRaft(dAtA[iNdEx:])
1775 if err != nil {
1776 return err
1777 }
1778 if skippy < 0 {
1779 return ErrInvalidLengthRaft
1780 }
1781 if (iNdEx + skippy) > l {
1782 return io.ErrUnexpectedEOF
1783 }
1784 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1785 iNdEx += skippy
1786 }
1787 }
1788
1789 if iNdEx > l {
1790 return io.ErrUnexpectedEOF
1791 }
1792 return nil
1793}
1794func (m *ConfState) Unmarshal(dAtA []byte) error {
1795 l := len(dAtA)
1796 iNdEx := 0
1797 for iNdEx < l {
1798 preIndex := iNdEx
1799 var wire uint64
1800 for shift := uint(0); ; shift += 7 {
1801 if shift >= 64 {
1802 return ErrIntOverflowRaft
1803 }
1804 if iNdEx >= l {
1805 return io.ErrUnexpectedEOF
1806 }
1807 b := dAtA[iNdEx]
1808 iNdEx++
1809 wire |= (uint64(b) & 0x7F) << shift
1810 if b < 0x80 {
1811 break
1812 }
1813 }
1814 fieldNum := int32(wire >> 3)
1815 wireType := int(wire & 0x7)
1816 if wireType == 4 {
1817 return fmt.Errorf("proto: ConfState: wiretype end group for non-group")
1818 }
1819 if fieldNum <= 0 {
1820 return fmt.Errorf("proto: ConfState: illegal tag %d (wire type %d)", fieldNum, wire)
1821 }
1822 switch fieldNum {
1823 case 1:
1824 if wireType == 0 {
1825 var v uint64
1826 for shift := uint(0); ; shift += 7 {
1827 if shift >= 64 {
1828 return ErrIntOverflowRaft
1829 }
1830 if iNdEx >= l {
1831 return io.ErrUnexpectedEOF
1832 }
1833 b := dAtA[iNdEx]
1834 iNdEx++
1835 v |= (uint64(b) & 0x7F) << shift
1836 if b < 0x80 {
1837 break
1838 }
1839 }
1840 m.Voters = append(m.Voters, v)
1841 } else if wireType == 2 {
1842 var packedLen int
1843 for shift := uint(0); ; shift += 7 {
1844 if shift >= 64 {
1845 return ErrIntOverflowRaft
1846 }
1847 if iNdEx >= l {
1848 return io.ErrUnexpectedEOF
1849 }
1850 b := dAtA[iNdEx]
1851 iNdEx++
1852 packedLen |= (int(b) & 0x7F) << shift
1853 if b < 0x80 {
1854 break
1855 }
1856 }
1857 if packedLen < 0 {
1858 return ErrInvalidLengthRaft
1859 }
1860 postIndex := iNdEx + packedLen
1861 if postIndex > l {
1862 return io.ErrUnexpectedEOF
1863 }
1864 for iNdEx < postIndex {
1865 var v uint64
1866 for shift := uint(0); ; shift += 7 {
1867 if shift >= 64 {
1868 return ErrIntOverflowRaft
1869 }
1870 if iNdEx >= l {
1871 return io.ErrUnexpectedEOF
1872 }
1873 b := dAtA[iNdEx]
1874 iNdEx++
1875 v |= (uint64(b) & 0x7F) << shift
1876 if b < 0x80 {
1877 break
1878 }
1879 }
1880 m.Voters = append(m.Voters, v)
1881 }
1882 } else {
1883 return fmt.Errorf("proto: wrong wireType = %d for field Voters", wireType)
1884 }
1885 case 2:
1886 if wireType == 0 {
1887 var v uint64
1888 for shift := uint(0); ; shift += 7 {
1889 if shift >= 64 {
1890 return ErrIntOverflowRaft
1891 }
1892 if iNdEx >= l {
1893 return io.ErrUnexpectedEOF
1894 }
1895 b := dAtA[iNdEx]
1896 iNdEx++
1897 v |= (uint64(b) & 0x7F) << shift
1898 if b < 0x80 {
1899 break
1900 }
1901 }
1902 m.Learners = append(m.Learners, v)
1903 } else if wireType == 2 {
1904 var packedLen int
1905 for shift := uint(0); ; shift += 7 {
1906 if shift >= 64 {
1907 return ErrIntOverflowRaft
1908 }
1909 if iNdEx >= l {
1910 return io.ErrUnexpectedEOF
1911 }
1912 b := dAtA[iNdEx]
1913 iNdEx++
1914 packedLen |= (int(b) & 0x7F) << shift
1915 if b < 0x80 {
1916 break
1917 }
1918 }
1919 if packedLen < 0 {
1920 return ErrInvalidLengthRaft
1921 }
1922 postIndex := iNdEx + packedLen
1923 if postIndex > l {
1924 return io.ErrUnexpectedEOF
1925 }
1926 for iNdEx < postIndex {
1927 var v uint64
1928 for shift := uint(0); ; shift += 7 {
1929 if shift >= 64 {
1930 return ErrIntOverflowRaft
1931 }
1932 if iNdEx >= l {
1933 return io.ErrUnexpectedEOF
1934 }
1935 b := dAtA[iNdEx]
1936 iNdEx++
1937 v |= (uint64(b) & 0x7F) << shift
1938 if b < 0x80 {
1939 break
1940 }
1941 }
1942 m.Learners = append(m.Learners, v)
1943 }
1944 } else {
1945 return fmt.Errorf("proto: wrong wireType = %d for field Learners", wireType)
1946 }
1947 case 3:
1948 if wireType == 0 {
1949 var v uint64
1950 for shift := uint(0); ; shift += 7 {
1951 if shift >= 64 {
1952 return ErrIntOverflowRaft
1953 }
1954 if iNdEx >= l {
1955 return io.ErrUnexpectedEOF
1956 }
1957 b := dAtA[iNdEx]
1958 iNdEx++
1959 v |= (uint64(b) & 0x7F) << shift
1960 if b < 0x80 {
1961 break
1962 }
1963 }
1964 m.VotersOutgoing = append(m.VotersOutgoing, v)
1965 } else if wireType == 2 {
1966 var packedLen int
1967 for shift := uint(0); ; shift += 7 {
1968 if shift >= 64 {
1969 return ErrIntOverflowRaft
1970 }
1971 if iNdEx >= l {
1972 return io.ErrUnexpectedEOF
1973 }
1974 b := dAtA[iNdEx]
1975 iNdEx++
1976 packedLen |= (int(b) & 0x7F) << shift
1977 if b < 0x80 {
1978 break
1979 }
1980 }
1981 if packedLen < 0 {
1982 return ErrInvalidLengthRaft
1983 }
1984 postIndex := iNdEx + packedLen
1985 if postIndex > l {
1986 return io.ErrUnexpectedEOF
1987 }
1988 for iNdEx < postIndex {
1989 var v uint64
1990 for shift := uint(0); ; shift += 7 {
1991 if shift >= 64 {
1992 return ErrIntOverflowRaft
1993 }
1994 if iNdEx >= l {
1995 return io.ErrUnexpectedEOF
1996 }
1997 b := dAtA[iNdEx]
1998 iNdEx++
1999 v |= (uint64(b) & 0x7F) << shift
2000 if b < 0x80 {
2001 break
2002 }
2003 }
2004 m.VotersOutgoing = append(m.VotersOutgoing, v)
2005 }
2006 } else {
2007 return fmt.Errorf("proto: wrong wireType = %d for field VotersOutgoing", wireType)
2008 }
2009 case 4:
2010 if wireType == 0 {
2011 var v uint64
2012 for shift := uint(0); ; shift += 7 {
2013 if shift >= 64 {
2014 return ErrIntOverflowRaft
2015 }
2016 if iNdEx >= l {
2017 return io.ErrUnexpectedEOF
2018 }
2019 b := dAtA[iNdEx]
2020 iNdEx++
2021 v |= (uint64(b) & 0x7F) << shift
2022 if b < 0x80 {
2023 break
2024 }
2025 }
2026 m.LearnersNext = append(m.LearnersNext, v)
2027 } else if wireType == 2 {
2028 var packedLen int
2029 for shift := uint(0); ; shift += 7 {
2030 if shift >= 64 {
2031 return ErrIntOverflowRaft
2032 }
2033 if iNdEx >= l {
2034 return io.ErrUnexpectedEOF
2035 }
2036 b := dAtA[iNdEx]
2037 iNdEx++
2038 packedLen |= (int(b) & 0x7F) << shift
2039 if b < 0x80 {
2040 break
2041 }
2042 }
2043 if packedLen < 0 {
2044 return ErrInvalidLengthRaft
2045 }
2046 postIndex := iNdEx + packedLen
2047 if postIndex > l {
2048 return io.ErrUnexpectedEOF
2049 }
2050 for iNdEx < postIndex {
2051 var v uint64
2052 for shift := uint(0); ; shift += 7 {
2053 if shift >= 64 {
2054 return ErrIntOverflowRaft
2055 }
2056 if iNdEx >= l {
2057 return io.ErrUnexpectedEOF
2058 }
2059 b := dAtA[iNdEx]
2060 iNdEx++
2061 v |= (uint64(b) & 0x7F) << shift
2062 if b < 0x80 {
2063 break
2064 }
2065 }
2066 m.LearnersNext = append(m.LearnersNext, v)
2067 }
2068 } else {
2069 return fmt.Errorf("proto: wrong wireType = %d for field LearnersNext", wireType)
2070 }
2071 case 5:
2072 if wireType != 0 {
2073 return fmt.Errorf("proto: wrong wireType = %d for field AutoLeave", wireType)
2074 }
2075 var v int
2076 for shift := uint(0); ; shift += 7 {
2077 if shift >= 64 {
2078 return ErrIntOverflowRaft
2079 }
2080 if iNdEx >= l {
2081 return io.ErrUnexpectedEOF
2082 }
2083 b := dAtA[iNdEx]
2084 iNdEx++
2085 v |= (int(b) & 0x7F) << shift
2086 if b < 0x80 {
2087 break
2088 }
2089 }
2090 m.AutoLeave = bool(v != 0)
2091 default:
2092 iNdEx = preIndex
2093 skippy, err := skipRaft(dAtA[iNdEx:])
2094 if err != nil {
2095 return err
2096 }
2097 if skippy < 0 {
2098 return ErrInvalidLengthRaft
2099 }
2100 if (iNdEx + skippy) > l {
2101 return io.ErrUnexpectedEOF
2102 }
2103 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2104 iNdEx += skippy
2105 }
2106 }
2107
2108 if iNdEx > l {
2109 return io.ErrUnexpectedEOF
2110 }
2111 return nil
2112}
2113func (m *ConfChange) Unmarshal(dAtA []byte) error {
2114 l := len(dAtA)
2115 iNdEx := 0
2116 for iNdEx < l {
2117 preIndex := iNdEx
2118 var wire uint64
2119 for shift := uint(0); ; shift += 7 {
2120 if shift >= 64 {
2121 return ErrIntOverflowRaft
2122 }
2123 if iNdEx >= l {
2124 return io.ErrUnexpectedEOF
2125 }
2126 b := dAtA[iNdEx]
2127 iNdEx++
2128 wire |= (uint64(b) & 0x7F) << shift
2129 if b < 0x80 {
2130 break
2131 }
2132 }
2133 fieldNum := int32(wire >> 3)
2134 wireType := int(wire & 0x7)
2135 if wireType == 4 {
2136 return fmt.Errorf("proto: ConfChange: wiretype end group for non-group")
2137 }
2138 if fieldNum <= 0 {
2139 return fmt.Errorf("proto: ConfChange: illegal tag %d (wire type %d)", fieldNum, wire)
2140 }
2141 switch fieldNum {
2142 case 1:
2143 if wireType != 0 {
2144 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
2145 }
2146 m.ID = 0
2147 for shift := uint(0); ; shift += 7 {
2148 if shift >= 64 {
2149 return ErrIntOverflowRaft
2150 }
2151 if iNdEx >= l {
2152 return io.ErrUnexpectedEOF
2153 }
2154 b := dAtA[iNdEx]
2155 iNdEx++
2156 m.ID |= (uint64(b) & 0x7F) << shift
2157 if b < 0x80 {
2158 break
2159 }
2160 }
2161 case 2:
2162 if wireType != 0 {
2163 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2164 }
2165 m.Type = 0
2166 for shift := uint(0); ; shift += 7 {
2167 if shift >= 64 {
2168 return ErrIntOverflowRaft
2169 }
2170 if iNdEx >= l {
2171 return io.ErrUnexpectedEOF
2172 }
2173 b := dAtA[iNdEx]
2174 iNdEx++
2175 m.Type |= (ConfChangeType(b) & 0x7F) << shift
2176 if b < 0x80 {
2177 break
2178 }
2179 }
2180 case 3:
2181 if wireType != 0 {
2182 return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
2183 }
2184 m.NodeID = 0
2185 for shift := uint(0); ; shift += 7 {
2186 if shift >= 64 {
2187 return ErrIntOverflowRaft
2188 }
2189 if iNdEx >= l {
2190 return io.ErrUnexpectedEOF
2191 }
2192 b := dAtA[iNdEx]
2193 iNdEx++
2194 m.NodeID |= (uint64(b) & 0x7F) << shift
2195 if b < 0x80 {
2196 break
2197 }
2198 }
2199 case 4:
2200 if wireType != 2 {
2201 return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
2202 }
2203 var byteLen int
2204 for shift := uint(0); ; shift += 7 {
2205 if shift >= 64 {
2206 return ErrIntOverflowRaft
2207 }
2208 if iNdEx >= l {
2209 return io.ErrUnexpectedEOF
2210 }
2211 b := dAtA[iNdEx]
2212 iNdEx++
2213 byteLen |= (int(b) & 0x7F) << shift
2214 if b < 0x80 {
2215 break
2216 }
2217 }
2218 if byteLen < 0 {
2219 return ErrInvalidLengthRaft
2220 }
2221 postIndex := iNdEx + byteLen
2222 if postIndex > l {
2223 return io.ErrUnexpectedEOF
2224 }
2225 m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...)
2226 if m.Context == nil {
2227 m.Context = []byte{}
2228 }
2229 iNdEx = postIndex
2230 default:
2231 iNdEx = preIndex
2232 skippy, err := skipRaft(dAtA[iNdEx:])
2233 if err != nil {
2234 return err
2235 }
2236 if skippy < 0 {
2237 return ErrInvalidLengthRaft
2238 }
2239 if (iNdEx + skippy) > l {
2240 return io.ErrUnexpectedEOF
2241 }
2242 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2243 iNdEx += skippy
2244 }
2245 }
2246
2247 if iNdEx > l {
2248 return io.ErrUnexpectedEOF
2249 }
2250 return nil
2251}
2252func (m *ConfChangeSingle) Unmarshal(dAtA []byte) error {
2253 l := len(dAtA)
2254 iNdEx := 0
2255 for iNdEx < l {
2256 preIndex := iNdEx
2257 var wire uint64
2258 for shift := uint(0); ; shift += 7 {
2259 if shift >= 64 {
2260 return ErrIntOverflowRaft
2261 }
2262 if iNdEx >= l {
2263 return io.ErrUnexpectedEOF
2264 }
2265 b := dAtA[iNdEx]
2266 iNdEx++
2267 wire |= (uint64(b) & 0x7F) << shift
2268 if b < 0x80 {
2269 break
2270 }
2271 }
2272 fieldNum := int32(wire >> 3)
2273 wireType := int(wire & 0x7)
2274 if wireType == 4 {
2275 return fmt.Errorf("proto: ConfChangeSingle: wiretype end group for non-group")
2276 }
2277 if fieldNum <= 0 {
2278 return fmt.Errorf("proto: ConfChangeSingle: illegal tag %d (wire type %d)", fieldNum, wire)
2279 }
2280 switch fieldNum {
2281 case 1:
2282 if wireType != 0 {
2283 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2284 }
2285 m.Type = 0
2286 for shift := uint(0); ; shift += 7 {
2287 if shift >= 64 {
2288 return ErrIntOverflowRaft
2289 }
2290 if iNdEx >= l {
2291 return io.ErrUnexpectedEOF
2292 }
2293 b := dAtA[iNdEx]
2294 iNdEx++
2295 m.Type |= (ConfChangeType(b) & 0x7F) << shift
2296 if b < 0x80 {
2297 break
2298 }
2299 }
2300 case 2:
2301 if wireType != 0 {
2302 return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
2303 }
2304 m.NodeID = 0
2305 for shift := uint(0); ; shift += 7 {
2306 if shift >= 64 {
2307 return ErrIntOverflowRaft
2308 }
2309 if iNdEx >= l {
2310 return io.ErrUnexpectedEOF
2311 }
2312 b := dAtA[iNdEx]
2313 iNdEx++
2314 m.NodeID |= (uint64(b) & 0x7F) << shift
2315 if b < 0x80 {
2316 break
2317 }
2318 }
2319 default:
2320 iNdEx = preIndex
2321 skippy, err := skipRaft(dAtA[iNdEx:])
2322 if err != nil {
2323 return err
2324 }
2325 if skippy < 0 {
2326 return ErrInvalidLengthRaft
2327 }
2328 if (iNdEx + skippy) > l {
2329 return io.ErrUnexpectedEOF
2330 }
2331 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2332 iNdEx += skippy
2333 }
2334 }
2335
2336 if iNdEx > l {
2337 return io.ErrUnexpectedEOF
2338 }
2339 return nil
2340}
2341func (m *ConfChangeV2) Unmarshal(dAtA []byte) error {
2342 l := len(dAtA)
2343 iNdEx := 0
2344 for iNdEx < l {
2345 preIndex := iNdEx
2346 var wire uint64
2347 for shift := uint(0); ; shift += 7 {
2348 if shift >= 64 {
2349 return ErrIntOverflowRaft
2350 }
2351 if iNdEx >= l {
2352 return io.ErrUnexpectedEOF
2353 }
2354 b := dAtA[iNdEx]
2355 iNdEx++
2356 wire |= (uint64(b) & 0x7F) << shift
2357 if b < 0x80 {
2358 break
2359 }
2360 }
2361 fieldNum := int32(wire >> 3)
2362 wireType := int(wire & 0x7)
2363 if wireType == 4 {
2364 return fmt.Errorf("proto: ConfChangeV2: wiretype end group for non-group")
2365 }
2366 if fieldNum <= 0 {
2367 return fmt.Errorf("proto: ConfChangeV2: illegal tag %d (wire type %d)", fieldNum, wire)
2368 }
2369 switch fieldNum {
2370 case 1:
2371 if wireType != 0 {
2372 return fmt.Errorf("proto: wrong wireType = %d for field Transition", wireType)
2373 }
2374 m.Transition = 0
2375 for shift := uint(0); ; shift += 7 {
2376 if shift >= 64 {
2377 return ErrIntOverflowRaft
2378 }
2379 if iNdEx >= l {
2380 return io.ErrUnexpectedEOF
2381 }
2382 b := dAtA[iNdEx]
2383 iNdEx++
2384 m.Transition |= (ConfChangeTransition(b) & 0x7F) << shift
2385 if b < 0x80 {
2386 break
2387 }
2388 }
2389 case 2:
2390 if wireType != 2 {
2391 return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
2392 }
2393 var msglen int
2394 for shift := uint(0); ; shift += 7 {
2395 if shift >= 64 {
2396 return ErrIntOverflowRaft
2397 }
2398 if iNdEx >= l {
2399 return io.ErrUnexpectedEOF
2400 }
2401 b := dAtA[iNdEx]
2402 iNdEx++
2403 msglen |= (int(b) & 0x7F) << shift
2404 if b < 0x80 {
2405 break
2406 }
2407 }
2408 if msglen < 0 {
2409 return ErrInvalidLengthRaft
2410 }
2411 postIndex := iNdEx + msglen
2412 if postIndex > l {
2413 return io.ErrUnexpectedEOF
2414 }
2415 m.Changes = append(m.Changes, ConfChangeSingle{})
2416 if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2417 return err
2418 }
2419 iNdEx = postIndex
2420 case 3:
2421 if wireType != 2 {
2422 return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
2423 }
2424 var byteLen int
2425 for shift := uint(0); ; shift += 7 {
2426 if shift >= 64 {
2427 return ErrIntOverflowRaft
2428 }
2429 if iNdEx >= l {
2430 return io.ErrUnexpectedEOF
2431 }
2432 b := dAtA[iNdEx]
2433 iNdEx++
2434 byteLen |= (int(b) & 0x7F) << shift
2435 if b < 0x80 {
2436 break
2437 }
2438 }
2439 if byteLen < 0 {
2440 return ErrInvalidLengthRaft
2441 }
2442 postIndex := iNdEx + byteLen
2443 if postIndex > l {
2444 return io.ErrUnexpectedEOF
2445 }
2446 m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...)
2447 if m.Context == nil {
2448 m.Context = []byte{}
2449 }
2450 iNdEx = postIndex
2451 default:
2452 iNdEx = preIndex
2453 skippy, err := skipRaft(dAtA[iNdEx:])
2454 if err != nil {
2455 return err
2456 }
2457 if skippy < 0 {
2458 return ErrInvalidLengthRaft
2459 }
2460 if (iNdEx + skippy) > l {
2461 return io.ErrUnexpectedEOF
2462 }
2463 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2464 iNdEx += skippy
2465 }
2466 }
2467
2468 if iNdEx > l {
2469 return io.ErrUnexpectedEOF
2470 }
2471 return nil
2472}
2473func skipRaft(dAtA []byte) (n int, err error) {
2474 l := len(dAtA)
2475 iNdEx := 0
2476 for iNdEx < l {
2477 var wire uint64
2478 for shift := uint(0); ; shift += 7 {
2479 if shift >= 64 {
2480 return 0, ErrIntOverflowRaft
2481 }
2482 if iNdEx >= l {
2483 return 0, io.ErrUnexpectedEOF
2484 }
2485 b := dAtA[iNdEx]
2486 iNdEx++
2487 wire |= (uint64(b) & 0x7F) << shift
2488 if b < 0x80 {
2489 break
2490 }
2491 }
2492 wireType := int(wire & 0x7)
2493 switch wireType {
2494 case 0:
2495 for shift := uint(0); ; shift += 7 {
2496 if shift >= 64 {
2497 return 0, ErrIntOverflowRaft
2498 }
2499 if iNdEx >= l {
2500 return 0, io.ErrUnexpectedEOF
2501 }
2502 iNdEx++
2503 if dAtA[iNdEx-1] < 0x80 {
2504 break
2505 }
2506 }
2507 return iNdEx, nil
2508 case 1:
2509 iNdEx += 8
2510 return iNdEx, nil
2511 case 2:
2512 var length int
2513 for shift := uint(0); ; shift += 7 {
2514 if shift >= 64 {
2515 return 0, ErrIntOverflowRaft
2516 }
2517 if iNdEx >= l {
2518 return 0, io.ErrUnexpectedEOF
2519 }
2520 b := dAtA[iNdEx]
2521 iNdEx++
2522 length |= (int(b) & 0x7F) << shift
2523 if b < 0x80 {
2524 break
2525 }
2526 }
2527 iNdEx += length
2528 if length < 0 {
2529 return 0, ErrInvalidLengthRaft
2530 }
2531 return iNdEx, nil
2532 case 3:
2533 for {
2534 var innerWire uint64
2535 var start int = iNdEx
2536 for shift := uint(0); ; shift += 7 {
2537 if shift >= 64 {
2538 return 0, ErrIntOverflowRaft
2539 }
2540 if iNdEx >= l {
2541 return 0, io.ErrUnexpectedEOF
2542 }
2543 b := dAtA[iNdEx]
2544 iNdEx++
2545 innerWire |= (uint64(b) & 0x7F) << shift
2546 if b < 0x80 {
2547 break
2548 }
2549 }
2550 innerWireType := int(innerWire & 0x7)
2551 if innerWireType == 4 {
2552 break
2553 }
2554 next, err := skipRaft(dAtA[start:])
2555 if err != nil {
2556 return 0, err
2557 }
2558 iNdEx = start + next
2559 }
2560 return iNdEx, nil
2561 case 4:
2562 return iNdEx, nil
2563 case 5:
2564 iNdEx += 4
2565 return iNdEx, nil
2566 default:
2567 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2568 }
2569 }
2570 panic("unreachable")
2571}
2572
2573var (
2574 ErrInvalidLengthRaft = fmt.Errorf("proto: negative length found during unmarshaling")
2575 ErrIntOverflowRaft = fmt.Errorf("proto: integer overflow")
2576)
2577
2578func init() { proto.RegisterFile("raft.proto", fileDescriptorRaft) }
2579
2580var fileDescriptorRaft = []byte{
2581 // 1009 bytes of a gzipped FileDescriptorProto
2582 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xcd, 0x6e, 0xe3, 0x36,
2583 0x17, 0xb5, 0x64, 0xc5, 0x3f, 0xd7, 0x8e, 0xc3, 0xdc, 0xc9, 0x37, 0x20, 0x82, 0xc0, 0xe3, 0xcf,
2584 0xd3, 0x62, 0x8c, 0x14, 0x93, 0x16, 0x5e, 0x14, 0x45, 0x77, 0xf9, 0x19, 0x20, 0x29, 0xe2, 0x74,
2585 0xea, 0x64, 0xb2, 0x28, 0x50, 0x04, 0x8c, 0x45, 0x2b, 0x6a, 0x2d, 0x51, 0xa0, 0xe8, 0x34, 0xd9,
2586 0x14, 0x45, 0x9f, 0xa2, 0x9b, 0xd9, 0xf6, 0x01, 0xfa, 0x14, 0x59, 0x0e, 0xd0, 0xfd, 0xa0, 0x93,
2587 0xbe, 0x48, 0x41, 0x8a, 0xb2, 0x65, 0x27, 0x98, 0x45, 0x77, 0xe4, 0x39, 0x87, 0xf7, 0x9e, 0x7b,
2588 0x79, 0x45, 0x01, 0x48, 0x36, 0x56, 0x3b, 0x89, 0x14, 0x4a, 0x60, 0x45, 0xaf, 0x93, 0xcb, 0xcd,
2589 0x8d, 0x40, 0x04, 0xc2, 0x40, 0x9f, 0xeb, 0x55, 0xc6, 0x76, 0x7f, 0x81, 0x95, 0x57, 0xb1, 0x92,
2590 0xb7, 0xf8, 0x19, 0x78, 0x67, 0xb7, 0x09, 0xa7, 0x4e, 0xc7, 0xe9, 0xb5, 0xfa, 0xeb, 0x3b, 0xd9,
2591 0xa9, 0x1d, 0x43, 0x6a, 0x62, 0xcf, 0xbb, 0x7b, 0xff, 0xac, 0x34, 0x34, 0x22, 0xa4, 0xe0, 0x9d,
2592 0x71, 0x19, 0x51, 0xb7, 0xe3, 0xf4, 0xbc, 0x19, 0xc3, 0x65, 0x84, 0x9b, 0xb0, 0x72, 0x14, 0xfb,
2593 0xfc, 0x86, 0x96, 0x0b, 0x54, 0x06, 0x21, 0x82, 0x77, 0xc0, 0x14, 0xa3, 0x5e, 0xc7, 0xe9, 0x35,
2594 0x87, 0x66, 0xdd, 0xfd, 0xd5, 0x01, 0x72, 0x1a, 0xb3, 0x24, 0xbd, 0x12, 0x6a, 0xc0, 0x15, 0xf3,
2595 0x99, 0x62, 0xf8, 0x25, 0xc0, 0x48, 0xc4, 0xe3, 0x8b, 0x54, 0x31, 0x95, 0x39, 0x6a, 0xcc, 0x1d,
2596 0xed, 0x8b, 0x78, 0x7c, 0xaa, 0x09, 0x1b, 0xbc, 0x3e, 0xca, 0x01, 0x9d, 0x3c, 0x34, 0xc9, 0x8b,
2597 0xbe, 0x32, 0x48, 0x5b, 0x56, 0xda, 0x72, 0xd1, 0x97, 0x41, 0xba, 0xdf, 0x43, 0x2d, 0x77, 0xa0,
2598 0x2d, 0x6a, 0x07, 0x26, 0x67, 0x73, 0x68, 0xd6, 0xf8, 0x35, 0xd4, 0x22, 0xeb, 0xcc, 0x04, 0x6e,
2599 0xf4, 0x69, 0xee, 0x65, 0xd9, 0xb9, 0x8d, 0x3b, 0xd3, 0x77, 0xdf, 0x96, 0xa1, 0x3a, 0xe0, 0x69,
2600 0xca, 0x02, 0x8e, 0x2f, 0xc1, 0x53, 0xf3, 0x0e, 0x3f, 0xc9, 0x63, 0x58, 0xba, 0xd8, 0x63, 0x2d,
2601 0xc3, 0x0d, 0x70, 0x95, 0x58, 0xa8, 0xc4, 0x55, 0x42, 0x97, 0x31, 0x96, 0x62, 0xa9, 0x0c, 0x8d,
2602 0xcc, 0x0a, 0xf4, 0x96, 0x0b, 0xc4, 0x36, 0x54, 0x27, 0x22, 0x30, 0x17, 0xb6, 0x52, 0x20, 0x73,
2603 0x70, 0xde, 0xb6, 0xca, 0xc3, 0xb6, 0xbd, 0x84, 0x2a, 0x8f, 0x95, 0x0c, 0x79, 0x4a, 0xab, 0x9d,
2604 0x72, 0xaf, 0xd1, 0x5f, 0x5d, 0x98, 0x8c, 0x3c, 0x94, 0xd5, 0xe0, 0x16, 0x54, 0x46, 0x22, 0x8a,
2605 0x42, 0x45, 0x6b, 0x85, 0x58, 0x16, 0xc3, 0x3e, 0xd4, 0x52, 0xdb, 0x31, 0x5a, 0x37, 0x9d, 0x24,
2606 0xcb, 0x9d, 0xcc, 0x3b, 0x98, 0xeb, 0x74, 0x44, 0xc9, 0x7f, 0xe4, 0x23, 0x45, 0xa1, 0xe3, 0xf4,
2607 0x6a, 0x79, 0xc4, 0x0c, 0xc3, 0x4f, 0x00, 0xb2, 0xd5, 0x61, 0x18, 0x2b, 0xda, 0x28, 0xe4, 0x2c,
2608 0xe0, 0x48, 0xa1, 0x3a, 0x12, 0xb1, 0xe2, 0x37, 0x8a, 0x36, 0xcd, 0xc5, 0xe6, 0xdb, 0xee, 0x0f,
2609 0x50, 0x3f, 0x64, 0xd2, 0xcf, 0xc6, 0x27, 0xef, 0xa0, 0xf3, 0xa0, 0x83, 0x14, 0xbc, 0x6b, 0xa1,
2610 0xf8, 0xe2, 0xbc, 0x6b, 0xa4, 0x50, 0x70, 0xf9, 0x61, 0xc1, 0xdd, 0x3f, 0x1d, 0xa8, 0xcf, 0xe6,
2611 0x15, 0x9f, 0x42, 0x45, 0x9f, 0x91, 0x29, 0x75, 0x3a, 0xe5, 0x9e, 0x37, 0xb4, 0x3b, 0xdc, 0x84,
2612 0xda, 0x84, 0x33, 0x19, 0x6b, 0xc6, 0x35, 0xcc, 0x6c, 0x8f, 0x2f, 0x60, 0x2d, 0x53, 0x5d, 0x88,
2613 0xa9, 0x0a, 0x44, 0x18, 0x07, 0xb4, 0x6c, 0x24, 0xad, 0x0c, 0xfe, 0xd6, 0xa2, 0xf8, 0x1c, 0x56,
2614 0xf3, 0x43, 0x17, 0xb1, 0xae, 0xd4, 0x33, 0xb2, 0x66, 0x0e, 0x9e, 0xf0, 0x1b, 0x85, 0xcf, 0x01,
2615 0xd8, 0x54, 0x89, 0x8b, 0x09, 0x67, 0xd7, 0xdc, 0x0c, 0x43, 0xde, 0xd0, 0xba, 0xc6, 0x8f, 0x35,
2616 0xdc, 0x7d, 0xeb, 0x00, 0x68, 0xd3, 0xfb, 0x57, 0x2c, 0x0e, 0xf4, 0x47, 0xe5, 0x86, 0xbe, 0xed,
2617 0x09, 0x68, 0xed, 0xfd, 0xfb, 0x67, 0xee, 0xd1, 0xc1, 0xd0, 0x0d, 0x7d, 0xfc, 0xc2, 0x8e, 0xb4,
2618 0x6b, 0x46, 0xfa, 0x69, 0xf1, 0x13, 0xcd, 0x4e, 0x3f, 0x98, 0xea, 0x17, 0x50, 0x8d, 0x85, 0xcf,
2619 0x2f, 0x42, 0xdf, 0x36, 0xac, 0x65, 0x43, 0x56, 0x4e, 0x84, 0xcf, 0x8f, 0x0e, 0x86, 0x15, 0x4d,
2620 0x1f, 0xf9, 0xc5, 0x3b, 0xf3, 0x16, 0xef, 0x2c, 0x02, 0x32, 0x4f, 0x70, 0x1a, 0xc6, 0xc1, 0x84,
2621 0xcf, 0x8c, 0x38, 0xff, 0xc5, 0x88, 0xfb, 0x31, 0x23, 0xdd, 0x3f, 0x1c, 0x68, 0xce, 0xe3, 0x9c,
2622 0xf7, 0x71, 0x0f, 0x40, 0x49, 0x16, 0xa7, 0xa1, 0x0a, 0x45, 0x6c, 0x33, 0x6e, 0x3d, 0x92, 0x71,
2623 0xa6, 0xc9, 0x27, 0x72, 0x7e, 0x0a, 0xbf, 0x82, 0xea, 0xc8, 0xa8, 0xb2, 0x1b, 0x2f, 0x3c, 0x29,
2624 0xcb, 0xa5, 0xe5, 0x5f, 0x98, 0x95, 0x17, 0xfb, 0x52, 0x5e, 0xe8, 0xcb, 0xf6, 0x21, 0xd4, 0x67,
2625 0xaf, 0x35, 0xae, 0x41, 0xc3, 0x6c, 0x4e, 0x84, 0x8c, 0xd8, 0x84, 0x94, 0xf0, 0x09, 0xac, 0x19,
2626 0x60, 0x1e, 0x9f, 0x38, 0xf8, 0x3f, 0x58, 0x5f, 0x02, 0xcf, 0xfb, 0xc4, 0xdd, 0xfe, 0xcb, 0x85,
2627 0x46, 0xe1, 0x59, 0x42, 0x80, 0xca, 0x20, 0x0d, 0x0e, 0xa7, 0x09, 0x29, 0x61, 0x03, 0xaa, 0x83,
2628 0x34, 0xd8, 0xe3, 0x4c, 0x11, 0xc7, 0x6e, 0x5e, 0x4b, 0x91, 0x10, 0xd7, 0xaa, 0x76, 0x93, 0x84,
2629 0x94, 0xb1, 0x05, 0x90, 0xad, 0x87, 0x3c, 0x4d, 0x88, 0x67, 0x85, 0xe7, 0x42, 0x71, 0xb2, 0xa2,
2630 0xbd, 0xd9, 0x8d, 0x61, 0x2b, 0x96, 0xd5, 0x4f, 0x00, 0xa9, 0x22, 0x81, 0xa6, 0x4e, 0xc6, 0x99,
2631 0x54, 0x97, 0x3a, 0x4b, 0x0d, 0x37, 0x80, 0x14, 0x11, 0x73, 0xa8, 0x8e, 0x08, 0xad, 0x41, 0x1a,
2632 0xbc, 0x89, 0x25, 0x67, 0xa3, 0x2b, 0x76, 0x39, 0xe1, 0x04, 0x70, 0x1d, 0x56, 0x6d, 0x20, 0xfd,
2633 0xc5, 0x4d, 0x53, 0xd2, 0xb0, 0xb2, 0xfd, 0x2b, 0x3e, 0xfa, 0xe9, 0xbb, 0xa9, 0x90, 0xd3, 0x88,
2634 0x34, 0x75, 0xd9, 0x83, 0x34, 0x30, 0x17, 0x34, 0xe6, 0xf2, 0x98, 0x33, 0x9f, 0x4b, 0xb2, 0x6a,
2635 0x4f, 0x9f, 0x85, 0x11, 0x17, 0x53, 0x75, 0x22, 0x7e, 0x26, 0x2d, 0x6b, 0x66, 0xc8, 0x99, 0x6f,
2636 0x7e, 0x61, 0x64, 0xcd, 0x9a, 0x99, 0x21, 0xc6, 0x0c, 0xb1, 0xf5, 0xbe, 0x96, 0xdc, 0x94, 0xb8,
2637 0x6e, 0xb3, 0xda, 0xbd, 0xd1, 0xe0, 0xf6, 0x6f, 0x0e, 0x6c, 0x3c, 0x36, 0x1e, 0xb8, 0x05, 0xf4,
2638 0x31, 0x7c, 0x77, 0xaa, 0x04, 0x29, 0xe1, 0xa7, 0xf0, 0xff, 0xc7, 0xd8, 0x6f, 0x44, 0x18, 0xab,
2639 0xa3, 0x28, 0x99, 0x84, 0xa3, 0x50, 0x5f, 0xc5, 0xc7, 0x64, 0xaf, 0x6e, 0xac, 0xcc, 0xdd, 0xbe,
2640 0x85, 0xd6, 0xe2, 0x47, 0xa1, 0x9b, 0x31, 0x47, 0x76, 0x7d, 0x5f, 0x8f, 0x3f, 0x29, 0x21, 0x2d,
2641 0x9a, 0x1d, 0xf2, 0x48, 0x5c, 0x73, 0xc3, 0x38, 0x8b, 0xcc, 0x9b, 0xc4, 0x67, 0x2a, 0x63, 0xdc,
2642 0xc5, 0x42, 0x76, 0x7d, 0xff, 0x38, 0x7b, 0x7b, 0x0c, 0x5b, 0xde, 0xa3, 0x77, 0x1f, 0xda, 0xa5,
2643 0x77, 0x1f, 0xda, 0xa5, 0xbb, 0xfb, 0xb6, 0xf3, 0xee, 0xbe, 0xed, 0xfc, 0x7d, 0xdf, 0x76, 0x7e,
2644 0xff, 0xa7, 0x5d, 0xfa, 0x37, 0x00, 0x00, 0xff, 0xff, 0x87, 0x11, 0x6d, 0xd6, 0xaf, 0x08, 0x00,
2645 0x00,
2646}