raft_entry.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: proto/mrpb/raft_entry.proto

package mrpb

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "google.golang.org/protobuf/types/known/timestamppb"

	github_com_kakao_varlog_pkg_types "github.com/kakao/varlog/pkg/types"
	snpb "github.com/kakao/varlog/proto/snpb"
	varlogpb "github.com/kakao/varlog/proto/varlogpb"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type RegisterStorageNode struct {
	StorageNode *varlogpb.StorageNodeDescriptor `protobuf:"bytes,1,opt,name=storage_node,json=storageNode,proto3" json:"storage_node,omitempty"`
}

func (m *RegisterStorageNode) Reset()         { *m = RegisterStorageNode{} }
func (m *RegisterStorageNode) String() string { return proto.CompactTextString(m) }
func (*RegisterStorageNode) ProtoMessage()    {}
func (*RegisterStorageNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{0}
}
func (m *RegisterStorageNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterStorageNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterStorageNode.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterStorageNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterStorageNode.Merge(m, src)
}
func (m *RegisterStorageNode) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RegisterStorageNode) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterStorageNode.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterStorageNode proto.InternalMessageInfo

func (m *RegisterStorageNode) GetStorageNode() *varlogpb.StorageNodeDescriptor {
	if m != nil {
		return m.StorageNode
	}
	return nil
}

type UnregisterStorageNode struct {
	StorageNodeID github_com_kakao_varlog_pkg_types.StorageNodeID `protobuf:"varint,1,opt,name=storage_node_id,json=storageNodeId,proto3,casttype=github.com/kakao/varlog/pkg/types.StorageNodeID" json:"storage_node_id,omitempty"`
}

func (m *UnregisterStorageNode) Reset()         { *m = UnregisterStorageNode{} }
func (m *UnregisterStorageNode) String() string { return proto.CompactTextString(m) }
func (*UnregisterStorageNode) ProtoMessage()    {}
func (*UnregisterStorageNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{1}
}
func (m *UnregisterStorageNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnregisterStorageNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnregisterStorageNode.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnregisterStorageNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnregisterStorageNode.Merge(m, src)
}
func (m *UnregisterStorageNode) XXX_Size() int {
	return m.ProtoSize()
}
func (m *UnregisterStorageNode) XXX_DiscardUnknown() {
	xxx_messageInfo_UnregisterStorageNode.DiscardUnknown(m)
}

var xxx_messageInfo_UnregisterStorageNode proto.InternalMessageInfo

func (m *UnregisterStorageNode) GetStorageNodeID() github_com_kakao_varlog_pkg_types.StorageNodeID {
	if m != nil {
		return m.StorageNodeID
	}
	return 0
}

type RegisterTopic struct {
	TopicID github_com_kakao_varlog_pkg_types.TopicID `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3,casttype=github.com/kakao/varlog/pkg/types.TopicID" json:"topic_id,omitempty"`
}

func (m *RegisterTopic) Reset()         { *m = RegisterTopic{} }
func (m *RegisterTopic) String() string { return proto.CompactTextString(m) }
func (*RegisterTopic) ProtoMessage()    {}
func (*RegisterTopic) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{2}
}
func (m *RegisterTopic) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterTopic.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterTopic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterTopic.Merge(m, src)
}
func (m *RegisterTopic) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RegisterTopic) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterTopic.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterTopic proto.InternalMessageInfo

func (m *RegisterTopic) GetTopicID() github_com_kakao_varlog_pkg_types.TopicID {
	if m != nil {
		return m.TopicID
	}
	return 0
}

type UnregisterTopic struct {
	TopicID github_com_kakao_varlog_pkg_types.TopicID `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3,casttype=github.com/kakao/varlog/pkg/types.TopicID" json:"topic_id,omitempty"`
}

func (m *UnregisterTopic) Reset()         { *m = UnregisterTopic{} }
func (m *UnregisterTopic) String() string { return proto.CompactTextString(m) }
func (*UnregisterTopic) ProtoMessage()    {}
func (*UnregisterTopic) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{3}
}
func (m *UnregisterTopic) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnregisterTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnregisterTopic.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnregisterTopic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnregisterTopic.Merge(m, src)
}
func (m *UnregisterTopic) XXX_Size() int {
	return m.ProtoSize()
}
func (m *UnregisterTopic) XXX_DiscardUnknown() {
	xxx_messageInfo_UnregisterTopic.DiscardUnknown(m)
}

var xxx_messageInfo_UnregisterTopic proto.InternalMessageInfo

func (m *UnregisterTopic) GetTopicID() github_com_kakao_varlog_pkg_types.TopicID {
	if m != nil {
		return m.TopicID
	}
	return 0
}

type RegisterLogStream struct {
	LogStream *varlogpb.LogStreamDescriptor `protobuf:"bytes,1,opt,name=log_stream,json=logStream,proto3" json:"log_stream,omitempty"`
}

func (m *RegisterLogStream) Reset()         { *m = RegisterLogStream{} }
func (m *RegisterLogStream) String() string { return proto.CompactTextString(m) }
func (*RegisterLogStream) ProtoMessage()    {}
func (*RegisterLogStream) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{4}
}
func (m *RegisterLogStream) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterLogStream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterLogStream.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterLogStream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterLogStream.Merge(m, src)
}
func (m *RegisterLogStream) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RegisterLogStream) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterLogStream.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterLogStream proto.InternalMessageInfo

func (m *RegisterLogStream) GetLogStream() *varlogpb.LogStreamDescriptor {
	if m != nil {
		return m.LogStream
	}
	return nil
}

