1// Code generated by protoc-gen-gogo. 2// source: raft.proto 3// DO NOT EDIT! 4 5/* 6 Package raftpb is a generated protocol buffer package. 7 8 It is generated from these files: 9 raft.proto 10 11 It has these top-level messages: 12 Entry 13 SnapshotMetadata 14 Snapshot 15 Message 16 HardState 17 ConfState 18 ConfChange 19*/ 20package raftpb 21 22import ( 23 "fmt" 24 25 proto "github.com/golang/protobuf/proto" 26 27 math "math" 28 29 io "io" 30) 31 32// Reference imports to suppress errors if they are not otherwise used. 33var _ = proto.Marshal 34var _ = fmt.Errorf 35var _ = math.Inf 36 37// This is a compile-time assertion to ensure that this generated file 38// is compatible with the proto package it is being compiled against. 39// A compilation error at this line likely means your copy of the 40// proto package needs to be updated. 41const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 42 43type EntryType int32 44 45const ( 46 EntryNormal EntryType = 0 47 EntryConfChange EntryType = 1 48) 49 50var EntryType_name = map[int32]string{ 51 0: "EntryNormal", 52 1: "EntryConfChange", 53} 54var EntryType_value = map[string]int32{ 55 "EntryNormal": 0, 56 "EntryConfChange": 1, 57} 58 59func (x EntryType) Enum() *EntryType { 60 p := new(EntryType) 61 *p = x 62 return p 63} 64func (x EntryType) String() string { 65 return proto.EnumName(EntryType_name, int32(x)) 66} 67func (x *EntryType) UnmarshalJSON(data []byte) error { 68 value, err := proto.UnmarshalJSONEnum(EntryType_value, data, "EntryType") 69 if err != nil { 70 return err 71 } 72 *x = EntryType(value) 73 return nil 74} 75func (EntryType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{0} } 76 77type MessageType int32 78 79const ( 80 MsgHup MessageType = 0 81 MsgBeat MessageType = 1 82 MsgProp MessageType = 2 83 MsgApp MessageType = 3 84 MsgAppResp MessageType = 4 85 MsgVote MessageType = 5 86 MsgVoteResp MessageType = 6 87 MsgSnap MessageType = 7 88 MsgHeartbeat MessageType = 8 89 MsgHeartbeatResp MessageType = 9 90 MsgUnreachable MessageType = 10 91 MsgSnapStatus MessageType = 11 92 MsgCheckQuorum MessageType = 12 93 MsgTransferLeader MessageType = 13 94 MsgTimeoutNow MessageType = 14 95 MsgReadIndex MessageType = 15 96 MsgReadIndexResp MessageType = 16 97 MsgPreVote MessageType = 17 98 MsgPreVoteResp MessageType = 18 99) 100 101var MessageType_name = map[int32]string{ 102 0: "MsgHup", 103 1: "MsgBeat", 104 2: "MsgProp", 105 3: "MsgApp", 106 4: "MsgAppResp", 107 5: "MsgVote", 108 6: "MsgVoteResp", 109 7: "MsgSnap", 110 8: "MsgHeartbeat", 111 9: "MsgHeartbeatResp", 112 10: "MsgUnreachable", 113 11: "MsgSnapStatus", 114 12: "MsgCheckQuorum", 115 13: "MsgTransferLeader", 116 14: "MsgTimeoutNow", 117 15: "MsgReadIndex", 118 16: "MsgReadIndexResp", 119 17: "MsgPreVote", 120 18: "MsgPreVoteResp", 121} 122var MessageType_value = map[string]int32{ 123 "MsgHup": 0, 124 "MsgBeat": 1, 125 "MsgProp": 2, 126 "MsgApp": 3, 127 "MsgAppResp": 4, 128 "MsgVote": 5, 129 "MsgVoteResp": 6, 130 "MsgSnap": 7, 131 "MsgHeartbeat": 8, 132 "MsgHeartbeatResp": 9, 133 "MsgUnreachable": 10, 134 "MsgSnapStatus": 11, 135 "MsgCheckQuorum": 12, 136 "MsgTransferLeader": 13, 137 "MsgTimeoutNow": 14, 138 "MsgReadIndex": 15, 139 "MsgReadIndexResp": 16, 140 "MsgPreVote": 17, 141 "MsgPreVoteResp": 18, 142} 143 144func (x MessageType) Enum() *MessageType { 145 p := new(MessageType) 146 *p = x 147 return p 148} 149func (x MessageType) String() string { 150 return proto.EnumName(MessageType_name, int32(x)) 151} 152func (x *MessageType) UnmarshalJSON(data []byte) error { 153 value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType") 154 if err != nil { 155 return err 156 } 157 *x = MessageType(value) 158 return nil 159} 160func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{1} } 161 162type ConfChangeType int32 163 164const ( 165 ConfChangeAddNode ConfChangeType = 0 166 ConfChangeRemoveNode ConfChangeType = 1 167 ConfChangeUpdateNode ConfChangeType = 2 168) 169 170var ConfChangeType_name = map[int32]string{ 171 0: "ConfChangeAddNode", 172 1: "ConfChangeRemoveNode", 173 2: "ConfChangeUpdateNode", 174} 175var ConfChangeType_value = map[string]int32{ 176 "ConfChangeAddNode": 0, 177 "ConfChangeRemoveNode": 1, 178 "ConfChangeUpdateNode": 2, 179} 180 181func (x ConfChangeType) Enum() *ConfChangeType { 182 p := new(ConfChangeType) 183 *p = x 184 return p 185} 186func (x ConfChangeType) String() string { 187 return proto.EnumName(ConfChangeType_name, int32(x)) 188} 189func (x *ConfChangeType) UnmarshalJSON(data []byte) error { 190 value, err := proto.UnmarshalJSONEnum(ConfChangeType_value, data, "ConfChangeType") 191 if err != nil { 192 return err 193 } 194 *x = ConfChangeType(value) 195 return nil 196} 197func (ConfChangeType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{2} } 198 199type Entry struct { 200 Term uint64 `protobuf:"varint,2,opt,name=Term" json:"Term"` 201 Index uint64 `protobuf:"varint,3,opt,name=Index" json:"Index"` 202 Type EntryType `protobuf:"varint,1,opt,name=Type,enum=raftpb.EntryType" json:"Type"` 203 Data []byte `protobuf:"bytes,4,opt,name=Data" json:"Data,omitempty"` 204 XXX_unrecognized []byte `json:"-"` 205} 206 207func (m *Entry) Reset() { *m = Entry{} } 208func (m *Entry) String() string { return proto.CompactTextString(m) } 209func (*Entry) ProtoMessage() {} 210func (*Entry) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{0} } 211 212type SnapshotMetadata struct { 213 ConfState ConfState `protobuf:"bytes,1,opt,name=conf_state,json=confState" json:"conf_state"` 214 Index uint64 `protobuf:"varint,2,opt,name=index" json:"index"` 215 Term uint64 `protobuf:"varint,3,opt,name=term" json:"term"` 216 XXX_unrecognized []byte `json:"-"` 217} 218 219func (m *SnapshotMetadata) Reset() { *m = SnapshotMetadata{} } 220func (m *SnapshotMetadata) String() string { return proto.CompactTextString(m) } 221func (*SnapshotMetadata) ProtoMessage() {} 222func (*SnapshotMetadata) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{1} } 223 224type Snapshot struct { 225 Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"` 226 Metadata SnapshotMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata"` 227 XXX_unrecognized []byte `json:"-"` 228} 229 230func (m *Snapshot) Reset() { *m = Snapshot{} } 231func (m *Snapshot) String() string { return proto.CompactTextString(m) } 232func (*Snapshot) ProtoMessage() {} 233func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{2} } 234 235type Message struct { 236 Type MessageType `protobuf:"varint,1,opt,name=type,enum=raftpb.MessageType" json:"type"` 237 To uint64 `protobuf:"varint,2,opt,name=to" json:"to"` 238 From uint64 `protobuf:"varint,3,opt,name=from" json:"from"` 239 Term uint64 `protobuf:"varint,4,opt,name=term" json:"term"` 240 LogTerm uint64 `protobuf:"varint,5,opt,name=logTerm" json:"logTerm"` 241 Index uint64 `protobuf:"varint,6,opt,name=index" json:"index"` 242 Entries []Entry `protobuf:"bytes,7,rep,name=entries" json:"entries"` 243 Commit uint64 `protobuf:"varint,8,opt,name=commit" json:"commit"` 244 Snapshot Snapshot `protobuf:"bytes,9,opt,name=snapshot" json:"snapshot"` 245 Reject bool `protobuf:"varint,10,opt,name=reject" json:"reject"` 246 RejectHint uint64 `protobuf:"varint,11,opt,name=rejectHint" json:"rejectHint"` 247 Context []byte `protobuf:"bytes,12,opt,name=context" json:"context,omitempty"` 248 XXX_unrecognized []byte `json:"-"` 249} 250 251func (m *Message) Reset() { *m = Message{} } 252func (m *Message) String() string { return proto.CompactTextString(m) } 253func (*Message) ProtoMessage() {} 254func (*Message) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{3} } 255 256type HardState struct { 257 Term uint64 `protobuf:"varint,1,opt,name=term" json:"term"` 258 Vote uint64 `protobuf:"varint,2,opt,name=vote" json:"vote"` 259 Commit uint64 `protobuf:"varint,3,opt,name=commit" json:"commit"` 260 XXX_unrecognized []byte `json:"-"` 261} 262 263func (m *HardState) Reset() { *m = HardState{} } 264func (m *HardState) String() string { return proto.CompactTextString(m) } 265func (*HardState) ProtoMessage() {} 266func (*HardState) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{4} } 267 268type ConfState struct { 269 Nodes []uint64 `protobuf:"varint,1,rep,name=nodes" json:"nodes,omitempty"` 270 XXX_unrecognized []byte `json:"-"` 271} 272 273func (m *ConfState) Reset() { *m = ConfState{} } 274func (m *ConfState) String() string { return proto.CompactTextString(m) } 275func (*ConfState) ProtoMessage() {} 276func (*ConfState) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{5} } 277 278type ConfChange struct { 279 ID uint64 `protobuf:"varint,1,opt,name=ID" json:"ID"` 280 Type ConfChangeType `protobuf:"varint,2,opt,name=Type,enum=raftpb.ConfChangeType" json:"Type"` 281 NodeID uint64 `protobuf:"varint,3,opt,name=NodeID" json:"NodeID"` 282 Context []byte `protobuf:"bytes,4,opt,name=Context" json:"Context,omitempty"` 283 XXX_unrecognized []byte `json:"-"` 284} 285 286func (m *ConfChange) Reset() { *m = ConfChange{} } 287func (m *ConfChange) String() string { return proto.CompactTextString(m) } 288func (*ConfChange) ProtoMessage() {} 289func (*ConfChange) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{6} } 290 291func init() { 292 proto.RegisterType((*Entry)(nil), "raftpb.Entry") 293 proto.RegisterType((*SnapshotMetadata)(nil), "raftpb.SnapshotMetadata") 294 proto.RegisterType((*Snapshot)(nil), "raftpb.Snapshot") 295 proto.RegisterType((*Message)(nil), "raftpb.Message") 296 proto.RegisterType((*HardState)(nil), "raftpb.HardState") 297 proto.RegisterType((*ConfState)(nil), "raftpb.ConfState") 298 proto.RegisterType((*ConfChange)(nil), "raftpb.ConfChange") 299 proto.RegisterEnum("raftpb.EntryType", EntryType_name, EntryType_value) 300 proto.RegisterEnum("raftpb.MessageType", MessageType_name, MessageType_value) 301 proto.RegisterEnum("raftpb.ConfChangeType", ConfChangeType_name, ConfChangeType_value) 302} 303func (m *Entry) Marshal() (dAtA []byte, err error) { 304 size := m.Size() 305 dAtA = make([]byte, size) 306 n, err := m.MarshalTo(dAtA) 307 if err != nil { 308 return nil, err 309 } 310 return dAtA[:n], nil 311} 312 313func (m *Entry) MarshalTo(dAtA []byte) (int, error) { 314 var i int 315 _ = i 316 var l int 317 _ = l 318 dAtA[i] = 0x8 319 i++ 320 i = encodeVarintRaft(dAtA, i, uint64(m.Type)) 321 dAtA[i] = 0x10 322 i++ 323 i = encodeVarintRaft(dAtA, i, uint64(m.Term)) 324 dAtA[i] = 0x18 325 i++ 326 i = encodeVarintRaft(dAtA, i, uint64(m.Index)) 327 if m.Data != nil { 328 dAtA[i] = 0x22 329 i++ 330 i = encodeVarintRaft(dAtA, i, uint64(len(m.Data))) 331 i += copy(dAtA[i:], m.Data) 332 } 333 if m.XXX_unrecognized != nil { 334 i += copy(dAtA[i:], m.XXX_unrecognized) 335 } 336 return i, nil 337} 338 339func (m *SnapshotMetadata) Marshal() (dAtA []byte, err error) { 340 size := m.Size() 341 dAtA = make([]byte, size) 342 n, err := m.MarshalTo(dAtA) 343 if err != nil { 344 return nil, err 345 } 346 return dAtA[:n], nil 347} 348 349func (m *SnapshotMetadata) MarshalTo(dAtA []byte) (int, error) { 350 var i int 351 _ = i 352 var l int 353 _ = l 354 dAtA[i] = 0xa 355 i++ 356 i = encodeVarintRaft(dAtA, i, uint64(m.ConfState.Size())) 357 n1, err := m.ConfState.MarshalTo(dAtA[i:]) 358 if err != nil { 359 return 0, err 360 } 361 i += n1 362 dAtA[i] = 0x10 363 i++ 364 i = encodeVarintRaft(dAtA, i, uint64(m.Index)) 365 dAtA[i] = 0x18 366 i++ 367 i = encodeVarintRaft(dAtA, i, uint64(m.Term)) 368 if m.XXX_unrecognized != nil { 369 i += copy(dAtA[i:], m.XXX_unrecognized) 370 } 371 return i, nil 372} 373 374func (m *Snapshot) Marshal() (dAtA []byte, err error) { 375 size := m.Size() 376 dAtA = make([]byte, size) 377 n, err := m.MarshalTo(dAtA) 378 if err != nil { 379 return nil, err 380 } 381 return dAtA[:n], nil 382} 383 384func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) { 385 var i int 386 _ = i 387 var l int 388 _ = l 389 if m.Data != nil { 390 dAtA[i] = 0xa 391 i++ 392 i = encodeVarintRaft(dAtA, i, uint64(len(m.Data))) 393 i += copy(dAtA[i:], m.Data) 394 } 395 dAtA[i] = 0x12 396 i++ 397 i = encodeVarintRaft(dAtA, i, uint64(m.Metadata.Size())) 398 n2, err := m.Metadata.MarshalTo(dAtA[i:]) 399 if err != nil { 400 return 0, err 401 } 402 i += n2 403 if m.XXX_unrecognized != nil { 404 i += copy(dAtA[i:], m.XXX_unrecognized) 405 } 406 return i, nil 407} 408 409func (m *Message) Marshal() (dAtA []byte, err error) { 410 size := m.Size() 411 dAtA = make([]byte, size) 412 n, err := m.MarshalTo(dAtA) 413 if err != nil { 414 return nil, err 415 } 416 return dAtA[:n], nil 417} 418 419func (m *Message) MarshalTo(dAtA []byte) (int, error) { 420 var i int 421 _ = i 422 var l int 423 _ = l 424 dAtA[i] = 0x8 425 i++ 426 i = encodeVarintRaft(dAtA, i, uint64(m.Type)) 427 dAtA[i] = 0x10 428 i++ 429 i = encodeVarintRaft(dAtA, i, uint64(m.To)) 430 dAtA[i] = 0x18 431 i++ 432 i = encodeVarintRaft(dAtA, i, uint64(m.From)) 433 dAtA[i] = 0x20 434 i++ 435 i = encodeVarintRaft(dAtA, i, uint64(m.Term)) 436 dAtA[i] = 0x28 437 i++ 438 i = encodeVarintRaft(dAtA, i, uint64(m.LogTerm)) 439 dAtA[i] = 0x30 440 i++ 441 i = encodeVarintRaft(dAtA, i, uint64(m.Index)) 442 if len(m.Entries) > 0 { 443 for _, msg := range m.Entries { 444 dAtA[i] = 0x3a 445 i++ 446 i = encodeVarintRaft(dAtA, i, uint64(msg.Size())) 447 n, err := msg.MarshalTo(dAtA[i:]) 448 if err != nil { 449 return 0, err 450 } 451 i += n 452 } 453 } 454 dAtA[i] = 0x40 455 i++ 456 i = encodeVarintRaft(dAtA, i, uint64(m.Commit)) 457 dAtA[i] = 0x4a 458 i++ 459 i = encodeVarintRaft(dAtA, i, uint64(m.Snapshot.Size())) 460 n3, err := m.Snapshot.MarshalTo(dAtA[i:]) 461 if err != nil { 462 return 0, err 463 } 464 i += n3 465 dAtA[i] = 0x50 466 i++ 467 if m.Reject { 468 dAtA[i] = 1 469 } else { 470 dAtA[i] = 0 471 } 472 i++ 473 dAtA[i] = 0x58 474 i++ 475 i = encodeVarintRaft(dAtA, i, uint64(m.RejectHint)) 476 if m.Context != nil { 477 dAtA[i] = 0x62 478 i++ 479 i = encodeVarintRaft(dAtA, i, uint64(len(m.Context))) 480 i += copy(dAtA[i:], m.Context) 481 } 482 if m.XXX_unrecognized != nil { 483 i += copy(dAtA[i:], m.XXX_unrecognized) 484 } 485 return i, nil 486} 487 488func (m *HardState) Marshal() (dAtA []byte, err error) { 489 size := m.Size() 490 dAtA = make([]byte, size) 491 n, err := m.MarshalTo(dAtA) 492 if err != nil { 493 return nil, err 494 } 495 return dAtA[:n], nil 496} 497 498func (m *HardState) MarshalTo(dAtA []byte) (int, error) { 499 var i int 500 _ = i 501 var l int 502 _ = l 503 dAtA[i] = 0x8 504 i++ 505 i = encodeVarintRaft(dAtA, i, uint64(m.Term)) 506 dAtA[i] = 0x10 507 i++ 508 i = encodeVarintRaft(dAtA, i, uint64(m.Vote)) 509 dAtA[i] = 0x18 510 i++ 511 i = encodeVarintRaft(dAtA, i, uint64(m.Commit)) 512 if m.XXX_unrecognized != nil { 513 i += copy(dAtA[i:], m.XXX_unrecognized) 514 } 515 return i, nil 516} 517 518func (m *ConfState) Marshal() (dAtA []byte, err error) { 519 size := m.Size() 520 dAtA = make([]byte, size) 521 n, err := m.MarshalTo(dAtA) 522 if err != nil { 523 return nil, err 524 } 525 return dAtA[:n], nil 526} 527 528func (m *ConfState) MarshalTo(dAtA []byte) (int, error) { 529 var i int 530 _ = i 531 var l int 532 _ = l 533 if len(m.Nodes) > 0 { 534 for _, num := range m.Nodes { 535 dAtA[i] = 0x8 536 i++ 537 i = encodeVarintRaft(dAtA, i, uint64(num)) 538 } 539 } 540 if m.XXX_unrecognized != nil { 541 i += copy(dAtA[i:], m.XXX_unrecognized) 542 } 543 return i, nil 544} 545 546func (m *ConfChange) Marshal() (dAtA []byte, err error) { 547 size := m.Size() 548 dAtA = make([]byte, size) 549 n, err := m.MarshalTo(dAtA) 550 if err != nil { 551 return nil, err 552 } 553 return dAtA[:n], nil 554} 555 556func (m *ConfChange) MarshalTo(dAtA []byte) (int, error) { 557 var i int 558 _ = i 559 var l int 560 _ = l 561 dAtA[i] = 0x8 562 i++ 563 i = encodeVarintRaft(dAtA, i, uint64(m.ID)) 564 dAtA[i] = 0x10 565 i++ 566 i = encodeVarintRaft(dAtA, i, uint64(m.Type)) 567 dAtA[i] = 0x18 568 i++ 569 i = encodeVarintRaft(dAtA, i, uint64(m.NodeID)) 570 if m.Context != nil { 571 dAtA[i] = 0x22 572 i++ 573 i = encodeVarintRaft(dAtA, i, uint64(len(m.Context))) 574 i += copy(dAtA[i:], m.Context) 575 } 576 if m.XXX_unrecognized != nil { 577 i += copy(dAtA[i:], m.XXX_unrecognized) 578 } 579 return i, nil 580} 581 582func encodeFixed64Raft(dAtA []byte, offset int, v uint64) int { 583 dAtA[offset] = uint8(v) 584 dAtA[offset+1] = uint8(v >> 8) 585 dAtA[offset+2] = uint8(v >> 16) 586 dAtA[offset+3] = uint8(v >> 24) 587 dAtA[offset+4] = uint8(v >> 32) 588 dAtA[offset+5] = uint8(v >> 40) 589 dAtA[offset+6] = uint8(v >> 48) 590 dAtA[offset+7] = uint8(v >> 56) 591 return offset + 8 592} 593func encodeFixed32Raft(dAtA []byte, offset int, v uint32) int { 594 dAtA[offset] = uint8(v) 595 dAtA[offset+1] = uint8(v >> 8) 596 dAtA[offset+2] = uint8(v >> 16) 597 dAtA[offset+3] = uint8(v >> 24) 598 return offset + 4 599} 600func encodeVarintRaft(dAtA []byte, offset int, v uint64) int { 601 for v >= 1<<7 { 602 dAtA[offset] = uint8(v&0x7f | 0x80) 603 v >>= 7 604 offset++ 605 } 606 dAtA[offset] = uint8(v) 607 return offset + 1 608} 609func (m *Entry) Size() (n int) { 610 var l int 611 _ = l 612 n += 1 + sovRaft(uint64(m.Type)) 613 n += 1 + sovRaft(uint64(m.Term)) 614 n += 1 + sovRaft(uint64(m.Index)) 615 if m.Data != nil { 616 l = len(m.Data) 617 n += 1 + l + sovRaft(uint64(l)) 618 } 619 if m.XXX_unrecognized != nil { 620 n += len(m.XXX_unrecognized) 621 } 622 return n 623} 624 625func (m *SnapshotMetadata) Size() (n int) { 626 var l int 627 _ = l 628 l = m.ConfState.Size() 629 n += 1 + l + sovRaft(uint64(l)) 630 n += 1 + sovRaft(uint64(m.Index)) 631 n += 1 + sovRaft(uint64(m.Term)) 632 if m.XXX_unrecognized != nil { 633 n += len(m.XXX_unrecognized) 634 } 635 return n 636} 637 638func (m *Snapshot) Size() (n int) { 639 var l int 640 _ = l 641 if m.Data != nil { 642 l = len(m.Data) 643 n += 1 + l + sovRaft(uint64(l)) 644 } 645 l = m.Metadata.Size() 646 n += 1 + l + sovRaft(uint64(l)) 647 if m.XXX_unrecognized != nil { 648 n += len(m.XXX_unrecognized) 649 } 650 return n 651} 652 653func (m *Message) Size() (n int) { 654 var l int 655 _ = l 656 n += 1 + sovRaft(uint64(m.Type)) 657 n += 1 + sovRaft(uint64(m.To)) 658 n += 1 + sovRaft(uint64(m.From)) 659 n += 1 + sovRaft(uint64(m.Term)) 660 n += 1 + sovRaft(uint64(m.LogTerm)) 661 n += 1 + sovRaft(uint64(m.Index)) 662 if len(m.Entries) > 0 { 663 for _, e := range m.Entries { 664 l = e.Size() 665 n += 1 + l + sovRaft(uint64(l)) 666 } 667 } 668 n += 1 + sovRaft(uint64(m.Commit)) 669 l = m.Snapshot.Size() 670 n += 1 + l + sovRaft(uint64(l)) 671 n += 2 672 n += 1 + sovRaft(uint64(m.RejectHint)) 673 if m.Context != nil { 674 l = len(m.Context) 675 n += 1 + l + sovRaft(uint64(l)) 676 } 677 if m.XXX_unrecognized != nil { 678 n += len(m.XXX_unrecognized) 679 } 680 return n 681} 682 683func (m *HardState) Size() (n int) { 684 var l int 685 _ = l 686 n += 1 + sovRaft(uint64(m.Term)) 687 n += 1 + sovRaft(uint64(m.Vote)) 688 n += 1 + sovRaft(uint64(m.Commit)) 689 if m.XXX_unrecognized != nil { 690 n += len(m.XXX_unrecognized) 691 } 692 return n 693} 694 695func (m *ConfState) Size() (n int) { 696 var l int 697 _ = l 698 if len(m.Nodes) > 0 { 699 for _, e := range m.Nodes { 700 n += 1 + sovRaft(uint64(e)) 701 } 702 } 703 if m.XXX_unrecognized != nil { 704 n += len(m.XXX_unrecognized) 705 } 706 return n 707} 708 709func (m *ConfChange) Size() (n int) { 710 var l int 711 _ = l 712 n += 1 + sovRaft(uint64(m.ID)) 713 n += 1 + sovRaft(uint64(m.Type)) 714 n += 1 + sovRaft(uint64(m.NodeID)) 715 if m.Context != nil { 716 l = len(m.Context) 717 n += 1 + l + sovRaft(uint64(l)) 718 } 719 if m.XXX_unrecognized != nil { 720 n += len(m.XXX_unrecognized) 721 } 722 return n 723} 724 725func sovRaft(x uint64) (n int) { 726 for { 727 n++ 728 x >>= 7 729 if x == 0 { 730 break 731 } 732 } 733 return n 734} 735func sozRaft(x uint64) (n int) { 736 return sovRaft(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 737} 738func (m *Entry) Unmarshal(dAtA []byte) error { 739 l := len(dAtA) 740 iNdEx := 0 741 for iNdEx < l { 742 preIndex := iNdEx 743 var wire uint64 744 for shift := uint(0); ; shift += 7 { 745 if shift >= 64 { 746 return ErrIntOverflowRaft 747 } 748 if iNdEx >= l { 749 return io.ErrUnexpectedEOF 750 } 751 b := dAtA[iNdEx] 752 iNdEx++ 753 wire |= (uint64(b) & 0x7F) << shift 754 if b < 0x80 { 755 break 756 } 757 } 758 fieldNum := int32(wire >> 3) 759 wireType := int(wire & 0x7) 760 if wireType == 4 { 761 return fmt.Errorf("proto: Entry: wiretype end group for non-group") 762 } 763 if fieldNum <= 0 { 764 return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire) 765 } 766 switch fieldNum { 767 case 1: 768 if wireType != 0 { 769 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 770 } 771 m.Type = 0 772 for shift := uint(0); ; shift += 7 { 773 if shift >= 64 { 774 return ErrIntOverflowRaft 775 } 776 if iNdEx >= l { 777 return io.ErrUnexpectedEOF 778 } 779 b := dAtA[iNdEx] 780 iNdEx++ 781 m.Type |= (EntryType(b) & 0x7F) << shift 782 if b < 0x80 { 783 break 784 } 785 } 786 case 2: 787 if wireType != 0 { 788 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) 789 } 790 m.Term = 0 791 for shift := uint(0); ; shift += 7 { 792 if shift >= 64 { 793 return ErrIntOverflowRaft 794 } 795 if iNdEx >= l { 796 return io.ErrUnexpectedEOF 797 } 798 b := dAtA[iNdEx] 799 iNdEx++ 800 m.Term |= (uint64(b) & 0x7F) << shift 801 if b < 0x80 { 802 break 803 } 804 } 805 case 3: 806 if wireType != 0 { 807 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 808 } 809 m.Index = 0 810 for shift := uint(0); ; shift += 7 { 811 if shift >= 64 { 812 return ErrIntOverflowRaft 813 } 814 if iNdEx >= l { 815 return io.ErrUnexpectedEOF 816 } 817 b := dAtA[iNdEx] 818 iNdEx++ 819 m.Index |= (uint64(b) & 0x7F) << shift 820 if b < 0x80 { 821 break 822 } 823 } 824 case 4: 825 if wireType != 2 { 826 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 827 } 828 var byteLen int 829 for shift := uint(0); ; shift += 7 { 830 if shift >= 64 { 831 return ErrIntOverflowRaft 832 } 833 if iNdEx >= l { 834 return io.ErrUnexpectedEOF 835 } 836 b := dAtA[iNdEx] 837 iNdEx++ 838 byteLen |= (int(b) & 0x7F) << shift 839 if b < 0x80 { 840 break 841 } 842 } 843 if byteLen < 0 { 844 return ErrInvalidLengthRaft 845 } 846 postIndex := iNdEx + byteLen 847 if postIndex > l { 848 return io.ErrUnexpectedEOF 849 } 850 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 851 if m.Data == nil { 852 m.Data = []byte{} 853 } 854 iNdEx = postIndex 855 default: 856 iNdEx = preIndex 857 skippy, err := skipRaft(dAtA[iNdEx:]) 858 if err != nil { 859 return err 860 } 861 if skippy < 0 { 862 return ErrInvalidLengthRaft 863 } 864 if (iNdEx + skippy) > l { 865 return io.ErrUnexpectedEOF 866 } 867 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 868 iNdEx += skippy 869 } 870 } 871 872 if iNdEx > l { 873 return io.ErrUnexpectedEOF 874 } 875 return nil 876} 877func (m *SnapshotMetadata) Unmarshal(dAtA []byte) error { 878 l := len(dAtA) 879 iNdEx := 0 880 for iNdEx < l { 881 preIndex := iNdEx 882 var wire uint64 883 for shift := uint(0); ; shift += 7 { 884 if shift >= 64 { 885 return ErrIntOverflowRaft 886 } 887 if iNdEx >= l { 888 return io.ErrUnexpectedEOF 889 } 890 b := dAtA[iNdEx] 891 iNdEx++ 892 wire |= (uint64(b) & 0x7F) << shift 893 if b < 0x80 { 894 break 895 } 896 } 897 fieldNum := int32(wire >> 3) 898 wireType := int(wire & 0x7) 899 if wireType == 4 { 900 return fmt.Errorf("proto: SnapshotMetadata: wiretype end group for non-group") 901 } 902 if fieldNum <= 0 { 903 return fmt.Errorf("proto: SnapshotMetadata: illegal tag %d (wire type %d)", fieldNum, wire) 904 } 905 switch fieldNum { 906 case 1: 907 if wireType != 2 { 908 return fmt.Errorf("proto: wrong wireType = %d for field ConfState", wireType) 909 } 910 var msglen int 911 for shift := uint(0); ; shift += 7 { 912 if shift >= 64 { 913 return ErrIntOverflowRaft 914 } 915 if iNdEx >= l { 916 return io.ErrUnexpectedEOF 917 } 918 b := dAtA[iNdEx] 919 iNdEx++ 920 msglen |= (int(b) & 0x7F) << shift 921 if b < 0x80 { 922 break 923 } 924 } 925 if msglen < 0 { 926 return ErrInvalidLengthRaft 927 } 928 postIndex := iNdEx + msglen 929 if postIndex > l { 930 return io.ErrUnexpectedEOF 931 } 932 if err := m.ConfState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 933 return err 934 } 935 iNdEx = postIndex 936 case 2: 937 if wireType != 0 { 938 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 939 } 940 m.Index = 0 941 for shift := uint(0); ; shift += 7 { 942 if shift >= 64 { 943 return ErrIntOverflowRaft 944 } 945 if iNdEx >= l { 946 return io.ErrUnexpectedEOF 947 } 948 b := dAtA[iNdEx] 949 iNdEx++ 950 m.Index |= (uint64(b) & 0x7F) << shift 951 if b < 0x80 { 952 break 953 } 954 } 955 case 3: 956 if wireType != 0 { 957 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) 958 } 959 m.Term = 0 960 for shift := uint(0); ; shift += 7 { 961 if shift >= 64 { 962 return ErrIntOverflowRaft 963 } 964 if iNdEx >= l { 965 return io.ErrUnexpectedEOF 966 } 967 b := dAtA[iNdEx] 968 iNdEx++ 969 m.Term |= (uint64(b) & 0x7F) << shift 970 if b < 0x80 { 971 break 972 } 973 } 974 default: 975 iNdEx = preIndex 976 skippy, err := skipRaft(dAtA[iNdEx:]) 977 if err != nil { 978 return err 979 } 980 if skippy < 0 { 981 return ErrInvalidLengthRaft 982 } 983 if (iNdEx + skippy) > l { 984 return io.ErrUnexpectedEOF 985 } 986 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 987 iNdEx += skippy 988 } 989 } 990 991 if iNdEx > l { 992 return io.ErrUnexpectedEOF 993 } 994 return nil 995} 996func (m *Snapshot) Unmarshal(dAtA []byte) error { 997 l := len(dAtA) 998 iNdEx := 0 999 for iNdEx < l { 1000 preIndex := iNdEx 1001 var wire uint64 1002 for shift := uint(0); ; shift += 7 { 1003 if shift >= 64 { 1004 return ErrIntOverflowRaft 1005 } 1006 if iNdEx >= l { 1007 return io.ErrUnexpectedEOF 1008 } 1009 b := dAtA[iNdEx] 1010 iNdEx++ 1011 wire |= (uint64(b) & 0x7F) << shift 1012 if b < 0x80 { 1013 break 1014 } 1015 } 1016 fieldNum := int32(wire >> 3) 1017 wireType := int(wire & 0x7) 1018 if wireType == 4 { 1019 return fmt.Errorf("proto: Snapshot: wiretype end group for non-group") 1020 } 1021 if fieldNum <= 0 { 1022 return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire) 1023 } 1024 switch fieldNum { 1025 case 1: 1026 if wireType != 2 { 1027 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 1028 } 1029 var byteLen int 1030 for shift := uint(0); ; shift += 7 { 1031 if shift >= 64 { 1032 return ErrIntOverflowRaft 1033 } 1034 if iNdEx >= l { 1035 return io.ErrUnexpectedEOF 1036 } 1037 b := dAtA[iNdEx] 1038 iNdEx++ 1039 byteLen |= (int(b) & 0x7F) << shift 1040 if b < 0x80 { 1041 break 1042 } 1043 } 1044 if byteLen < 0 { 1045 return ErrInvalidLengthRaft 1046 } 1047 postIndex := iNdEx + byteLen 1048 if postIndex > l { 1049 return io.ErrUnexpectedEOF 1050 } 1051 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 1052 if m.Data == nil { 1053 m.Data = []byte{} 1054 } 1055 iNdEx = postIndex 1056 case 2: 1057 if wireType != 2 { 1058 return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) 1059 } 1060 var msglen int 1061 for shift := uint(0); ; shift += 7 { 1062 if shift >= 64 { 1063 return ErrIntOverflowRaft 1064 } 1065 if iNdEx >= l { 1066 return io.ErrUnexpectedEOF 1067 } 1068 b := dAtA[iNdEx] 1069 iNdEx++ 1070 msglen |= (int(b) & 0x7F) << shift 1071 if b < 0x80 { 1072 break 1073 } 1074 } 1075 if msglen < 0 { 1076 return ErrInvalidLengthRaft 1077 } 1078 postIndex := iNdEx + msglen 1079 if postIndex > l { 1080 return io.ErrUnexpectedEOF 1081 } 1082 if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1083 return err 1084 } 1085 iNdEx = postIndex 1086 default: 1087 iNdEx = preIndex 1088 skippy, err := skipRaft(dAtA[iNdEx:]) 1089 if err != nil { 1090 return err 1091 } 1092 if skippy < 0 { 1093 return ErrInvalidLengthRaft 1094 } 1095 if (iNdEx + skippy) > l { 1096 return io.ErrUnexpectedEOF 1097 } 1098 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1099 iNdEx += skippy 1100 } 1101 } 1102 1103 if iNdEx > l { 1104 return io.ErrUnexpectedEOF 1105 } 1106 return nil 1107} 1108func (m *Message) Unmarshal(dAtA []byte) error { 1109 l := len(dAtA) 1110 iNdEx := 0 1111 for iNdEx < l { 1112 preIndex := iNdEx 1113 var wire uint64 1114 for shift := uint(0); ; shift += 7 { 1115 if shift >= 64 { 1116 return ErrIntOverflowRaft 1117 } 1118 if iNdEx >= l { 1119 return io.ErrUnexpectedEOF 1120 } 1121 b := dAtA[iNdEx] 1122 iNdEx++ 1123 wire |= (uint64(b) & 0x7F) << shift 1124 if b < 0x80 { 1125 break 1126 } 1127 } 1128 fieldNum := int32(wire >> 3) 1129 wireType := int(wire & 0x7) 1130 if wireType == 4 { 1131 return fmt.Errorf("proto: Message: wiretype end group for non-group") 1132 } 1133 if fieldNum <= 0 { 1134 return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) 1135 } 1136 switch fieldNum { 1137 case 1: 1138 if wireType != 0 { 1139 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 1140 } 1141 m.Type = 0 1142 for shift := uint(0); ; shift += 7 { 1143 if shift >= 64 { 1144 return ErrIntOverflowRaft 1145 } 1146 if iNdEx >= l { 1147 return io.ErrUnexpectedEOF 1148 } 1149 b := dAtA[iNdEx] 1150 iNdEx++ 1151 m.Type |= (MessageType(b) & 0x7F) << shift 1152 if b < 0x80 { 1153 break 1154 } 1155 } 1156 case 2: 1157 if wireType != 0 { 1158 return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) 1159 } 1160 m.To = 0 1161 for shift := uint(0); ; shift += 7 { 1162 if shift >= 64 { 1163 return ErrIntOverflowRaft 1164 } 1165 if iNdEx >= l { 1166 return io.ErrUnexpectedEOF 1167 } 1168 b := dAtA[iNdEx] 1169 iNdEx++ 1170 m.To |= (uint64(b) & 0x7F) << shift 1171 if b < 0x80 { 1172 break 1173 } 1174 } 1175 case 3: 1176 if wireType != 0 { 1177 return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) 1178 } 1179 m.From = 0 1180 for shift := uint(0); ; shift += 7 { 1181 if shift >= 64 { 1182 return ErrIntOverflowRaft 1183 } 1184 if iNdEx >= l { 1185 return io.ErrUnexpectedEOF 1186 } 1187 b := dAtA[iNdEx] 1188 iNdEx++ 1189 m.From |= (uint64(b) & 0x7F) << shift 1190 if b < 0x80 { 1191 break 1192 } 1193 } 1194 case 4: 1195 if wireType != 0 { 1196 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) 1197 } 1198 m.Term = 0 1199 for shift := uint(0); ; shift += 7 { 1200 if shift >= 64 { 1201 return ErrIntOverflowRaft 1202 } 1203 if iNdEx >= l { 1204 return io.ErrUnexpectedEOF 1205 } 1206 b := dAtA[iNdEx] 1207 iNdEx++ 1208 m.Term |= (uint64(b) & 0x7F) << shift 1209 if b < 0x80 { 1210 break 1211 } 1212 } 1213 case 5: 1214 if wireType != 0 { 1215 return fmt.Errorf("proto: wrong wireType = %d for field LogTerm", wireType) 1216 } 1217 m.LogTerm = 0 1218 for shift := uint(0); ; shift += 7 { 1219 if shift >= 64 { 1220 return ErrIntOverflowRaft 1221 } 1222 if iNdEx >= l { 1223 return io.ErrUnexpectedEOF 1224 } 1225 b := dAtA[iNdEx] 1226 iNdEx++ 1227 m.LogTerm |= (uint64(b) & 0x7F) << shift 1228 if b < 0x80 { 1229 break 1230 } 1231 } 1232 case 6: 1233 if wireType != 0 { 1234 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 1235 } 1236 m.Index = 0 1237 for shift := uint(0); ; shift += 7 { 1238 if shift >= 64 { 1239 return ErrIntOverflowRaft 1240 } 1241 if iNdEx >= l { 1242 return io.ErrUnexpectedEOF 1243 } 1244 b := dAtA[iNdEx] 1245 iNdEx++ 1246 m.Index |= (uint64(b) & 0x7F) << shift 1247 if b < 0x80 { 1248 break 1249 } 1250 } 1251 case 7: 1252 if wireType != 2 { 1253 return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) 1254 } 1255 var msglen int 1256 for shift := uint(0); ; shift += 7 { 1257 if shift >= 64 { 1258 return ErrIntOverflowRaft 1259 } 1260 if iNdEx >= l { 1261 return io.ErrUnexpectedEOF 1262 } 1263 b := dAtA[iNdEx] 1264 iNdEx++ 1265 msglen |= (int(b) & 0x7F) << shift 1266 if b < 0x80 { 1267 break 1268 } 1269 } 1270 if msglen < 0 { 1271 return ErrInvalidLengthRaft 1272 } 1273 postIndex := iNdEx + msglen 1274 if postIndex > l { 1275 return io.ErrUnexpectedEOF 1276 } 1277 m.Entries = append(m.Entries, Entry{}) 1278 if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1279 return err 1280 } 1281 iNdEx = postIndex 1282 case 8: 1283 if wireType != 0 { 1284 return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) 1285 } 1286 m.Commit = 0 1287 for shift := uint(0); ; shift += 7 { 1288 if shift >= 64 { 1289 return ErrIntOverflowRaft 1290 } 1291 if iNdEx >= l { 1292 return io.ErrUnexpectedEOF 1293 } 1294 b := dAtA[iNdEx] 1295 iNdEx++ 1296 m.Commit |= (uint64(b) & 0x7F) << shift 1297 if b < 0x80 { 1298 break 1299 } 1300 } 1301 case 9: 1302 if wireType != 2 { 1303 return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType) 1304 } 1305 var msglen int 1306 for shift := uint(0); ; shift += 7 { 1307 if shift >= 64 { 1308 return ErrIntOverflowRaft 1309 } 1310 if iNdEx >= l { 1311 return io.ErrUnexpectedEOF 1312 } 1313 b := dAtA[iNdEx] 1314 iNdEx++ 1315 msglen |= (int(b) & 0x7F) << shift 1316 if b < 0x80 { 1317 break 1318 } 1319 } 1320 if msglen < 0 { 1321 return ErrInvalidLengthRaft 1322 } 1323 postIndex := iNdEx + msglen 1324 if postIndex > l { 1325 return io.ErrUnexpectedEOF 1326 } 1327 if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1328 return err 1329 } 1330 iNdEx = postIndex 1331 case 10: 1332 if wireType != 0 { 1333 return fmt.Errorf("proto: wrong wireType = %d for field Reject", wireType) 1334 } 1335 var v int 1336 for shift := uint(0); ; shift += 7 { 1337 if shift >= 64 { 1338 return ErrIntOverflowRaft 1339 } 1340 if iNdEx >= l { 1341 return io.ErrUnexpectedEOF 1342 } 1343 b := dAtA[iNdEx] 1344 iNdEx++ 1345 v |= (int(b) & 0x7F) << shift 1346 if b < 0x80 { 1347 break 1348 } 1349 } 1350 m.Reject = bool(v != 0) 1351 case 11: 1352 if wireType != 0 { 1353 return fmt.Errorf("proto: wrong wireType = %d for field RejectHint", wireType) 1354 } 1355 m.RejectHint = 0 1356 for shift := uint(0); ; shift += 7 { 1357 if shift >= 64 { 1358 return ErrIntOverflowRaft 1359 } 1360 if iNdEx >= l { 1361 return io.ErrUnexpectedEOF 1362 } 1363 b := dAtA[iNdEx] 1364 iNdEx++ 1365 m.RejectHint |= (uint64(b) & 0x7F) << shift 1366 if b < 0x80 { 1367 break 1368 } 1369 } 1370 case 12: 1371 if wireType != 2 { 1372 return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) 1373 } 1374 var byteLen int 1375 for shift := uint(0); ; shift += 7 { 1376 if shift >= 64 { 1377 return ErrIntOverflowRaft 1378 } 1379 if iNdEx >= l { 1380 return io.ErrUnexpectedEOF 1381 } 1382 b := dAtA[iNdEx] 1383 iNdEx++ 1384 byteLen |= (int(b) & 0x7F) << shift 1385 if b < 0x80 { 1386 break 1387 } 1388 } 1389 if byteLen < 0 { 1390 return ErrInvalidLengthRaft 1391 } 1392 postIndex := iNdEx + byteLen 1393 if postIndex > l { 1394 return io.ErrUnexpectedEOF 1395 } 1396 m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) 1397 if m.Context == nil { 1398 m.Context = []byte{} 1399 } 1400 iNdEx = postIndex 1401 default: 1402 iNdEx = preIndex 1403 skippy, err := skipRaft(dAtA[iNdEx:]) 1404 if err != nil { 1405 return err 1406 } 1407 if skippy < 0 { 1408 return ErrInvalidLengthRaft 1409 } 1410 if (iNdEx + skippy) > l { 1411 return io.ErrUnexpectedEOF 1412 } 1413 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1414 iNdEx += skippy 1415 } 1416 } 1417 1418 if iNdEx > l { 1419 return io.ErrUnexpectedEOF 1420 } 1421 return nil 1422} 1423func (m *HardState) Unmarshal(dAtA []byte) error { 1424 l := len(dAtA) 1425 iNdEx := 0 1426 for iNdEx < l { 1427 preIndex := iNdEx 1428 var wire uint64 1429 for shift := uint(0); ; shift += 7 { 1430 if shift >= 64 { 1431 return ErrIntOverflowRaft 1432 } 1433 if iNdEx >= l { 1434 return io.ErrUnexpectedEOF 1435 } 1436 b := dAtA[iNdEx] 1437 iNdEx++ 1438 wire |= (uint64(b) & 0x7F) << shift 1439 if b < 0x80 { 1440 break 1441 } 1442 } 1443 fieldNum := int32(wire >> 3) 1444 wireType := int(wire & 0x7) 1445 if wireType == 4 { 1446 return fmt.Errorf("proto: HardState: wiretype end group for non-group") 1447 } 1448 if fieldNum <= 0 { 1449 return fmt.Errorf("proto: HardState: illegal tag %d (wire type %d)", fieldNum, wire) 1450 } 1451 switch fieldNum { 1452 case 1: 1453 if wireType != 0 { 1454 return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) 1455 } 1456 m.Term = 0 1457 for shift := uint(0); ; shift += 7 { 1458 if shift >= 64 { 1459 return ErrIntOverflowRaft 1460 } 1461 if iNdEx >= l { 1462 return io.ErrUnexpectedEOF 1463 } 1464 b := dAtA[iNdEx] 1465 iNdEx++ 1466 m.Term |= (uint64(b) & 0x7F) << shift 1467 if b < 0x80 { 1468 break 1469 } 1470 } 1471 case 2: 1472 if wireType != 0 { 1473 return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType) 1474 } 1475 m.Vote = 0 1476 for shift := uint(0); ; shift += 7 { 1477 if shift >= 64 { 1478 return ErrIntOverflowRaft 1479 } 1480 if iNdEx >= l { 1481 return io.ErrUnexpectedEOF 1482 } 1483 b := dAtA[iNdEx] 1484 iNdEx++ 1485 m.Vote |= (uint64(b) & 0x7F) << shift 1486 if b < 0x80 { 1487 break 1488 } 1489 } 1490 case 3: 1491 if wireType != 0 { 1492 return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) 1493 } 1494 m.Commit = 0 1495 for shift := uint(0); ; shift += 7 { 1496 if shift >= 64 { 1497 return ErrIntOverflowRaft 1498 } 1499 if iNdEx >= l { 1500 return io.ErrUnexpectedEOF 1501 } 1502 b := dAtA[iNdEx] 1503 iNdEx++ 1504 m.Commit |= (uint64(b) & 0x7F) << shift 1505 if b < 0x80 { 1506 break 1507 } 1508 } 1509 default: 1510 iNdEx = preIndex 1511 skippy, err := skipRaft(dAtA[iNdEx:]) 1512 if err != nil { 1513 return err 1514 } 1515 if skippy < 0 { 1516 return ErrInvalidLengthRaft 1517 } 1518 if (iNdEx + skippy) > l { 1519 return io.ErrUnexpectedEOF 1520 } 1521 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1522 iNdEx += skippy 1523 } 1524 } 1525 1526 if iNdEx > l { 1527 return io.ErrUnexpectedEOF 1528 } 1529 return nil 1530} 1531func (m *ConfState) Unmarshal(dAtA []byte) error { 1532 l := len(dAtA) 1533 iNdEx := 0 1534 for iNdEx < l { 1535 preIndex := iNdEx 1536 var wire uint64 1537 for shift := uint(0); ; shift += 7 { 1538 if shift >= 64 { 1539 return ErrIntOverflowRaft 1540 } 1541 if iNdEx >= l { 1542 return io.ErrUnexpectedEOF 1543 } 1544 b := dAtA[iNdEx] 1545 iNdEx++ 1546 wire |= (uint64(b) & 0x7F) << shift 1547 if b < 0x80 { 1548 break 1549 } 1550 } 1551 fieldNum := int32(wire >> 3) 1552 wireType := int(wire & 0x7) 1553 if wireType == 4 { 1554 return fmt.Errorf("proto: ConfState: wiretype end group for non-group") 1555 } 1556 if fieldNum <= 0 { 1557 return fmt.Errorf("proto: ConfState: illegal tag %d (wire type %d)", fieldNum, wire) 1558 } 1559 switch fieldNum { 1560 case 1: 1561 if wireType == 0 { 1562 var v uint64 1563 for shift := uint(0); ; shift += 7 { 1564 if shift >= 64 { 1565 return ErrIntOverflowRaft 1566 } 1567 if iNdEx >= l { 1568 return io.ErrUnexpectedEOF 1569 } 1570 b := dAtA[iNdEx] 1571 iNdEx++ 1572 v |= (uint64(b) & 0x7F) << shift 1573 if b < 0x80 { 1574 break 1575 } 1576 } 1577 m.Nodes = append(m.Nodes, v) 1578 } else if wireType == 2 { 1579 var packedLen int 1580 for shift := uint(0); ; shift += 7 { 1581 if shift >= 64 { 1582 return ErrIntOverflowRaft 1583 } 1584 if iNdEx >= l { 1585 return io.ErrUnexpectedEOF 1586 } 1587 b := dAtA[iNdEx] 1588 iNdEx++ 1589 packedLen |= (int(b) & 0x7F) << shift 1590 if b < 0x80 { 1591 break 1592 } 1593 } 1594 if packedLen < 0 { 1595 return ErrInvalidLengthRaft 1596 } 1597 postIndex := iNdEx + packedLen 1598 if postIndex > l { 1599 return io.ErrUnexpectedEOF 1600 } 1601 for iNdEx < postIndex { 1602 var v uint64 1603 for shift := uint(0); ; shift += 7 { 1604 if shift >= 64 { 1605 return ErrIntOverflowRaft 1606 } 1607 if iNdEx >= l { 1608 return io.ErrUnexpectedEOF 1609 } 1610 b := dAtA[iNdEx] 1611 iNdEx++ 1612 v |= (uint64(b) & 0x7F) << shift 1613 if b < 0x80 { 1614 break 1615 } 1616 } 1617 m.Nodes = append(m.Nodes, v) 1618 } 1619 } else { 1620 return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType) 1621 } 1622 default: 1623 iNdEx = preIndex 1624 skippy, err := skipRaft(dAtA[iNdEx:]) 1625 if err != nil { 1626 return err 1627 } 1628 if skippy < 0 { 1629 return ErrInvalidLengthRaft 1630 } 1631 if (iNdEx + skippy) > l { 1632 return io.ErrUnexpectedEOF 1633 } 1634 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1635 iNdEx += skippy 1636 } 1637 } 1638 1639 if iNdEx > l { 1640 return io.ErrUnexpectedEOF 1641 } 1642 return nil 1643} 1644func (m *ConfChange) Unmarshal(dAtA []byte) error { 1645 l := len(dAtA) 1646 iNdEx := 0 1647 for iNdEx < l { 1648 preIndex := iNdEx 1649 var wire uint64 1650 for shift := uint(0); ; shift += 7 { 1651 if shift >= 64 { 1652 return ErrIntOverflowRaft 1653 } 1654 if iNdEx >= l { 1655 return io.ErrUnexpectedEOF 1656 } 1657 b := dAtA[iNdEx] 1658 iNdEx++ 1659 wire |= (uint64(b) & 0x7F) << shift 1660 if b < 0x80 { 1661 break 1662 } 1663 } 1664 fieldNum := int32(wire >> 3) 1665 wireType := int(wire & 0x7) 1666 if wireType == 4 { 1667 return fmt.Errorf("proto: ConfChange: wiretype end group for non-group") 1668 } 1669 if fieldNum <= 0 { 1670 return fmt.Errorf("proto: ConfChange: illegal tag %d (wire type %d)", fieldNum, wire) 1671 } 1672 switch fieldNum { 1673 case 1: 1674 if wireType != 0 { 1675 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 1676 } 1677 m.ID = 0 1678 for shift := uint(0); ; shift += 7 { 1679 if shift >= 64 { 1680 return ErrIntOverflowRaft 1681 } 1682 if iNdEx >= l { 1683 return io.ErrUnexpectedEOF 1684 } 1685 b := dAtA[iNdEx] 1686 iNdEx++ 1687 m.ID |= (uint64(b) & 0x7F) << shift 1688 if b < 0x80 { 1689 break 1690 } 1691 } 1692 case 2: 1693 if wireType != 0 { 1694 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 1695 } 1696 m.Type = 0 1697 for shift := uint(0); ; shift += 7 { 1698 if shift >= 64 { 1699 return ErrIntOverflowRaft 1700 } 1701 if iNdEx >= l { 1702 return io.ErrUnexpectedEOF 1703 } 1704 b := dAtA[iNdEx] 1705 iNdEx++ 1706 m.Type |= (ConfChangeType(b) & 0x7F) << shift 1707 if b < 0x80 { 1708 break 1709 } 1710 } 1711 case 3: 1712 if wireType != 0 { 1713 return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType) 1714 } 1715 m.NodeID = 0 1716 for shift := uint(0); ; shift += 7 { 1717 if shift >= 64 { 1718 return ErrIntOverflowRaft 1719 } 1720 if iNdEx >= l { 1721 return io.ErrUnexpectedEOF 1722 } 1723 b := dAtA[iNdEx] 1724 iNdEx++ 1725 m.NodeID |= (uint64(b) & 0x7F) << shift 1726 if b < 0x80 { 1727 break 1728 } 1729 } 1730 case 4: 1731 if wireType != 2 { 1732 return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) 1733 } 1734 var byteLen int 1735 for shift := uint(0); ; shift += 7 { 1736 if shift >= 64 { 1737 return ErrIntOverflowRaft 1738 } 1739 if iNdEx >= l { 1740 return io.ErrUnexpectedEOF 1741 } 1742 b := dAtA[iNdEx] 1743 iNdEx++ 1744 byteLen |= (int(b) & 0x7F) << shift 1745 if b < 0x80 { 1746 break 1747 } 1748 } 1749 if byteLen < 0 { 1750 return ErrInvalidLengthRaft 1751 } 1752 postIndex := iNdEx + byteLen 1753 if postIndex > l { 1754 return io.ErrUnexpectedEOF 1755 } 1756 m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...) 1757 if m.Context == nil { 1758 m.Context = []byte{} 1759 } 1760 iNdEx = postIndex 1761 default: 1762 iNdEx = preIndex 1763 skippy, err := skipRaft(dAtA[iNdEx:]) 1764 if err != nil { 1765 return err 1766 } 1767 if skippy < 0 { 1768 return ErrInvalidLengthRaft 1769 } 1770 if (iNdEx + skippy) > l { 1771 return io.ErrUnexpectedEOF 1772 } 1773 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1774 iNdEx += skippy 1775 } 1776 } 1777 1778 if iNdEx > l { 1779 return io.ErrUnexpectedEOF 1780 } 1781 return nil 1782} 1783func skipRaft(dAtA []byte) (n int, err error) { 1784 l := len(dAtA) 1785 iNdEx := 0 1786 for iNdEx < l { 1787 var wire uint64 1788 for shift := uint(0); ; shift += 7 { 1789 if shift >= 64 { 1790 return 0, ErrIntOverflowRaft 1791 } 1792 if iNdEx >= l { 1793 return 0, io.ErrUnexpectedEOF 1794 } 1795 b := dAtA[iNdEx] 1796 iNdEx++ 1797 wire |= (uint64(b) & 0x7F) << shift 1798 if b < 0x80 { 1799 break 1800 } 1801 } 1802 wireType := int(wire & 0x7) 1803 switch wireType { 1804 case 0: 1805 for shift := uint(0); ; shift += 7 { 1806 if shift >= 64 { 1807 return 0, ErrIntOverflowRaft 1808 } 1809 if iNdEx >= l { 1810 return 0, io.ErrUnexpectedEOF 1811 } 1812 iNdEx++ 1813 if dAtA[iNdEx-1] < 0x80 { 1814 break 1815 } 1816 } 1817 return iNdEx, nil 1818 case 1: 1819 iNdEx += 8 1820 return iNdEx, nil 1821 case 2: 1822 var length int 1823 for shift := uint(0); ; shift += 7 { 1824 if shift >= 64 { 1825 return 0, ErrIntOverflowRaft 1826 } 1827 if iNdEx >= l { 1828 return 0, io.ErrUnexpectedEOF 1829 } 1830 b := dAtA[iNdEx] 1831 iNdEx++ 1832 length |= (int(b) & 0x7F) << shift 1833 if b < 0x80 { 1834 break 1835 } 1836 } 1837 iNdEx += length 1838 if length < 0 { 1839 return 0, ErrInvalidLengthRaft 1840 } 1841 return iNdEx, nil 1842 case 3: 1843 for { 1844 var innerWire uint64 1845 var start int = iNdEx 1846 for shift := uint(0); ; shift += 7 { 1847 if shift >= 64 { 1848 return 0, ErrIntOverflowRaft 1849 } 1850 if iNdEx >= l { 1851 return 0, io.ErrUnexpectedEOF 1852 } 1853 b := dAtA[iNdEx] 1854 iNdEx++ 1855 innerWire |= (uint64(b) & 0x7F) << shift 1856 if b < 0x80 { 1857 break 1858 } 1859 } 1860 innerWireType := int(innerWire & 0x7) 1861 if innerWireType == 4 { 1862 break 1863 } 1864 next, err := skipRaft(dAtA[start:]) 1865 if err != nil { 1866 return 0, err 1867 } 1868 iNdEx = start + next 1869 } 1870 return iNdEx, nil 1871 case 4: 1872 return iNdEx, nil 1873 case 5: 1874 iNdEx += 4 1875 return iNdEx, nil 1876 default: 1877 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1878 } 1879 } 1880 panic("unreachable") 1881} 1882 1883var ( 1884 ErrInvalidLengthRaft = fmt.Errorf("proto: negative length found during unmarshaling") 1885 ErrIntOverflowRaft = fmt.Errorf("proto: integer overflow") 1886) 1887 1888func init() { proto.RegisterFile("raft.proto", fileDescriptorRaft) } 1889 1890var fileDescriptorRaft = []byte{ 1891 // 790 bytes of a gzipped FileDescriptorProto 1892 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x54, 0xcd, 0x6e, 0xdb, 0x46, 1893 0x10, 0x16, 0x29, 0xea, 0x6f, 0x28, 0xcb, 0xab, 0xb5, 0x5a, 0x2c, 0x0c, 0x43, 0x55, 0x85, 0x1e, 1894 0x04, 0x17, 0x76, 0x5b, 0x1d, 0x7a, 0xe8, 0xcd, 0x96, 0x0a, 0x58, 0x40, 0x65, 0xb8, 0xb2, 0xdc, 1895 0x43, 0x83, 0x20, 0x58, 0x8b, 0x2b, 0x4a, 0x89, 0xc9, 0x25, 0x96, 0x2b, 0xc7, 0xbe, 0x04, 0x79, 1896 0x80, 0x3c, 0x40, 0x2e, 0x79, 0x1f, 0x1f, 0x0d, 0xe4, 0x1e, 0xc4, 0xce, 0x8b, 0x04, 0xbb, 0x5c, 1897 0x4a, 0x94, 0x74, 0xdb, 0xf9, 0xbe, 0xe1, 0xcc, 0x37, 0xdf, 0xce, 0x12, 0x40, 0xd0, 0xa9, 0x3c, 1898 0x8e, 0x04, 0x97, 0x1c, 0x17, 0xd5, 0x39, 0xba, 0xde, 0x6f, 0xf8, 0xdc, 0xe7, 0x1a, 0xfa, 0x4d, 1899 0x9d, 0x12, 0xb6, 0xfd, 0x0e, 0x0a, 0x7f, 0x87, 0x52, 0xdc, 0xe3, 0x5f, 0xc1, 0x19, 0xdf, 0x47, 1900 0x8c, 0x58, 0x2d, 0xab, 0x53, 0xeb, 0xd6, 0x8f, 0x93, 0xaf, 0x8e, 0x35, 0xa9, 0x88, 0x53, 0xe7, 1901 0xe1, 0xcb, 0x4f, 0xb9, 0x91, 0x4e, 0xc2, 0x04, 0x9c, 0x31, 0x13, 0x01, 0xb1, 0x5b, 0x56, 0xc7, 1902 0x59, 0x32, 0x4c, 0x04, 0x78, 0x1f, 0x0a, 0x83, 0xd0, 0x63, 0x77, 0x24, 0x9f, 0xa1, 0x12, 0x08, 1903 0x63, 0x70, 0xfa, 0x54, 0x52, 0xe2, 0xb4, 0xac, 0x4e, 0x75, 0xa4, 0xcf, 0xed, 0xf7, 0x16, 0xa0, 1904 0xcb, 0x90, 0x46, 0xf1, 0x8c, 0xcb, 0x21, 0x93, 0xd4, 0xa3, 0x92, 0xe2, 0x3f, 0x01, 0x26, 0x3c, 1905 0x9c, 0xbe, 0x8a, 0x25, 0x95, 0x89, 0x22, 0x77, 0xa5, 0xa8, 0xc7, 0xc3, 0xe9, 0xa5, 0x22, 0x4c, 1906 0xf1, 0xca, 0x24, 0x05, 0x54, 0xf3, 0xb9, 0x6e, 0x9e, 0xd5, 0x95, 0x40, 0x4a, 0xb2, 0x54, 0x92, 1907 0xb3, 0xba, 0x34, 0xd2, 0xfe, 0x1f, 0xca, 0xa9, 0x02, 0x25, 0x51, 0x29, 0xd0, 0x3d, 0xab, 0x23, 1908 0x7d, 0xc6, 0x7f, 0x41, 0x39, 0x30, 0xca, 0x74, 0x61, 0xb7, 0x4b, 0x52, 0x2d, 0x9b, 0xca, 0x4d, 1909 0xdd, 0x65, 0x7e, 0xfb, 0x53, 0x1e, 0x4a, 0x43, 0x16, 0xc7, 0xd4, 0x67, 0xf8, 0x08, 0x1c, 0xb9, 1910 0x72, 0x78, 0x2f, 0xad, 0x61, 0xe8, 0xac, 0xc7, 0x2a, 0x0d, 0x37, 0xc0, 0x96, 0x7c, 0x6d, 0x12, 1911 0x5b, 0x72, 0x35, 0xc6, 0x54, 0xf0, 0x8d, 0x31, 0x14, 0xb2, 0x1c, 0xd0, 0xd9, 0x1c, 0x10, 0x37, 1912 0xa1, 0x74, 0xc3, 0x7d, 0x7d, 0x61, 0x85, 0x0c, 0x99, 0x82, 0x2b, 0xdb, 0x8a, 0xdb, 0xb6, 0x1d, 1913 0x41, 0x89, 0x85, 0x52, 0xcc, 0x59, 0x4c, 0x4a, 0xad, 0x7c, 0xc7, 0xed, 0xee, 0xac, 0x6d, 0x46, 1914 0x5a, 0xca, 0xe4, 0xe0, 0x03, 0x28, 0x4e, 0x78, 0x10, 0xcc, 0x25, 0x29, 0x67, 0x6a, 0x19, 0x0c, 1915 0x77, 0xa1, 0x1c, 0x1b, 0xc7, 0x48, 0x45, 0x3b, 0x89, 0x36, 0x9d, 0x4c, 0x1d, 0x4c, 0xf3, 0x54, 1916 0x45, 0xc1, 0x5e, 0xb3, 0x89, 0x24, 0xd0, 0xb2, 0x3a, 0xe5, 0xb4, 0x62, 0x82, 0xe1, 0x5f, 0x00, 1917 0x92, 0xd3, 0xd9, 0x3c, 0x94, 0xc4, 0xcd, 0xf4, 0xcc, 0xe0, 0x98, 0x40, 0x69, 0xc2, 0x43, 0xc9, 1918 0xee, 0x24, 0xa9, 0xea, 0x8b, 0x4d, 0xc3, 0xf6, 0x4b, 0xa8, 0x9c, 0x51, 0xe1, 0x25, 0xeb, 0x93, 1919 0x3a, 0x68, 0x6d, 0x39, 0x48, 0xc0, 0xb9, 0xe5, 0x92, 0xad, 0xef, 0xbb, 0x42, 0x32, 0x03, 0xe7, 1920 0xb7, 0x07, 0x6e, 0xff, 0x0c, 0x95, 0xe5, 0xba, 0xe2, 0x06, 0x14, 0x42, 0xee, 0xb1, 0x98, 0x58, 1921 0xad, 0x7c, 0xc7, 0x19, 0x25, 0x41, 0xfb, 0x83, 0x05, 0xa0, 0x72, 0x7a, 0x33, 0x1a, 0xfa, 0xfa, 1922 0xd6, 0x07, 0xfd, 0x35, 0x05, 0xf6, 0xa0, 0x8f, 0x7f, 0x37, 0x8f, 0xd3, 0xd6, 0xab, 0xf3, 0x63, 1923 0xf6, 0x29, 0x24, 0xdf, 0x6d, 0xbd, 0xd0, 0x03, 0x28, 0x9e, 0x73, 0x8f, 0x0d, 0xfa, 0xeb, 0xba, 1924 0x12, 0x4c, 0x19, 0xd2, 0x33, 0x86, 0x24, 0x8f, 0x31, 0x0d, 0x0f, 0xff, 0x80, 0xca, 0xf2, 0xc9, 1925 0xe3, 0x5d, 0x70, 0x75, 0x70, 0xce, 0x45, 0x40, 0x6f, 0x50, 0x0e, 0xef, 0xc1, 0xae, 0x06, 0x56, 1926 0x8d, 0x91, 0x75, 0xf8, 0xd9, 0x06, 0x37, 0xb3, 0xc4, 0x18, 0xa0, 0x38, 0x8c, 0xfd, 0xb3, 0x45, 1927 0x84, 0x72, 0xd8, 0x85, 0xd2, 0x30, 0xf6, 0x4f, 0x19, 0x95, 0xc8, 0x32, 0xc1, 0x85, 0xe0, 0x11, 1928 0xb2, 0x4d, 0xd6, 0x49, 0x14, 0xa1, 0x3c, 0xae, 0x01, 0x24, 0xe7, 0x11, 0x8b, 0x23, 0xe4, 0x98, 1929 0xc4, 0xff, 0xb8, 0x64, 0xa8, 0xa0, 0x44, 0x98, 0x40, 0xb3, 0x45, 0xc3, 0xaa, 0x85, 0x41, 0x25, 1930 0x8c, 0xa0, 0xaa, 0x9a, 0x31, 0x2a, 0xe4, 0xb5, 0xea, 0x52, 0xc6, 0x0d, 0x40, 0x59, 0x44, 0x7f, 1931 0x54, 0xc1, 0x18, 0x6a, 0xc3, 0xd8, 0xbf, 0x0a, 0x05, 0xa3, 0x93, 0x19, 0xbd, 0xbe, 0x61, 0x08, 1932 0x70, 0x1d, 0x76, 0x4c, 0x21, 0x75, 0x41, 0x8b, 0x18, 0xb9, 0x26, 0xad, 0x37, 0x63, 0x93, 0x37, 1933 0xff, 0x2e, 0xb8, 0x58, 0x04, 0xa8, 0x8a, 0x7f, 0x80, 0xfa, 0x30, 0xf6, 0xc7, 0x82, 0x86, 0xf1, 1934 0x94, 0x89, 0x7f, 0x18, 0xf5, 0x98, 0x40, 0x3b, 0xe6, 0xeb, 0xf1, 0x3c, 0x60, 0x7c, 0x21, 0xcf, 1935 0xf9, 0x5b, 0x54, 0x33, 0x62, 0x46, 0x8c, 0x7a, 0xfa, 0x87, 0x87, 0x76, 0x8d, 0x98, 0x25, 0xa2, 1936 0xc5, 0x20, 0x33, 0xef, 0x85, 0x60, 0x7a, 0xc4, 0xba, 0xe9, 0x6a, 0x62, 0x9d, 0x83, 0x0f, 0x5f, 1937 0x40, 0x6d, 0xfd, 0x7a, 0x95, 0x8e, 0x15, 0x72, 0xe2, 0x79, 0xea, 0x2e, 0x51, 0x0e, 0x13, 0x68, 1938 0xac, 0xe0, 0x11, 0x0b, 0xf8, 0x2d, 0xd3, 0x8c, 0xb5, 0xce, 0x5c, 0x45, 0x1e, 0x95, 0x09, 0x63, 1939 0x9f, 0x92, 0x87, 0xa7, 0x66, 0xee, 0xf1, 0xa9, 0x99, 0x7b, 0x78, 0x6e, 0x5a, 0x8f, 0xcf, 0x4d, 1940 0xeb, 0xeb, 0x73, 0xd3, 0xfa, 0xf8, 0xad, 0x99, 0xfb, 0x1e, 0x00, 0x00, 0xff, 0xff, 0xcf, 0x30, 1941 0x01, 0x41, 0x3a, 0x06, 0x00, 0x00, 1942} 1943