mirror of
https://github.com/etcd-io/etcd.git
synced 2024-09-27 06:25:44 +00:00
5967794009
Users might want to update the peerurl of the etcd member in several cases. For example, if the IP address of the physical machine etcd running on is changed, user need to update the adversite-pee-rurl accordingly. This commit makes etcd support updating the advertise-peer-url of its members.
1177 lines
26 KiB
Go
1177 lines
26 KiB
Go
// Code generated by protoc-gen-gogo.
|
|
// source: raft.proto
|
|
// DO NOT EDIT!
|
|
|
|
/*
|
|
Package raftpb is a generated protocol buffer package.
|
|
|
|
It is generated from these files:
|
|
raft.proto
|
|
|
|
It has these top-level messages:
|
|
Entry
|
|
Snapshot
|
|
Message
|
|
HardState
|
|
ConfChange
|
|
*/
|
|
package raftpb
|
|
|
|
import proto "github.com/coreos/etcd/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/proto"
|
|
import json "encoding/json"
|
|
import math "math"
|
|
|
|
// discarding unused import gogoproto "code.google.com/p/gogoprotobuf/gogoproto/gogo.pb"
|
|
|
|
import io "io"
|
|
import code_google_com_p_gogoprotobuf_proto "github.com/coreos/etcd/Godeps/_workspace/src/code.google.com/p/gogoprotobuf/proto"
|
|
|
|
// Reference proto, json, and math imports to suppress error if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = &json.SyntaxError{}
|
|
var _ = math.Inf
|
|
|
|
type EntryType int32
|
|
|
|
const (
|
|
EntryNormal EntryType = 0
|
|
EntryConfChange EntryType = 1
|
|
)
|
|
|
|
var EntryType_name = map[int32]string{
|
|
0: "EntryNormal",
|
|
1: "EntryConfChange",
|
|
}
|
|
var EntryType_value = map[string]int32{
|
|
"EntryNormal": 0,
|
|
"EntryConfChange": 1,
|
|
}
|
|
|
|
func (x EntryType) Enum() *EntryType {
|
|
p := new(EntryType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x EntryType) String() string {
|
|
return proto.EnumName(EntryType_name, int32(x))
|
|
}
|
|
func (x *EntryType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(EntryType_value, data, "EntryType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = EntryType(value)
|
|
return nil
|
|
}
|
|
|
|
type MessageType int32
|
|
|
|
const (
|
|
MsgHup MessageType = 0
|
|
MsgBeat MessageType = 1
|
|
MsgProp MessageType = 2
|
|
MsgApp MessageType = 3
|
|
MsgAppResp MessageType = 4
|
|
MsgVote MessageType = 5
|
|
MsgVoteResp MessageType = 6
|
|
MsgSnap MessageType = 7
|
|
)
|
|
|
|
var MessageType_name = map[int32]string{
|
|
0: "MsgHup",
|
|
1: "MsgBeat",
|
|
2: "MsgProp",
|
|
3: "MsgApp",
|
|
4: "MsgAppResp",
|
|
5: "MsgVote",
|
|
6: "MsgVoteResp",
|
|
7: "MsgSnap",
|
|
}
|
|
var MessageType_value = map[string]int32{
|
|
"MsgHup": 0,
|
|
"MsgBeat": 1,
|
|
"MsgProp": 2,
|
|
"MsgApp": 3,
|
|
"MsgAppResp": 4,
|
|
"MsgVote": 5,
|
|
"MsgVoteResp": 6,
|
|
"MsgSnap": 7,
|
|
}
|
|
|
|
func (x MessageType) Enum() *MessageType {
|
|
p := new(MessageType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x MessageType) String() string {
|
|
return proto.EnumName(MessageType_name, int32(x))
|
|
}
|
|
func (x *MessageType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MessageType(value)
|
|
return nil
|
|
}
|
|
|
|
type ConfChangeType int32
|
|
|
|
const (
|
|
ConfChangeAddNode ConfChangeType = 0
|
|
ConfChangeRemoveNode ConfChangeType = 1
|
|
ConfChangeUpdateNode ConfChangeType = 2
|
|
)
|
|
|
|
var ConfChangeType_name = map[int32]string{
|
|
0: "ConfChangeAddNode",
|
|
1: "ConfChangeRemoveNode",
|
|
2: "ConfChangeUpdateNode",
|
|
}
|
|
var ConfChangeType_value = map[string]int32{
|
|
"ConfChangeAddNode": 0,
|
|
"ConfChangeRemoveNode": 1,
|
|
"ConfChangeUpdateNode": 2,
|
|
}
|
|
|
|
func (x ConfChangeType) Enum() *ConfChangeType {
|
|
p := new(ConfChangeType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x ConfChangeType) String() string {
|
|
return proto.EnumName(ConfChangeType_name, int32(x))
|
|
}
|
|
func (x *ConfChangeType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(ConfChangeType_value, data, "ConfChangeType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = ConfChangeType(value)
|
|
return nil
|
|
}
|
|
|
|
type Entry struct {
|
|
Type EntryType `protobuf:"varint,1,req,enum=raftpb.EntryType" json:"Type"`
|
|
Term uint64 `protobuf:"varint,2,req" json:"Term"`
|
|
Index uint64 `protobuf:"varint,3,req" json:"Index"`
|
|
Data []byte `protobuf:"bytes,4,opt" json:"Data"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Entry) Reset() { *m = Entry{} }
|
|
func (m *Entry) String() string { return proto.CompactTextString(m) }
|
|
func (*Entry) ProtoMessage() {}
|
|
|
|
type Snapshot struct {
|
|
Data []byte `protobuf:"bytes,1,req,name=data" json:"data"`
|
|
Nodes []uint64 `protobuf:"varint,2,rep,name=nodes" json:"nodes"`
|
|
Index uint64 `protobuf:"varint,3,req,name=index" json:"index"`
|
|
Term uint64 `protobuf:"varint,4,req,name=term" json:"term"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Snapshot) Reset() { *m = Snapshot{} }
|
|
func (m *Snapshot) String() string { return proto.CompactTextString(m) }
|
|
func (*Snapshot) ProtoMessage() {}
|
|
|
|
type Message struct {
|
|
Type MessageType `protobuf:"varint,1,req,name=type,enum=raftpb.MessageType" json:"type"`
|
|
To uint64 `protobuf:"varint,2,req,name=to" json:"to"`
|
|
From uint64 `protobuf:"varint,3,req,name=from" json:"from"`
|
|
Term uint64 `protobuf:"varint,4,req,name=term" json:"term"`
|
|
LogTerm uint64 `protobuf:"varint,5,req,name=logTerm" json:"logTerm"`
|
|
Index uint64 `protobuf:"varint,6,req,name=index" json:"index"`
|
|
Entries []Entry `protobuf:"bytes,7,rep,name=entries" json:"entries"`
|
|
Commit uint64 `protobuf:"varint,8,req,name=commit" json:"commit"`
|
|
Snapshot Snapshot `protobuf:"bytes,9,req,name=snapshot" json:"snapshot"`
|
|
Reject bool `protobuf:"varint,10,req,name=reject" json:"reject"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Message) Reset() { *m = Message{} }
|
|
func (m *Message) String() string { return proto.CompactTextString(m) }
|
|
func (*Message) ProtoMessage() {}
|
|
|
|
type HardState struct {
|
|
Term uint64 `protobuf:"varint,1,req,name=term" json:"term"`
|
|
Vote uint64 `protobuf:"varint,2,req,name=vote" json:"vote"`
|
|
Commit uint64 `protobuf:"varint,3,req,name=commit" json:"commit"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *HardState) Reset() { *m = HardState{} }
|
|
func (m *HardState) String() string { return proto.CompactTextString(m) }
|
|
func (*HardState) ProtoMessage() {}
|
|
|
|
type ConfChange struct {
|
|
ID uint64 `protobuf:"varint,1,req" json:"ID"`
|
|
Type ConfChangeType `protobuf:"varint,2,req,enum=raftpb.ConfChangeType" json:"Type"`
|
|
NodeID uint64 `protobuf:"varint,3,req" json:"NodeID"`
|
|
Context []byte `protobuf:"bytes,4,opt" json:"Context"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *ConfChange) Reset() { *m = ConfChange{} }
|
|
func (m *ConfChange) String() string { return proto.CompactTextString(m) }
|
|
func (*ConfChange) ProtoMessage() {}
|
|
|
|
func init() {
|
|
proto.RegisterEnum("raftpb.EntryType", EntryType_name, EntryType_value)
|
|
proto.RegisterEnum("raftpb.MessageType", MessageType_name, MessageType_value)
|
|
proto.RegisterEnum("raftpb.ConfChangeType", ConfChangeType_name, ConfChangeType_value)
|
|
}
|
|
func (m *Entry) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
index := 0
|
|
for index < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Type |= (EntryType(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Term |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Index |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 2 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
postIndex := index + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Data = append(m.Data, data[index:postIndex]...)
|
|
index = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
index -= sizeOfWire
|
|
skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (index + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
|
|
index += skippy
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Snapshot) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
index := 0
|
|
for index < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
postIndex := index + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Data = append(m.Data, data[index:postIndex]...)
|
|
index = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Nodes = append(m.Nodes, v)
|
|
case 3:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Index |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Term |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
index -= sizeOfWire
|
|
skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (index + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
|
|
index += skippy
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Message) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
index := 0
|
|
for index < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Type |= (MessageType(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.To |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.From |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Term |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.LogTerm |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 6:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Index |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 7:
|
|
if wireType != 2 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
postIndex := index + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Entries = append(m.Entries, Entry{})
|
|
m.Entries[len(m.Entries)-1].Unmarshal(data[index:postIndex])
|
|
index = postIndex
|
|
case 8:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Commit |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 9:
|
|
if wireType != 2 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
postIndex := index + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := m.Snapshot.Unmarshal(data[index:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
index = postIndex
|
|
case 10:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Reject = bool(v != 0)
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
index -= sizeOfWire
|
|
skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (index + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
|
|
index += skippy
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (m *HardState) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
index := 0
|
|
for index < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Term |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Vote |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Commit |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
index -= sizeOfWire
|
|
skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (index + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
|
|
index += skippy
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ConfChange) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
index := 0
|
|
for index < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.ID |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.Type |= (ConfChangeType(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
m.NodeID |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 2 {
|
|
return code_google_com_p_gogoprotobuf_proto.ErrWrongType
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
postIndex := index + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Context = append(m.Context, data[index:postIndex]...)
|
|
index = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
index -= sizeOfWire
|
|
skippy, err := code_google_com_p_gogoprotobuf_proto.Skip(data[index:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (index + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[index:index+skippy]...)
|
|
index += skippy
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Entry) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovRaft(uint64(m.Type))
|
|
n += 1 + sovRaft(uint64(m.Term))
|
|
n += 1 + sovRaft(uint64(m.Index))
|
|
l = len(m.Data)
|
|
n += 1 + l + sovRaft(uint64(l))
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
func (m *Snapshot) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
l = len(m.Data)
|
|
n += 1 + l + sovRaft(uint64(l))
|
|
if len(m.Nodes) > 0 {
|
|
for _, e := range m.Nodes {
|
|
n += 1 + sovRaft(uint64(e))
|
|
}
|
|
}
|
|
n += 1 + sovRaft(uint64(m.Index))
|
|
n += 1 + sovRaft(uint64(m.Term))
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
func (m *Message) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovRaft(uint64(m.Type))
|
|
n += 1 + sovRaft(uint64(m.To))
|
|
n += 1 + sovRaft(uint64(m.From))
|
|
n += 1 + sovRaft(uint64(m.Term))
|
|
n += 1 + sovRaft(uint64(m.LogTerm))
|
|
n += 1 + sovRaft(uint64(m.Index))
|
|
if len(m.Entries) > 0 {
|
|
for _, e := range m.Entries {
|
|
l = e.Size()
|
|
n += 1 + l + sovRaft(uint64(l))
|
|
}
|
|
}
|
|
n += 1 + sovRaft(uint64(m.Commit))
|
|
l = m.Snapshot.Size()
|
|
n += 1 + l + sovRaft(uint64(l))
|
|
n += 2
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
func (m *HardState) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovRaft(uint64(m.Term))
|
|
n += 1 + sovRaft(uint64(m.Vote))
|
|
n += 1 + sovRaft(uint64(m.Commit))
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
func (m *ConfChange) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovRaft(uint64(m.ID))
|
|
n += 1 + sovRaft(uint64(m.Type))
|
|
n += 1 + sovRaft(uint64(m.NodeID))
|
|
l = len(m.Context)
|
|
n += 1 + l + sovRaft(uint64(l))
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovRaft(x uint64) (n int) {
|
|
for {
|
|
n++
|
|
x >>= 7
|
|
if x == 0 {
|
|
break
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
func sozRaft(x uint64) (n int) {
|
|
return sovRaft(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *Entry) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *Entry) MarshalTo(data []byte) (n int, err error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Type))
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Term))
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Index))
|
|
data[i] = 0x22
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(len(m.Data)))
|
|
i += copy(data[i:], m.Data)
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *Snapshot) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *Snapshot) MarshalTo(data []byte) (n int, err error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(len(m.Data)))
|
|
i += copy(data[i:], m.Data)
|
|
if len(m.Nodes) > 0 {
|
|
for _, num := range m.Nodes {
|
|
data[i] = 0x10
|
|
i++
|
|
for num >= 1<<7 {
|
|
data[i] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
i++
|
|
}
|
|
data[i] = uint8(num)
|
|
i++
|
|
}
|
|
}
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Index))
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Term))
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *Message) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *Message) MarshalTo(data []byte) (n int, err error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Type))
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.To))
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.From))
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Term))
|
|
data[i] = 0x28
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.LogTerm))
|
|
data[i] = 0x30
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Index))
|
|
if len(m.Entries) > 0 {
|
|
for _, msg := range m.Entries {
|
|
data[i] = 0x3a
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
data[i] = 0x40
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Commit))
|
|
data[i] = 0x4a
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Snapshot.Size()))
|
|
n1, err := m.Snapshot.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n1
|
|
data[i] = 0x50
|
|
i++
|
|
if m.Reject {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *HardState) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *HardState) MarshalTo(data []byte) (n int, err error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Term))
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Vote))
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Commit))
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *ConfChange) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *ConfChange) MarshalTo(data []byte) (n int, err error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.ID))
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.Type))
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.NodeID))
|
|
data[i] = 0x22
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(len(m.Context)))
|
|
i += copy(data[i:], m.Context)
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
func encodeFixed64Raft(data []byte, offset int, v uint64) int {
|
|
data[offset] = uint8(v)
|
|
data[offset+1] = uint8(v >> 8)
|
|
data[offset+2] = uint8(v >> 16)
|
|
data[offset+3] = uint8(v >> 24)
|
|
data[offset+4] = uint8(v >> 32)
|
|
data[offset+5] = uint8(v >> 40)
|
|
data[offset+6] = uint8(v >> 48)
|
|
data[offset+7] = uint8(v >> 56)
|
|
return offset + 8
|
|
}
|
|
func encodeFixed32Raft(data []byte, offset int, v uint32) int {
|
|
data[offset] = uint8(v)
|
|
data[offset+1] = uint8(v >> 8)
|
|
data[offset+2] = uint8(v >> 16)
|
|
data[offset+3] = uint8(v >> 24)
|
|
return offset + 4
|
|
}
|
|
func encodeVarintRaft(data []byte, offset int, v uint64) int {
|
|
for v >= 1<<7 {
|
|
data[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
data[offset] = uint8(v)
|
|
return offset + 1
|
|
}
|