type UnregisterLogStream struct {
	LogStreamID github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,1,opt,name=log_stream_id,json=logStreamId,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"log_stream_id,omitempty"`
}

func (m *UnregisterLogStream) Reset()         { *m = UnregisterLogStream{} }
func (m *UnregisterLogStream) String() string { return proto.CompactTextString(m) }
func (*UnregisterLogStream) ProtoMessage()    {}
func (*UnregisterLogStream) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{5}
}
func (m *UnregisterLogStream) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnregisterLogStream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnregisterLogStream.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnregisterLogStream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnregisterLogStream.Merge(m, src)
}
func (m *UnregisterLogStream) XXX_Size() int {
	return m.ProtoSize()
}
func (m *UnregisterLogStream) XXX_DiscardUnknown() {
	xxx_messageInfo_UnregisterLogStream.DiscardUnknown(m)
}

var xxx_messageInfo_UnregisterLogStream proto.InternalMessageInfo

func (m *UnregisterLogStream) GetLogStreamID() github_com_kakao_varlog_pkg_types.LogStreamID {
	if m != nil {
		return m.LogStreamID
	}
	return 0
}

type UpdateLogStream struct {
	LogStream *varlogpb.LogStreamDescriptor `protobuf:"bytes,1,opt,name=log_stream,json=logStream,proto3" json:"log_stream,omitempty"`
}

func (m *UpdateLogStream) Reset()         { *m = UpdateLogStream{} }
func (m *UpdateLogStream) String() string { return proto.CompactTextString(m) }
func (*UpdateLogStream) ProtoMessage()    {}
func (*UpdateLogStream) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{6}
}
func (m *UpdateLogStream) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateLogStream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateLogStream.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UpdateLogStream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateLogStream.Merge(m, src)
}
func (m *UpdateLogStream) XXX_Size() int {
	return m.ProtoSize()
}
func (m *UpdateLogStream) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateLogStream.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateLogStream proto.InternalMessageInfo

func (m *UpdateLogStream) GetLogStream() *varlogpb.LogStreamDescriptor {
	if m != nil {
		return m.LogStream
	}
	return nil
}

type Report struct {
	StorageNodeID  github_com_kakao_varlog_pkg_types.StorageNodeID `protobuf:"varint,1,opt,name=storage_node_id,json=storageNodeId,proto3,casttype=github.com/kakao/varlog/pkg/types.StorageNodeID" json:"storage_node_id,omitempty"`
	UncommitReport []snpb.LogStreamUncommitReport                  `protobuf:"bytes,3,rep,name=uncommit_report,json=uncommitReport,proto3" json:"uncommit_report"`
}

func (m *Report) Reset()         { *m = Report{} }
func (m *Report) String() string { return proto.CompactTextString(m) }
func (*Report) ProtoMessage()    {}
func (*Report) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{7}
}
func (m *Report) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Report) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Report.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Report) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Report.Merge(m, src)
}
func (m *Report) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Report) XXX_DiscardUnknown() {
	xxx_messageInfo_Report.DiscardUnknown(m)
}

var xxx_messageInfo_Report proto.InternalMessageInfo

func (m *Report) GetStorageNodeID() github_com_kakao_varlog_pkg_types.StorageNodeID {
	if m != nil {
		return m.StorageNodeID
	}
	return 0
}

func (m *Report) GetUncommitReport() []snpb.LogStreamUncommitReport {
	if m != nil {
		return m.UncommitReport
	}
	return nil
}

type Reports struct {
	NodeID      github_com_kakao_varlog_pkg_types.NodeID `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3,casttype=github.com/kakao/varlog/pkg/types.NodeID" json:"node_id,omitempty"`
	CreatedTime time.Time                                `protobuf:"bytes,2,opt,name=created_time,json=createdTime,proto3,stdtime" json:"created_time"`
	Reports     []*Report                                `protobuf:"bytes,3,rep,name=reports,proto3" json:"reports,omitempty"`
}

func (m *Reports) Reset()         { *m = Reports{} }
func (m *Reports) String() string { return proto.CompactTextString(m) }
func (*Reports) ProtoMessage()    {}
func (*Reports) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{8}
}
func (m *Reports) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Reports) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Reports.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Reports) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Reports.Merge(m, src)
}
func (m *Reports) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Reports) XXX_DiscardUnknown() {
	xxx_messageInfo_Reports.DiscardUnknown(m)
}

var xxx_messageInfo_Reports proto.InternalMessageInfo

func (m *Reports) GetNodeID() github_com_kakao_varlog_pkg_types.NodeID {
	if m != nil {
		return m.NodeID
	}
	return 0
}

func (m *Reports) GetCreatedTime() time.Time {
	if m != nil {
		return m.CreatedTime
	}
	return time.Time{}
}

func (m *Reports) GetReports() []*Report {
	if m != nil {
		return m.Reports
	}
	return nil
}

type Commit struct {
	NodeID      github_com_kakao_varlog_pkg_types.NodeID `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3,casttype=github.com/kakao/varlog/pkg/types.NodeID" json:"node_id,omitempty"`
	CreatedTime time.Time                                `protobuf:"bytes,2,opt,name=created_time,json=createdTime,proto3,stdtime" json:"created_time"`
}

func (m *Commit) Reset()         { *m = Commit{} }
func (m *Commit) String() string { return proto.CompactTextString(m) }
func (*Commit) ProtoMessage()    {}
func (*Commit) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{9}
}
func (m *Commit) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Commit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Commit.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Commit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Commit.Merge(m, src)
}
func (m *Commit) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Commit) XXX_DiscardUnknown() {
	xxx_messageInfo_Commit.DiscardUnknown(m)
}

var xxx_messageInfo_Commit proto.InternalMessageInfo

func (m *Commit) GetNodeID() github_com_kakao_varlog_pkg_types.NodeID {
	if m != nil {
		return m.NodeID
	}
	return 0
}

func (m *Commit) GetCreatedTime() time.Time {
	if m != nil {
		return m.CreatedTime
	}
	return time.Time{}
}

type Seal struct {
	LogStreamID github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,1,opt,name=log_stream_id,json=logStreamId,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"log_stream_id,omitempty"`
}

func (m *Seal) Reset()         { *m = Seal{} }
func (m *Seal) String() string { return proto.CompactTextString(m) }
func (*Seal) ProtoMessage()    {}
func (*Seal) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{10}
}
func (m *Seal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Seal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Seal.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Seal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Seal.Merge(m, src)
}
func (m *Seal) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Seal) XXX_DiscardUnknown() {
	xxx_messageInfo_Seal.DiscardUnknown(m)
}

var xxx_messageInfo_Seal proto.InternalMessageInfo

func (m *Seal) GetLogStreamID() github_com_kakao_varlog_pkg_types.LogStreamID {
	if m != nil {
		return m.LogStreamID
	}
	return 0
}

type Unseal struct {
	LogStreamID github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,1,opt,name=log_stream_id,json=logStreamId,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"log_stream_id,omitempty"`
}

func (m *Unseal) Reset()         { *m = Unseal{} }
func (m *Unseal) String() string { return proto.CompactTextString(m) }
func (*Unseal) ProtoMessage()    {}
func (*Unseal) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{11}
}
func (m *Unseal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Unseal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Unseal.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Unseal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Unseal.Merge(m, src)
}
func (m *Unseal) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Unseal) XXX_DiscardUnknown() {
	xxx_messageInfo_Unseal.DiscardUnknown(m)
}

var xxx_messageInfo_Unseal proto.InternalMessageInfo

func (m *Unseal) GetLogStreamID() github_com_kakao_varlog_pkg_types.LogStreamID {
	if m != nil {
		return m.LogStreamID
	}
	return 0
}

type AddPeer struct {
	NodeID    github_com_kakao_varlog_pkg_types.NodeID `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3,casttype=github.com/kakao/varlog/pkg/types.NodeID" json:"node_id,omitempty"`
	Url       string                                   `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	IsLearner bool                                     `protobuf:"varint,3,opt,name=is_learner,json=isLearner,proto3" json:"is_learner,omitempty"`
}

func (m *AddPeer) Reset()         { *m = AddPeer{} }
func (m *AddPeer) String() string { return proto.CompactTextString(m) }
func (*AddPeer) ProtoMessage()    {}
func (*AddPeer) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{12}
}
func (m *AddPeer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddPeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddPeer.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AddPeer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddPeer.Merge(m, src)
}
func (m *AddPeer) XXX_Size() int {
	return m.ProtoSize()
}
func (m *AddPeer) XXX_DiscardUnknown() {
	xxx_messageInfo_AddPeer.DiscardUnknown(m)
}

var xxx_messageInfo_AddPeer proto.InternalMessageInfo

func (m *AddPeer) GetNodeID() github_com_kakao_varlog_pkg_types.NodeID {
	if m != nil {
		return m.NodeID
	}
	return 0
}

func (m *AddPeer) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *AddPeer) GetIsLearner() bool {
	if m != nil {
		return m.IsLearner
	}
	return false
}

type RemovePeer struct {
	NodeID github_com_kakao_varlog_pkg_types.NodeID `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3,casttype=github.com/kakao/varlog/pkg/types.NodeID" json:"node_id,omitempty"`
}

