952 lines
21 KiB
Go
952 lines
21 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:
|
|
Info
|
|
Entry
|
|
Snapshot
|
|
Message
|
|
State
|
|
*/
|
|
package raftpb
|
|
|
|
import proto "github.com/coreos/etcd/third_party/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/third_party/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 Info struct {
|
|
Id int64 `protobuf:"varint,1,req,name=id" json:"id"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Info) Reset() { *m = Info{} }
|
|
func (m *Info) String() string { return proto.CompactTextString(m) }
|
|
func (*Info) ProtoMessage() {}
|
|
|
|
type Entry struct {
|
|
Term int64 `protobuf:"varint,2,req,name=term" json:"term"`
|
|
Index int64 `protobuf:"varint,3,req,name=index" json:"index"`
|
|
Data []byte `protobuf:"bytes,4,opt,name=data" 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 []int64 `protobuf:"varint,2,rep,name=nodes" json:"nodes"`
|
|
Index int64 `protobuf:"varint,3,req,name=index" json:"index"`
|
|
Term int64 `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 int64 `protobuf:"varint,1,req,name=type" json:"type"`
|
|
To int64 `protobuf:"varint,2,req,name=to" json:"to"`
|
|
From int64 `protobuf:"varint,3,req,name=from" json:"from"`
|
|
Term int64 `protobuf:"varint,4,req,name=term" json:"term"`
|
|
LogTerm int64 `protobuf:"varint,5,req,name=logTerm" json:"logTerm"`
|
|
Index int64 `protobuf:"varint,6,req,name=index" json:"index"`
|
|
Entries []Entry `protobuf:"bytes,7,rep,name=entries" json:"entries"`
|
|
Commit int64 `protobuf:"varint,8,req,name=commit" json:"commit"`
|
|
Snapshot Snapshot `protobuf:"bytes,9,req,name=snapshot" json:"snapshot"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Message) Reset() { *m = Message{} }
|
|
func (m *Message) String() string { return proto.CompactTextString(m) }
|
|
func (*Message) ProtoMessage() {}
|
|
|
|
type State struct {
|
|
Term int64 `protobuf:"varint,1,req,name=term" json:"term"`
|
|
Vote int64 `protobuf:"varint,2,req,name=vote" json:"vote"`
|
|
Commit int64 `protobuf:"varint,3,req,name=commit" json:"commit"`
|
|
LastIndex int64 `protobuf:"varint,4,req,name=lastIndex" json:"lastIndex"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *State) Reset() { *m = State{} }
|
|
func (m *State) String() string { return proto.CompactTextString(m) }
|
|
func (*State) ProtoMessage() {}
|
|
|
|
func init() {
|
|
}
|
|
func (m *Info) 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 |= (int64(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 *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 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 |= (int64(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 |= (int64(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 int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if index >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[index]
|
|
index++
|
|
v |= (int64(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 |= (int64(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 |= (int64(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 |= (int64(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 |= (int64(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 |= (int64(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 |= (int64(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 |= (int64(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 |= (int64(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 |= (int64(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
|
|
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 *State) 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 |= (int64(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 |= (int64(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 |= (int64(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.LastIndex |= (int64(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 *Info) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovRaft(uint64(m.Id))
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
func (m *Entry) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
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))
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
func (m *State) 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))
|
|
n += 1 + sovRaft(uint64(m.LastIndex))
|
|
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 *Info) 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 *Info) 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))
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
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] = 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++
|
|
i = encodeVarintRaft(data, i, uint64(num))
|
|
}
|
|
}
|
|
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
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *State) 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 *State) 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))
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintRaft(data, i, uint64(m.LastIndex))
|
|
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
|
|
}
|