func (m *RemovePeer) Reset()         { *m = RemovePeer{} }
func (m *RemovePeer) String() string { return proto.CompactTextString(m) }
func (*RemovePeer) ProtoMessage()    {}
func (*RemovePeer) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{13}
}
func (m *RemovePeer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemovePeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemovePeer.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemovePeer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemovePeer.Merge(m, src)
}
func (m *RemovePeer) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RemovePeer) XXX_DiscardUnknown() {
	xxx_messageInfo_RemovePeer.DiscardUnknown(m)
}

var xxx_messageInfo_RemovePeer proto.InternalMessageInfo

func (m *RemovePeer) GetNodeID() github_com_kakao_varlog_pkg_types.NodeID {
	if m != nil {
		return m.NodeID
	}
	return 0
}

type Endpoint struct {
	NodeID github_com_kakao_varlog_pkg_types.NodeID `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3,casttype=github.com/kakao/varlog/pkg/types.NodeID" json:"node_id,omitempty"`
	Url    string                                   `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
}

func (m *Endpoint) Reset()         { *m = Endpoint{} }
func (m *Endpoint) String() string { return proto.CompactTextString(m) }
func (*Endpoint) ProtoMessage()    {}
func (*Endpoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{14}
}
func (m *Endpoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Endpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Endpoint.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Endpoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Endpoint.Merge(m, src)
}
func (m *Endpoint) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Endpoint) XXX_DiscardUnknown() {
	xxx_messageInfo_Endpoint.DiscardUnknown(m)
}

var xxx_messageInfo_Endpoint proto.InternalMessageInfo

func (m *Endpoint) GetNodeID() github_com_kakao_varlog_pkg_types.NodeID {
	if m != nil {
		return m.NodeID
	}
	return 0
}

func (m *Endpoint) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

type RecoverStateMachine struct {
	StateMachine *MetadataRepositoryDescriptor `protobuf:"bytes,1,opt,name=state_machine,json=stateMachine,proto3" json:"state_machine,omitempty"`
}

func (m *RecoverStateMachine) Reset()         { *m = RecoverStateMachine{} }
func (m *RecoverStateMachine) String() string { return proto.CompactTextString(m) }
func (*RecoverStateMachine) ProtoMessage()    {}
func (*RecoverStateMachine) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{15}
}
func (m *RecoverStateMachine) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecoverStateMachine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecoverStateMachine.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RecoverStateMachine) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecoverStateMachine.Merge(m, src)
}
func (m *RecoverStateMachine) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RecoverStateMachine) XXX_DiscardUnknown() {
	xxx_messageInfo_RecoverStateMachine.DiscardUnknown(m)
}

var xxx_messageInfo_RecoverStateMachine proto.InternalMessageInfo

func (m *RecoverStateMachine) GetStateMachine() *MetadataRepositoryDescriptor {
	if m != nil {
		return m.StateMachine
	}
	return nil
}

type RaftEntry struct {
	NodeIndex    uint64            `protobuf:"varint,1,opt,name=node_index,json=nodeIndex,proto3" json:"node_index,omitempty"`
	RequestIndex uint64            `protobuf:"varint,2,opt,name=request_index,json=requestIndex,proto3" json:"request_index,omitempty"`
	AppliedIndex uint64            `protobuf:"varint,3,opt,name=applied_index,json=appliedIndex,proto3" json:"applied_index,omitempty"`
	Request      RaftEntry_Request `protobuf:"bytes,4,opt,name=request,proto3" json:"request"`
}

func (m *RaftEntry) Reset()         { *m = RaftEntry{} }
func (m *RaftEntry) String() string { return proto.CompactTextString(m) }
func (*RaftEntry) ProtoMessage()    {}
func (*RaftEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{16}
}
func (m *RaftEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RaftEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RaftEntry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RaftEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RaftEntry.Merge(m, src)
}
func (m *RaftEntry) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RaftEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_RaftEntry.DiscardUnknown(m)
}

var xxx_messageInfo_RaftEntry proto.InternalMessageInfo

func (m *RaftEntry) GetNodeIndex() uint64 {
	if m != nil {
		return m.NodeIndex
	}
	return 0
}

func (m *RaftEntry) GetRequestIndex() uint64 {
	if m != nil {
		return m.RequestIndex
	}
	return 0
}

func (m *RaftEntry) GetAppliedIndex() uint64 {
	if m != nil {
		return m.AppliedIndex
	}
	return 0
}

func (m *RaftEntry) GetRequest() RaftEntry_Request {
	if m != nil {
		return m.Request
	}
	return RaftEntry_Request{}
}

type RaftEntry_Request struct {
	RegisterStorageNode   *RegisterStorageNode   `protobuf:"bytes,1,opt,name=register_storage_node,json=registerStorageNode,proto3" json:"register_storage_node,omitempty"`
	UnregisterStorageNode *UnregisterStorageNode `protobuf:"bytes,2,opt,name=unregister_storage_node,json=unregisterStorageNode,proto3" json:"unregister_storage_node,omitempty"`
	RegisterLogStream     *RegisterLogStream     `protobuf:"bytes,3,opt,name=register_log_stream,json=registerLogStream,proto3" json:"register_log_stream,omitempty"`
	UnregisterLogStream   *UnregisterLogStream   `protobuf:"bytes,4,opt,name=unregister_log_stream,json=unregisterLogStream,proto3" json:"unregister_log_stream,omitempty"`
	UpdateLogStream       *UpdateLogStream       `protobuf:"bytes,5,opt,name=update_log_stream,json=updateLogStream,proto3" json:"update_log_stream,omitempty"`
	Report                *Reports               `protobuf:"bytes,6,opt,name=report,proto3" json:"report,omitempty"`
	Commit                *Commit                `protobuf:"bytes,7,opt,name=commit,proto3" json:"commit,omitempty"`
	Seal                  *Seal                  `protobuf:"bytes,8,opt,name=seal,proto3" json:"seal,omitempty"`
	Unseal                *Unseal                `protobuf:"bytes,9,opt,name=unseal,proto3" json:"unseal,omitempty"`
	AddPeer               *AddPeer               `protobuf:"bytes,10,opt,name=add_peer,json=addPeer,proto3" json:"add_peer,omitempty"`
	RemovePeer            *RemovePeer            `protobuf:"bytes,11,opt,name=remove_peer,json=removePeer,proto3" json:"remove_peer,omitempty"`
	Endpoint              *Endpoint              `protobuf:"bytes,12,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	RecoverStateMachine   *RecoverStateMachine   `protobuf:"bytes,13,opt,name=recover_state_machine,json=recoverStateMachine,proto3" json:"recover_state_machine,omitempty"`
	RegisterTopic         *RegisterTopic         `protobuf:"bytes,14,opt,name=register_topic,json=registerTopic,proto3" json:"register_topic,omitempty"`
	UnregisterTopic       *UnregisterTopic       `protobuf:"bytes,15,opt,name=unregister_topic,json=unregisterTopic,proto3" json:"unregister_topic,omitempty"`
}

func (m *RaftEntry_Request) Reset()         { *m = RaftEntry_Request{} }
func (m *RaftEntry_Request) String() string { return proto.CompactTextString(m) }
func (*RaftEntry_Request) ProtoMessage()    {}
func (*RaftEntry_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_9661c8402dd472d1, []int{16, 0}
}
func (m *RaftEntry_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RaftEntry_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RaftEntry_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RaftEntry_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RaftEntry_Request.Merge(m, src)
}
func (m *RaftEntry_Request) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RaftEntry_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_RaftEntry_Request.DiscardUnknown(m)
}

var xxx_messageInfo_RaftEntry_Request proto.InternalMessageInfo

func (m *RaftEntry_Request) GetRegisterStorageNode() *RegisterStorageNode {
	if m != nil {
		return m.RegisterStorageNode
	}
	return nil
}

func (m *RaftEntry_Request) GetUnregisterStorageNode() *UnregisterStorageNode {
	if m != nil {
		return m.UnregisterStorageNode
	}
	return nil
}

func (m *RaftEntry_Request) GetRegisterLogStream() *RegisterLogStream {
	if m != nil {
		return m.RegisterLogStream
	}
	return nil
}

func (m *RaftEntry_Request) GetUnregisterLogStream() *UnregisterLogStream {
	if m != nil {
		return m.UnregisterLogStream
	}
	return nil
}

func (m *RaftEntry_Request) GetUpdateLogStream() *UpdateLogStream {
	if m != nil {
		return m.UpdateLogStream
	}
	return nil
}

func (m *RaftEntry_Request) GetReport() *Reports {
	if m != nil {
		return m.Report
	}
	return nil
}

func (m *RaftEntry_Request) GetCommit() *Commit {
	if m != nil {
		return m.Commit
	}
	return nil
}

func (m *RaftEntry_Request) GetSeal() *Seal {
	if m != nil {
		return m.Seal
	}
	return nil
}

func (m *RaftEntry_Request) GetUnseal() *Unseal {
	if m != nil {
		return m.Unseal
	}
	return nil
}

func (m *RaftEntry_Request) GetAddPeer() *AddPeer {
	if m != nil {
		return m.AddPeer
	}
	return nil
}

func (m *RaftEntry_Request) GetRemovePeer() *RemovePeer {
	if m != nil {
		return m.RemovePeer
	}
	return nil
}

func (m *RaftEntry_Request) GetEndpoint() *Endpoint {
	if m != nil {
		return m.Endpoint
	}
	return nil
}

func (m *RaftEntry_Request) GetRecoverStateMachine() *RecoverStateMachine {
	if m != nil {
		return m.RecoverStateMachine
	}
	return nil
}

func (m *RaftEntry_Request) GetRegisterTopic() *RegisterTopic {
	if m != nil {
		return m.RegisterTopic
	}
	return nil
}

func (m *RaftEntry_Request) GetUnregisterTopic() *UnregisterTopic {
	if m != nil {
		return m.UnregisterTopic
	}
	return nil
}

func init() {
	proto.RegisterType((*RegisterStorageNode)(nil), "varlog.mrpb.RegisterStorageNode")
	proto.RegisterType((*UnregisterStorageNode)(nil), "varlog.mrpb.UnregisterStorageNode")
	proto.RegisterType((*RegisterTopic)(nil), "varlog.mrpb.RegisterTopic")
	proto.RegisterType((*UnregisterTopic)(nil), "varlog.mrpb.UnregisterTopic")
	proto.RegisterType((*RegisterLogStream)(nil), "varlog.mrpb.RegisterLogStream")
	proto.RegisterType((*UnregisterLogStream)(nil), "varlog.mrpb.UnregisterLogStream")
	proto.RegisterType((*UpdateLogStream)(nil), "varlog.mrpb.UpdateLogStream")
	proto.RegisterType((*Report)(nil), "varlog.mrpb.Report")
	proto.RegisterType((*Reports)(nil), "varlog.mrpb.Reports")
	proto.RegisterType((*Commit)(nil), "varlog.mrpb.Commit")
	proto.RegisterType((*Seal)(nil), "varlog.mrpb.Seal")
	proto.RegisterType((*Unseal)(nil), "varlog.mrpb.Unseal")
	proto.RegisterType((*AddPeer)(nil), "varlog.mrpb.AddPeer")
	proto.RegisterType((*RemovePeer)(nil), "varlog.mrpb.RemovePeer")
	proto.RegisterType((*Endpoint)(nil), "varlog.mrpb.Endpoint")
	proto.RegisterType((*RecoverStateMachine)(nil), "varlog.mrpb.RecoverStateMachine")
	proto.RegisterType((*RaftEntry)(nil), "varlog.mrpb.RaftEntry")
	proto.RegisterType((*RaftEntry_Request)(nil), "varlog.mrpb.RaftEntry.Request")
}

func init() { proto.RegisterFile("proto/mrpb/raft_entry.proto", fileDescriptor_9661c8402dd472d1) }

var fileDescriptor_9661c8402dd472d1 = []byte{
	// 1097 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcd, 0x6f, 0xdc, 0x44,
	0x14, 0x8f, 0xbb, 0xdb, 0xfd, 0x78, 0x9b, 0xcd, 0x36, 0x0e, 0x51, 0xac, 0x00, 0xbb, 0x91, 0x0b,
	0x28, 0x15, 0xc4, 0x16, 0x20, 0xa1, 0x0a, 0x21, 0x44, 0x43, 0xaa, 0x12, 0xa9, 0x4d, 0xd1, 0x24,
	0xb9, 0x54, 0x80, 0xe5, 0x5d, 0x4f, 0x5c, 0x2b, 0x6b, 0x8f, 0x19, 0x8f, 0x23, 0x2a, 0xce, 0x9c,
	0xb8, 0xf4, 0xc6, 0xb5, 0xe2, 0xaf, 0x89, 0xc4, 0xa5, 0xe2, 0xc4, 0x69, 0x41, 0x9b, 0xff, 0x82,
	0x13, 0x9a, 0x0f, 0x7f, 0x65, 0x8d, 0x72, 0x21, 0x11, 0xb7, 0xd9, 0x99, 0xdf, 0xfb, 0xf8, 0x8d,
	0xdf, 0xfc, 0xde, 0x5b, 0x78, 0x33, 0xa6, 0x84, 0x11, 0x3b, 0xa4, 0xf1, 0xd8, 0xa6, 0xee, 0x09,
	0x73, 0x70, 0xc4, 0xe8, 0x0b, 0x4b, 0xec, 0xea, 0xbd, 0x33, 0x97, 0x4e, 0x89, 0x6f, 0xf1, 0xd3,
	0xcd, 0x91, 0x4f, 0x88, 0x3f, 0xc5, 0xb6, 0x38, 0x1a, 0xa7, 0x27, 0x36, 0x0b, 0x42, 0x9c, 0x30,
	0x37, 0x8c, 0x25, 0x7a, 0x73, 0xc7, 0x0f, 0xd8, 0xf3, 0x74, 0x6c, 0x4d, 0x48, 0x68, 0xfb, 0xc4,
	0x27, 0x05, 0x92, 0xff, 0x92, 0x71, 0xf8, 0x4a, 0xc1, 0x37, 0xa4, 0xf3, 0x78, 0x6c, 0x87, 0x98,
	0xb9, 0x9e, 0xcb, 0x5c, 0x75, 0x30, 0x4c, 0xa2, 0x78, 0x6c, 0x4f, 0x89, 0xef, 0x24, 0x8c, 0x62,
	0x37, 0x74, 0x28, 0x8e, 0x09, 0x65, 0x98, 0xaa, 0xf3, 0xbb, 0x45, 0xb2, 0x99, 0xa5, 0x80, 0x24,
	0x01, 0x23, 0x59, 0xea, 0xe6, 0x09, 0xac, 0x21, 0xec, 0x07, 0x09, 0xc3, 0xf4, 0x90, 0x11, 0xea,
	0xfa, 0xf8, 0x80, 0x78, 0x58, 0x7f, 0x0a, 0xcb, 0x89, 0xfc, 0xe9, 0x44, 0xc4, 0xc3, 0x86, 0xb6,
	0xa5, 0x6d, 0xf7, 0x3e, 0x7a, 0xcf, 0x52, 0x44, 0xb3, 0x94, 0xac, 0x92, 0xcd, 0x1e, 0x4e, 0x26,
	0x34, 0x88, 0x19, 0xa1, 0xbb, 0xcd, 0xf3, 0xd9, 0x48, 0x43, 0xbd, 0xa4, 0x38, 0x34, 0x7f, 0xd2,
	0x60, 0xfd, 0x38, 0xa2, 0x35, 0xa1, 0xa6, 0x30, 0x28, 0x87, 0x72, 0x02, 0x4f, 0x44, 0xbb, 0xbd,
	0xbb, 0x37, 0x9f, 0x8d, 0xfa, 0x25, 0xe4, 0xfe, 0xde, 0xdf, 0xb3, 0x91, 0x5d, 0xba, 0xbc, 0x53,
	0xf7, 0xd4, 0x25, 0xb6, 0xcc, 0xc5, 0x8e, 0x4f, 0x7d, 0x9b, 0xbd, 0x88, 0x71, 0x62, 0x55, 0x4c,
	0x50, 0xbf, 0x94, 0xc5, 0xbe, 0x67, 0x7a, 0xd0, 0xcf, 0xf8, 0x1e, 0x91, 0x38, 0x98, 0xe8, 0x87,
	0xd0, 0x61, 0x7c, 0x51, 0xc4, 0xbd, 0x3f, 0x9f, 0x8d, 0xda, 0xe2, 0x50, 0x44, 0xbc, 0x77, 0x75,
	0x44, 0x05, 0x46, 0x6d, 0xe1, 0x69, 0xdf, 0x33, 0x4f, 0x60, 0x50, 0x90, 0xbd, 0xc6, 0x38, 0xdf,
	0xc1, 0x6a, 0xc6, 0xe6, 0x31, 0xf1, 0x0f, 0x45, 0x19, 0xe8, 0xfb, 0x00, 0x45, 0x51, 0xa8, 0x2f,
	0xf7, 0xce, 0xc2, 0x97, 0xcb, 0xf1, 0x0b, 0xdf, 0xad, 0x3b, 0xcd, 0x8e, 0xcc, 0x1f, 0x61, 0xad,
	0xe0, 0x51, 0x44, 0xf0, 0xa0, 0x5f, 0x2a, 0xbb, 0x9c, 0xd0, 0x17, 0xf3, 0xd9, 0xa8, 0x97, 0xa3,
	0x04, 0xa9, 0x9d, 0xab, 0x49, 0x95, 0x0c, 0x50, 0x2f, 0x0f, 0xbd, 0xef, 0x99, 0xdf, 0xc0, 0xe0,
	0x38, 0xf6, 0x5c, 0x86, 0xaf, 0x85, 0xda, 0x6f, 0x1a, 0xb4, 0x90, 0x78, 0x30, 0x37, 0x5b, 0x81,
	0xfa, 0x21, 0x0c, 0xd2, 0x68, 0x42, 0xc2, 0x30, 0x60, 0xea, 0xc5, 0x1a, 0x8d, 0xad, 0x46, 0x99,
	0x08, 0x7f, 0xd7, 0x05, 0x89, 0x63, 0x05, 0x96, 0xc9, 0x0a, 0x22, 0x4b, 0x68, 0x25, 0xad, 0xec,
	0x9a, 0xbf, 0x6b, 0xd0, 0x96, 0xcb, 0x44, 0x7f, 0x0a, 0xed, 0x32, 0x8d, 0xe6, 0xee, 0x27, 0xf3,
	0xd9, 0xa8, 0x95, 0xe7, 0xbf, 0x7d, 0x75, 0xfe, 0x2a, 0xf1, 0x56, 0x24, 0x33, 0x7e, 0x04, 0xcb,
	0x13, 0x8a, 0x5d, 0x86, 0x3d, 0x87, 0x6b, 0x99, 0x71, 0x4b, 0xdc, 0xfb, 0xa6, 0x25, 0x85, 0xce,
	0xca, 0xe4, 0xcb, 0x3a, 0xca, 0x84, 0x6e, 0xb7, 0xc3, 0x93, 0x7c, 0xf9, 0x27, 0x17, 0x01, 0x65,
	0xc9, 0xcf, 0xf4, 0x1d, 0x68, 0x4b, 0xc6, 0x89, 0xa2, 0xbc, 0x66, 0x95, 0x94, 0xd3, 0x92, 0x04,
	0x50, 0x86, 0x31, 0x7f, 0xd5, 0xa0, 0xf5, 0xa5, 0x60, 0xf9, 0xff, 0xe5, 0x64, 0x4e, 0xa1, 0x79,
	0x88, 0xdd, 0xe9, 0x0d, 0xbd, 0x89, 0x08, 0x5a, 0xc7, 0x51, 0x72, 0x73, 0xf1, 0x7e, 0xd6, 0xa0,
	0xfd, 0xc0, 0xf3, 0xbe, 0xc6, 0x98, 0xfe, 0xf7, 0xdf, 0xe0, 0x0e, 0x34, 0x52, 0x3a, 0x15, 0x57,
	0xdf, 0x45, 0x7c, 0xa9, 0xbf, 0x0d, 0x10, 0x24, 0xce, 0x14, 0xbb, 0x34, 0xc2, 0xd4, 0x68, 0x6c,
	0x69, 0xdb, 0x1d, 0xd4, 0x0d, 0x92, 0xc7, 0x72, 0xc3, 0xfc, 0x16, 0x00, 0xe1, 0x90, 0x9c, 0xe1,
	0x6b, 0xc9, 0xc7, 0x0c, 0xa1, 0xf3, 0x30, 0xf2, 0x62, 0x12, 0x44, 0xec, 0x06, 0xc8, 0x9a, 0x98,
	0xb7, 0xde, 0x09, 0x39, 0xe3, 0xed, 0xd0, 0x65, 0xf8, 0x89, 0x3b, 0x79, 0x1e, 0x44, 0x58, 0x3f,
	0x80, 0x7e, 0xc2, 0x7f, 0x3b, 0xa1, 0xdc, 0x50, 0x32, 0x77, 0xaf, 0xf2, 0x54, 0x9e, 0xa8, 0x86,
	0x8e, 0xf2, 0x7e, 0x5e, 0x68, 0x1d, 0x5a, 0x4e, 0x4a, 0xfe, 0xcc, 0x5f, 0xba, 0xd0, 0x45, 0xee,
	0x09, 0x7b, 0xc8, 0x07, 0x16, 0x7e, 0xc3, 0x92, 0x57, 0xe4, 0xe1, 0x1f, 0x24, 0x35, 0xd4, 0x15,
	0x29, 0xf2, 0x0d, 0xfd, 0x2e, 0xf4, 0x29, 0xfe, 0x3e, 0xc5, 0x09, 0x53, 0x88, 0x5b, 0x02, 0xb1,
	0xac, 0x36, 0x73, 0x90, 0x1b, 0xc7, 0xd3, 0x00, 0x7b, 0x0a, 0xd4, 0x90, 0x20, 0xb5, 0x29, 0x41,
	0x9f, 0xf3, 0xb7, 0x2e, 0x8c, 0x8c, 0xa6, 0x20, 0x30, 0xac, 0xbe, 0xf5, 0x2c, 0x23, 0x0b, 0x49,
	0x94, 0x12, 0xb6, 0xcc, 0x68, 0xf3, 0xaf, 0x36, 0x57, 0x34, 0xb1, 0xd6, 0x8f, 0x60, 0x3d, 0x6b,
	0x42, 0x4e, 0xcd, 0x58, 0xb2, 0x75, 0x49, 0x45, 0x16, 0x66, 0x0c, 0xb4, 0x56, 0x37, 0x78, 0x3c,
	0x83, 0x8d, 0x34, 0xaa, 0xf7, 0x2b, 0xd5, 0xc0, 0xac, 0xf8, 0xad, 0x9d, 0x5e, 0xd0, 0x7a, 0x5a,
	0x3b, 0xd4, 0x1c, 0x40, 0x1e, 0xd2, 0x29, 0x75, 0xac, 0x46, 0xdd, 0x4d, 0x5c, 0x6e, 0xaf, 0x68,
	0x75, 0xb1, 0xe3, 0x1e, 0x41, 0x29, 0x50, 0xd9, 0x63, 0xb3, 0xe6, 0x06, 0x6a, 0x5a, 0x36, 0x5a,
	0x4b, 0x6b, 0xfa, 0xf8, 0x57, 0xb0, 0x9a, 0x8a, 0x0e, 0x5b, 0xf6, 0x78, 0x5b, 0x78, 0x7c, 0xab,
	0xea, 0xb1, 0xda, 0x87, 0xd1, 0x20, 0xbd, 0xd4, 0x98, 0x3f, 0x80, 0x96, 0xea, 0x65, 0x2d, 0x61,
	0xfe, 0x46, 0x8d, 0xb0, 0x27, 0x48, 0x61, 0xf4, 0xf7, 0xa1, 0x25, 0xbb, 0x97, 0xd1, 0x16, 0xe8,
	0x6a, 0x1b, 0x90, 0x92, 0x8f, 0x14, 0x44, 0x7f, 0x17, 0x9a, 0x5c, 0xf0, 0x8c, 0x8e, 0x80, 0xae,
	0x56, 0xa0, 0x5c, 0x79, 0x91, 0x38, 0xe6, 0x3e, 0x53, 0xa1, 0x8c, 0x46, 0xb7, 0xc6, 0xa7, 0x14,
	0x4d, 0xa4, 0x20, 0xba, 0x0d, 0x1d, 0xd7, 0xf3, 0x9c, 0x18, 0x63, 0x6a, 0x40, 0x4d, 0xc2, 0x4a,
	0xf2, 0x50, 0xdb, 0x55, 0xda, 0x77, 0x1f, 0x7a, 0x54, 0x28, 0x8f, 0xb4, 0xe9, 0x09, 0x9b, 0x8d,
	0x4b, 0x24, 0x33, 0x65, 0x42, 0x40, 0x0b, 0x95, 0xfa, 0x10, 0x3a, 0x58, 0x89, 0x8a, 0xb1, 0x2c,
	0xcc, 0xd6, 0x2b, 0x66, 0x99, 0xe2, 0xa0, 0x1c, 0x26, 0xcb, 0x5d, 0x08, 0x83, 0x53, 0x55, 0x82,
	0x7e, 0x6d, 0xb9, 0x2f, 0x48, 0x08, 0x2f, 0xf7, 0x45, 0x5d, 0x79, 0x00, 0x2b, 0x79, 0x01, 0x89,
	0xf9, 0xd1, 0x58, 0x51, 0x3d, 0xaf, 0xae, 0x1a, 0xc5, 0xa8, 0x89, 0xfa, 0xd5, 0x19, 0xf6, 0x11,
	0xdc, 0x29, 0x55, 0xa1, 0x74, 0x32, 0xa8, 0x2b, 0x97, 0xea, 0xec, 0x8b, 0x06, 0x69, 0x75, 0xe3,
	0xd3, 0xe6, 0xf9, 0xab, 0x91, 0xb6, 0xfb, 0xd9, 0xf9, 0x7c, 0xa8, 0xbd, 0x9e, 0x0f, 0xb5, 0x97,
	0x17, 0xc3, 0xa5, 0x57, 0x17, 0x43, 0xed, 0xf5, 0xc5, 0x70, 0xe9, 0x8f, 0x8b, 0xe1, 0xd2, 0x33,
	0xf3, 0x5f, 0xe5, 0x35, 0xff, 0x17, 0x36, 0x6e, 0x89, 0xf5, 0xc7, 0xff, 0x04, 0x00, 0x00, 0xff,
	0xff, 0xe2, 0x66, 0x54, 0x77, 0x9a, 0x0d, 0x00, 0x00,
}

func (m *RegisterStorageNode) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterStorageNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterStorageNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StorageNode != nil {
		{
			size, err := m.StorageNode.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnregisterStorageNode) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnregisterStorageNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnregisterStorageNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StorageNodeID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.StorageNodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RegisterTopic) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterTopic) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterTopic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.TopicID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UnregisterTopic) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnregisterTopic) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnregisterTopic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.TopicID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RegisterLogStream) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterLogStream) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterLogStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogStream != nil {
		{
			size, err := m.LogStream.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnregisterLogStream) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnregisterLogStream) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnregisterLogStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogStreamID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.LogStreamID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UpdateLogStream) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UpdateLogStream) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateLogStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogStream != nil {
		{
			size, err := m.LogStream.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Report) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Report) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Report) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UncommitReport) > 0 {
		for iNdEx := len(m.UncommitReport) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UncommitReport[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRaftEntry(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.StorageNodeID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.StorageNodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Reports) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Reports) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Reports) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reports) > 0 {
		for iNdEx := len(m.Reports) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Reports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRaftEntry(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedTime):])
	if err4 != nil {
		return 0, err4
	}
	i -= n4
	i = encodeVarintRaftEntry(dAtA, i, uint64(n4))
	i--
	dAtA[i] = 0x12
	if m.NodeID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.NodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Commit) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Commit) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedTime):])
	if err5 != nil {
		return 0, err5
	}
	i -= n5
	i = encodeVarintRaftEntry(dAtA, i, uint64(n5))
	i--
	dAtA[i] = 0x12
	if m.NodeID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.NodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Seal) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Seal) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Seal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogStreamID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.LogStreamID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Unseal) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Unseal) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Unseal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogStreamID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.LogStreamID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AddPeer) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddPeer) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddPeer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsLearner {
		i--
		if m.IsLearner {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintRaftEntry(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x12
	}
	if m.NodeID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.NodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RemovePeer) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemovePeer) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemovePeer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NodeID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.NodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Endpoint) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Endpoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Endpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		i -= len(m.Url)
		copy(dAtA[i:], m.Url)
		i = encodeVarintRaftEntry(dAtA, i, uint64(len(m.Url)))
		i--
		dAtA[i] = 0x12
	}
	if m.NodeID != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.NodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RecoverStateMachine) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RecoverStateMachine) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecoverStateMachine) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StateMachine != nil {
		{
			size, err := m.StateMachine.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RaftEntry) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RaftEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftEntry(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.AppliedIndex != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.AppliedIndex))
		i--
		dAtA[i] = 0x18
	}
	if m.RequestIndex != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.RequestIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.NodeIndex != 0 {
		i = encodeVarintRaftEntry(dAtA, i, uint64(m.NodeIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RaftEntry_Request) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RaftEntry_Request) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftEntry_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UnregisterTopic != nil {
		{
			size, err := m.UnregisterTopic.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.RegisterTopic != nil {
		{
			size, err := m.RegisterTopic.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	if m.RecoverStateMachine != nil {
		{
			size, err := m.RecoverStateMachine.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.Endpoint != nil {
		{
			size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.RemovePeer != nil {
		{
			size, err := m.RemovePeer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.AddPeer != nil {
		{
			size, err := m.AddPeer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.Unseal != nil {
		{
			size, err := m.Unseal.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Seal != nil {
		{
			size, err := m.Seal.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Commit != nil {
		{
			size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Report != nil {
		{
			size, err := m.Report.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.UpdateLogStream != nil {
		{
			size, err := m.UpdateLogStream.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.UnregisterLogStream != nil {
		{
			size, err := m.UnregisterLogStream.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.RegisterLogStream != nil {
		{
			size, err := m.RegisterLogStream.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.UnregisterStorageNode != nil {
		{
			size, err := m.UnregisterStorageNode.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.RegisterStorageNode != nil {
		{
			size, err := m.RegisterStorageNode.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftEntry(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintRaftEntry(dAtA []byte, offset int, v uint64) int {
	offset -= sovRaftEntry(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *RegisterStorageNode) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StorageNode != nil {
		l = m.StorageNode.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	return n
}

func (m *UnregisterStorageNode) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StorageNodeID != 0 {
		n += 1 + sovRaftEntry(uint64(m.StorageNodeID))
	}
	return n
}

func (m *RegisterTopic) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicID != 0 {
		n += 1 + sovRaftEntry(uint64(m.TopicID))
	}
	return n
}

func (m *UnregisterTopic) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicID != 0 {
		n += 1 + sovRaftEntry(uint64(m.TopicID))
	}
	return n
}

func (m *RegisterLogStream) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LogStream != nil {
		l = m.LogStream.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	return n
}

func (m *UnregisterLogStream) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LogStreamID != 0 {
		n += 1 + sovRaftEntry(uint64(m.LogStreamID))
	}
	return n
}

func (m *UpdateLogStream) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LogStream != nil {
		l = m.LogStream.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	return n
}

func (m *Report) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StorageNodeID != 0 {
		n += 1 + sovRaftEntry(uint64(m.StorageNodeID))
	}
	if len(m.UncommitReport) > 0 {
		for _, e := range m.UncommitReport {
			l = e.ProtoSize()
			n += 1 + l + sovRaftEntry(uint64(l))
		}
	}
	return n
}

func (m *Reports) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeID != 0 {
		n += 1 + sovRaftEntry(uint64(m.NodeID))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedTime)
	n += 1 + l + sovRaftEntry(uint64(l))
	if len(m.Reports) > 0 {
		for _, e := range m.Reports {
			l = e.ProtoSize()
			n += 1 + l + sovRaftEntry(uint64(l))
		}
	}
	return n
}

func (m *Commit) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeID != 0 {
		n += 1 + sovRaftEntry(uint64(m.NodeID))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedTime)
	n += 1 + l + sovRaftEntry(uint64(l))
	return n
}

func (m *Seal) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LogStreamID != 0 {
		n += 1 + sovRaftEntry(uint64(m.LogStreamID))
	}
	return n
}

func (m *Unseal) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LogStreamID != 0 {
		n += 1 + sovRaftEntry(uint64(m.LogStreamID))
	}
	return n
}

func (m *AddPeer) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeID != 0 {
		n += 1 + sovRaftEntry(uint64(m.NodeID))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.IsLearner {
		n += 2
	}
	return n
}

func (m *RemovePeer) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeID != 0 {
		n += 1 + sovRaftEntry(uint64(m.NodeID))
	}
	return n
}

func (m *Endpoint) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeID != 0 {
		n += 1 + sovRaftEntry(uint64(m.NodeID))
	}
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	return n
}

func (m *RecoverStateMachine) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StateMachine != nil {
		l = m.StateMachine.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	return n
}

func (m *RaftEntry) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeIndex != 0 {
		n += 1 + sovRaftEntry(uint64(m.NodeIndex))
	}
	if m.RequestIndex != 0 {
		n += 1 + sovRaftEntry(uint64(m.RequestIndex))
	}
	if m.AppliedIndex != 0 {
		n += 1 + sovRaftEntry(uint64(m.AppliedIndex))
	}
	l = m.Request.ProtoSize()
	n += 1 + l + sovRaftEntry(uint64(l))
	return n
}

func (m *RaftEntry_Request) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RegisterStorageNode != nil {
		l = m.RegisterStorageNode.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.UnregisterStorageNode != nil {
		l = m.UnregisterStorageNode.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.RegisterLogStream != nil {
		l = m.RegisterLogStream.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.UnregisterLogStream != nil {
		l = m.UnregisterLogStream.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.UpdateLogStream != nil {
		l = m.UpdateLogStream.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.Report != nil {
		l = m.Report.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.Commit != nil {
		l = m.Commit.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.Seal != nil {
		l = m.Seal.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.Unseal != nil {
		l = m.Unseal.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.AddPeer != nil {
		l = m.AddPeer.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.RemovePeer != nil {
		l = m.RemovePeer.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.Endpoint != nil {
		l = m.Endpoint.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.RecoverStateMachine != nil {
		l = m.RecoverStateMachine.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.RegisterTopic != nil {
		l = m.RegisterTopic.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	if m.UnregisterTopic != nil {
		l = m.UnregisterTopic.ProtoSize()
		n += 1 + l + sovRaftEntry(uint64(l))
	}
	return n
}

func sovRaftEntry(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRaftEntry(x uint64) (n int) {
	return sovRaftEntry(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *RaftEntry_Request) GetValue() interface{} {
	if this.RegisterStorageNode != nil {
		return this.RegisterStorageNode
	}
	if this.UnregisterStorageNode != nil {
		return this.UnregisterStorageNode
	}
	if this.RegisterLogStream != nil {
		return this.RegisterLogStream
	}
	if this.UnregisterLogStream != nil {
		return this.UnregisterLogStream
	}
	if this.UpdateLogStream != nil {
		return this.UpdateLogStream
	}
	if this.Report != nil {
		return this.Report
	}
	if this.Commit != nil {
		return this.Commit
	}
	if this.Seal != nil {
		return this.Seal
	}
	if this.Unseal != nil {
		return this.Unseal
	}
	if this.AddPeer != nil {
		return this.AddPeer
	}
	if this.RemovePeer != nil {
		return this.RemovePeer
	}
	if this.Endpoint != nil {
		return this.Endpoint
	}
	if this.RecoverStateMachine != nil {
		return this.RecoverStateMachine
	}
	if this.RegisterTopic != nil {
		return this.RegisterTopic
	}
	if this.UnregisterTopic != nil {
		return this.UnregisterTopic
	}
	return nil
}

func (this *RaftEntry_Request) SetValue(value interface{}) bool {
	switch vt := value.(type) {
	case *RegisterStorageNode:
		this.RegisterStorageNode = vt
	case *UnregisterStorageNode:
		this.UnregisterStorageNode = vt
	case *RegisterLogStream:
		this.RegisterLogStream = vt
	case *UnregisterLogStream:
		this.UnregisterLogStream = vt
	case *UpdateLogStream:
		this.UpdateLogStream = vt
	case *Reports:
		this.Report = vt
	case *Commit:
		this.Commit = vt
	case *Seal:
		this.Seal = vt
	case *Unseal:
		this.Unseal = vt
	case *AddPeer:
		this.AddPeer = vt
	case *RemovePeer:
		this.RemovePeer = vt
	case *Endpoint:
		this.Endpoint = vt
	case *RecoverStateMachine:
		this.RecoverStateMachine = vt
	case *RegisterTopic:
		this.RegisterTopic = vt
	case *UnregisterTopic:
		this.UnregisterTopic = vt
	default:
		return false
	}
	return true
}
func (m *RegisterStorageNode) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterStorageNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterStorageNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageNode", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageNode == nil {
				m.StorageNode = &varlogpb.StorageNodeDescriptor{}
			}
			if err := m.StorageNode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnregisterStorageNode) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: UnregisterStorageNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnregisterStorageNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageNodeID", wireType)
			}
			m.StorageNodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageNodeID |= github_com_kakao_varlog_pkg_types.StorageNodeID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterTopic) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterTopic: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterTopic: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicID", wireType)
			}
			m.TopicID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicID |= github_com_kakao_varlog_pkg_types.TopicID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnregisterTopic) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: UnregisterTopic: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnregisterTopic: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicID", wireType)
			}
			m.TopicID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicID |= github_com_kakao_varlog_pkg_types.TopicID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterLogStream) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterLogStream: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterLogStream: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogStream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogStream == nil {
				m.LogStream = &varlogpb.LogStreamDescriptor{}
			}
			if err := m.LogStream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnregisterLogStream) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: UnregisterLogStream: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnregisterLogStream: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogStreamID", wireType)
			}
			m.LogStreamID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogStreamID |= github_com_kakao_varlog_pkg_types.LogStreamID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateLogStream) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: UpdateLogStream: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateLogStream: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogStream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogStream == nil {
				m.LogStream = &varlogpb.LogStreamDescriptor{}
			}
			if err := m.LogStream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Report) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: Report: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Report: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageNodeID", wireType)
			}
			m.StorageNodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StorageNodeID |= github_com_kakao_varlog_pkg_types.StorageNodeID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UncommitReport", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UncommitReport = append(m.UncommitReport, snpb.LogStreamUncommitReport{})
			if err := m.UncommitReport[len(m.UncommitReport)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Reports) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: Reports: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Reports: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= github_com_kakao_varlog_pkg_types.NodeID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reports = append(m.Reports, &Report{})
			if err := m.Reports[len(m.Reports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Commit) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: Commit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Commit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= github_com_kakao_varlog_pkg_types.NodeID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Seal) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: Seal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Seal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogStreamID", wireType)
			}
			m.LogStreamID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogStreamID |= github_com_kakao_varlog_pkg_types.LogStreamID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Unseal) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: Unseal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Unseal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogStreamID", wireType)
			}
			m.LogStreamID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogStreamID |= github_com_kakao_varlog_pkg_types.LogStreamID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddPeer) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: AddPeer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddPeer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= github_com_kakao_varlog_pkg_types.NodeID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsLearner", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsLearner = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemovePeer) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: RemovePeer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemovePeer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= github_com_kakao_varlog_pkg_types.NodeID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Endpoint) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: Endpoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Endpoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= github_com_kakao_varlog_pkg_types.NodeID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecoverStateMachine) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: RecoverStateMachine: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecoverStateMachine: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateMachine", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StateMachine == nil {
				m.StateMachine = &MetadataRepositoryDescriptor{}
			}
			if err := m.StateMachine.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RaftEntry) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: RaftEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeIndex", wireType)
			}
			m.NodeIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestIndex", wireType)
			}
			m.RequestIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppliedIndex", wireType)
			}
			m.AppliedIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AppliedIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RaftEntry_Request) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftEntry
			}
			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)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterStorageNode", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RegisterStorageNode == nil {
				m.RegisterStorageNode = &RegisterStorageNode{}
			}
			if err := m.RegisterStorageNode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnregisterStorageNode", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnregisterStorageNode == nil {
				m.UnregisterStorageNode = &UnregisterStorageNode{}
			}
			if err := m.UnregisterStorageNode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterLogStream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RegisterLogStream == nil {
				m.RegisterLogStream = &RegisterLogStream{}
			}
			if err := m.RegisterLogStream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnregisterLogStream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnregisterLogStream == nil {
				m.UnregisterLogStream = &UnregisterLogStream{}
			}
			if err := m.UnregisterLogStream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateLogStream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdateLogStream == nil {
				m.UpdateLogStream = &UpdateLogStream{}
			}
			if err := m.UpdateLogStream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Report", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Report == nil {
				m.Report = &Reports{}
			}
			if err := m.Report.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Commit == nil {
				m.Commit = &Commit{}
			}
			if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seal", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Seal == nil {
				m.Seal = &Seal{}
			}
			if err := m.Seal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unseal", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Unseal == nil {
				m.Unseal = &Unseal{}
			}
			if err := m.Unseal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddPeer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AddPeer == nil {
				m.AddPeer = &AddPeer{}
			}
			if err := m.AddPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemovePeer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RemovePeer == nil {
				m.RemovePeer = &RemovePeer{}
			}
			if err := m.RemovePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Endpoint == nil {
				m.Endpoint = &Endpoint{}
			}
			if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecoverStateMachine", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RecoverStateMachine == nil {
				m.RecoverStateMachine = &RecoverStateMachine{}
			}
			if err := m.RecoverStateMachine.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterTopic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RegisterTopic == nil {
				m.RegisterTopic = &RegisterTopic{}
			}
			if err := m.RegisterTopic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnregisterTopic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftEntry
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnregisterTopic == nil {
				m.UnregisterTopic = &UnregisterTopic{}
			}
			if err := m.UnregisterTopic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftEntry(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRaftEntry
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRaftEntry(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowRaftEntry
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRaftEntry
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthRaftEntry
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupRaftEntry
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthRaftEntry
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthRaftEntry        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRaftEntry          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRaftEntry = fmt.Errorf("proto: unexpected end of group")
)