metadata.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: proto/varlogpb/metadata.proto

package varlogpb

import (
	bytes "bytes"
	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"
)

// 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 StorageNodeStatus int32

const (
	StorageNodeStatusRunning StorageNodeStatus = 0
	StorageNodeStatusDeleted StorageNodeStatus = 1
)

var StorageNodeStatus_name = map[int32]string{
	0: "STORAGE_NODE_STATUS_RUNNING",
	1: "STORAGE_NODE_STATUS_DELETED",
}

var StorageNodeStatus_value = map[string]int32{
	"STORAGE_NODE_STATUS_RUNNING": 0,
	"STORAGE_NODE_STATUS_DELETED": 1,
}

func (x StorageNodeStatus) String() string {
	return proto.EnumName(StorageNodeStatus_name, int32(x))
}

func (StorageNodeStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{0}
}

type LogStreamStatus int32

const (
	LogStreamStatusRunning   LogStreamStatus = 0
	LogStreamStatusSealing   LogStreamStatus = 1
	LogStreamStatusSealed    LogStreamStatus = 2
	LogStreamStatusDeleted   LogStreamStatus = 3
	LogStreamStatusUnsealing LogStreamStatus = 4
)

var LogStreamStatus_name = map[int32]string{
	0: "LS_STATUS_RUNNING",
	1: "LS_STATUS_SEALING",
	2: "LS_STATUS_SEALED",
	3: "LS_STATUS_DELETED",
	4: "LS_STATUS_UNSEALING",
}

var LogStreamStatus_value = map[string]int32{
	"LS_STATUS_RUNNING":   0,
	"LS_STATUS_SEALING":   1,
	"LS_STATUS_SEALED":    2,
	"LS_STATUS_DELETED":   3,
	"LS_STATUS_UNSEALING": 4,
}

func (x LogStreamStatus) String() string {
	return proto.EnumName(LogStreamStatus_name, int32(x))
}

func (LogStreamStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{1}
}

type TopicStatus int32

const (
	TopicStatusRunning TopicStatus = 0
	TopicStatusDeleted TopicStatus = 1
)

var TopicStatus_name = map[int32]string{
	0: "TOPIC_STATUS_RUNNING",
	1: "TOPIC_STATUS_DELETED",
}

var TopicStatus_value = map[string]int32{
	"TOPIC_STATUS_RUNNING": 0,
	"TOPIC_STATUS_DELETED": 1,
}

func (x TopicStatus) String() string {
	return proto.EnumName(TopicStatus_name, int32(x))
}

func (TopicStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{2}
}

// MetadataDescriptor is metadata to persist the overall state of the cluster in
// the metadata repository.
type MetadataDescriptor struct {
	AppliedIndex uint64                   `protobuf:"varint,1,opt,name=applied_index,json=appliedIndex,proto3" json:"appliedIndex"`
	StorageNodes []*StorageNodeDescriptor `protobuf:"bytes,2,rep,name=storage_nodes,json=storageNodes,proto3" json:"storageNodes"`
	LogStreams   []*LogStreamDescriptor   `protobuf:"bytes,3,rep,name=log_streams,json=logStreams,proto3" json:"logStreams"`
	Topics       []*TopicDescriptor       `protobuf:"bytes,4,rep,name=topics,proto3" json:"topics"`
}

func (m *MetadataDescriptor) Reset()         { *m = MetadataDescriptor{} }
func (m *MetadataDescriptor) String() string { return proto.CompactTextString(m) }
func (*MetadataDescriptor) ProtoMessage()    {}
func (*MetadataDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{0}
}
func (m *MetadataDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetadataDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetadataDescriptor.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 *MetadataDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataDescriptor.Merge(m, src)
}
func (m *MetadataDescriptor) XXX_Size() int {
	return m.ProtoSize()
}
func (m *MetadataDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataDescriptor proto.InternalMessageInfo

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

func (m *MetadataDescriptor) GetStorageNodes() []*StorageNodeDescriptor {
	if m != nil {
		return m.StorageNodes
	}
	return nil
}

func (m *MetadataDescriptor) GetLogStreams() []*LogStreamDescriptor {
	if m != nil {
		return m.LogStreams
	}
	return nil
}

func (m *MetadataDescriptor) GetTopics() []*TopicDescriptor {
	if m != nil {
		return m.Topics
	}
	return nil
}

// StorageNodeDescriptor is immutable metadata to persist information of a
// storage node in the metadata repository.
// It is also used to compare two storage nodes to decide if they are the same.
//
// Note that only immutable fields should be added.
type StorageNodeDescriptor struct {
	StorageNode `protobuf:"bytes,1,opt,name=storage_node,json=storageNode,proto3,embedded=storage_node" json:""`
	Status      StorageNodeStatus `protobuf:"varint,2,opt,name=status,proto3,enum=varlog.varlogpb.StorageNodeStatus" json:"status,omitempty"`
	Paths       []string          `protobuf:"bytes,3,rep,name=paths,proto3" json:"paths,omitempty"`
	CreateTime  time.Time         `protobuf:"bytes,4,opt,name=create_time,json=createTime,proto3,stdtime" json:"createTime"`
}

func (m *StorageNodeDescriptor) Reset()         { *m = StorageNodeDescriptor{} }
func (m *StorageNodeDescriptor) String() string { return proto.CompactTextString(m) }
func (*StorageNodeDescriptor) ProtoMessage()    {}
func (*StorageNodeDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{1}
}
func (m *StorageNodeDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StorageNodeDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StorageNodeDescriptor.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 *StorageNodeDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageNodeDescriptor.Merge(m, src)
}
func (m *StorageNodeDescriptor) XXX_Size() int {
	return m.ProtoSize()
}
func (m *StorageNodeDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageNodeDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_StorageNodeDescriptor proto.InternalMessageInfo

func (m *StorageNodeDescriptor) GetStatus() StorageNodeStatus {
	if m != nil {
		return m.Status
	}
	return StorageNodeStatusRunning
}

func (m *StorageNodeDescriptor) GetPaths() []string {
	if m != nil {
		return m.Paths
	}
	return nil
}

func (m *StorageNodeDescriptor) GetCreateTime() time.Time {
	if m != nil {
		return m.CreateTime
	}
	return time.Time{}
}

type StorageDescriptor struct {
	Path  string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Used  uint64 `protobuf:"varint,2,opt,name=used,proto3" json:"used,omitempty"`
	Total uint64 `protobuf:"varint,3,opt,name=total,proto3" json:"total,omitempty"`
}

func (m *StorageDescriptor) Reset()         { *m = StorageDescriptor{} }
func (m *StorageDescriptor) String() string { return proto.CompactTextString(m) }
func (*StorageDescriptor) ProtoMessage()    {}
func (*StorageDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{2}
}
func (m *StorageDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StorageDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StorageDescriptor.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 *StorageDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageDescriptor.Merge(m, src)
}
func (m *StorageDescriptor) XXX_Size() int {
	return m.ProtoSize()
}
func (m *StorageDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_StorageDescriptor proto.InternalMessageInfo

func (m *StorageDescriptor) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *StorageDescriptor) GetUsed() uint64 {
	if m != nil {
		return m.Used
	}
	return 0
}

func (m *StorageDescriptor) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

// LogStreamDescriptor is metadata to persist information of a log stream in the
// metadata repository.
type LogStreamDescriptor 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:"topicId"`
	LogStreamID github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,2,opt,name=log_stream_id,json=logStreamId,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"logStreamId"`
	Status      LogStreamStatus                               `protobuf:"varint,3,opt,name=status,proto3,enum=varlog.varlogpb.LogStreamStatus" json:"status,omitempty"`
	Replicas    []*ReplicaDescriptor                          `protobuf:"bytes,4,rep,name=replicas,proto3" json:"replicas,omitempty"`
	// Deprecated: The members - head and tail are not used by the metadata
	// repository. It exists here just since the LogStreamDescriptor is used
	// elsewhere other than the metadata repository. It leads to misusing the
	// LogStreamDescriptor.
	Head LogEntryMeta `protobuf:"bytes,5,opt,name=head,proto3" json:"head,omitempty"`
	Tail LogEntryMeta `protobuf:"bytes,6,opt,name=tail,proto3" json:"tail,omitempty"`
}

func (m *LogStreamDescriptor) Reset()         { *m = LogStreamDescriptor{} }
func (m *LogStreamDescriptor) String() string { return proto.CompactTextString(m) }
func (*LogStreamDescriptor) ProtoMessage()    {}
func (*LogStreamDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{3}
}
func (m *LogStreamDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogStreamDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogStreamDescriptor.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 *LogStreamDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogStreamDescriptor.Merge(m, src)
}
func (m *LogStreamDescriptor) XXX_Size() int {
	return m.ProtoSize()
}
func (m *LogStreamDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_LogStreamDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_LogStreamDescriptor proto.InternalMessageInfo

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

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

func (m *LogStreamDescriptor) GetStatus() LogStreamStatus {
	if m != nil {
		return m.Status
	}
	return LogStreamStatusRunning
}

func (m *LogStreamDescriptor) GetReplicas() []*ReplicaDescriptor {
	if m != nil {
		return m.Replicas
	}
	return nil
}

func (m *LogStreamDescriptor) GetHead() LogEntryMeta {
	if m != nil {
		return m.Head
	}
	return LogEntryMeta{}
}

func (m *LogStreamDescriptor) GetTail() LogEntryMeta {
	if m != nil {
		return m.Tail
	}
	return LogEntryMeta{}
}

// ReplicaDescriptor represents a storage node and directory where a log stream
// replica exists.
type ReplicaDescriptor struct {
	// StorageNodeID for a storage node where the replica is served.
	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:"storageNodeId"`
	// StorageNodePath is a parent directory where the data path for the replica
	// exists.
	StorageNodePath string `protobuf:"bytes,2,opt,name=storage_node_path,json=storageNodePath,proto3" json:"storageNodePath"`
	// DataPath is a directory where the log stream replica stores its data, for
	// instance, logs appended, commit history, etc.
	DataPath string `protobuf:"bytes,3,opt,name=data_path,json=dataPath,proto3" json:"dataPath"`
}

func (m *ReplicaDescriptor) Reset()         { *m = ReplicaDescriptor{} }
func (m *ReplicaDescriptor) String() string { return proto.CompactTextString(m) }
func (*ReplicaDescriptor) ProtoMessage()    {}
func (*ReplicaDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{4}
}
func (m *ReplicaDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicaDescriptor.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 *ReplicaDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaDescriptor.Merge(m, src)
}
func (m *ReplicaDescriptor) XXX_Size() int {
	return m.ProtoSize()
}
func (m *ReplicaDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaDescriptor proto.InternalMessageInfo

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

func (m *ReplicaDescriptor) GetStorageNodePath() string {
	if m != nil {
		return m.StorageNodePath
	}
	return ""
}

func (m *ReplicaDescriptor) GetDataPath() string {
	if m != nil {
		return m.DataPath
	}
	return ""
}

// TopicDescriptor is metadata to persist information of a topic in the metadata
// repository.
type TopicDescriptor 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:"topicId"`
	Status     TopicStatus                                     `protobuf:"varint,2,opt,name=status,proto3,enum=varlog.varlogpb.TopicStatus" json:"status"`
	LogStreams []github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,3,rep,packed,name=log_streams,json=logStreams,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"logStreams,omitempty"`
}

func (m *TopicDescriptor) Reset()         { *m = TopicDescriptor{} }
func (m *TopicDescriptor) String() string { return proto.CompactTextString(m) }
func (*TopicDescriptor) ProtoMessage()    {}
func (*TopicDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{5}
}
func (m *TopicDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicDescriptor.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 *TopicDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicDescriptor.Merge(m, src)
}
func (m *TopicDescriptor) XXX_Size() int {
	return m.ProtoSize()
}
func (m *TopicDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_TopicDescriptor proto.InternalMessageInfo

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

func (m *TopicDescriptor) GetStatus() TopicStatus {
	if m != nil {
		return m.Status
	}
	return TopicStatusRunning
}

func (m *TopicDescriptor) GetLogStreams() []github_com_kakao_varlog_pkg_types.LogStreamID {
	if m != nil {
		return m.LogStreams
	}
	return nil
}

// StorageNode is a structure to represent identifier and address of storage
// node.
type StorageNode 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:"storageNodeId"`
	Address       string                                          `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *StorageNode) Reset()         { *m = StorageNode{} }
func (m *StorageNode) String() string { return proto.CompactTextString(m) }
func (*StorageNode) ProtoMessage()    {}
func (*StorageNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{6}
}
func (m *StorageNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StorageNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StorageNode.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 *StorageNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageNode.Merge(m, src)
}
func (m *StorageNode) XXX_Size() int {
	return m.ProtoSize()
}
func (m *StorageNode) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageNode.DiscardUnknown(m)
}

var xxx_messageInfo_StorageNode proto.InternalMessageInfo

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

func (m *StorageNode) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

// TopicLogStream wraps TopicID and LogStreamID.
type TopicLogStream 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:"topicId"`
	LogStreamID github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,2,opt,name=log_stream_id,json=logStreamId,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"logStreamId"`
}

func (m *TopicLogStream) Reset()         { *m = TopicLogStream{} }
func (m *TopicLogStream) String() string { return proto.CompactTextString(m) }
func (*TopicLogStream) ProtoMessage()    {}
func (*TopicLogStream) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{7}
}
func (m *TopicLogStream) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicLogStream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicLogStream.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 *TopicLogStream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicLogStream.Merge(m, src)
}
func (m *TopicLogStream) XXX_Size() int {
	return m.ProtoSize()
}
func (m *TopicLogStream) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicLogStream.DiscardUnknown(m)
}

var xxx_messageInfo_TopicLogStream proto.InternalMessageInfo

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

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

// LogStreamReplica represents replica of log stream.
type LogStreamReplica struct {
	StorageNode    `protobuf:"bytes,1,opt,name=storage_node,json=storageNode,proto3,embedded=storage_node" json:""`
	TopicLogStream `protobuf:"bytes,2,opt,name=topic_log_stream,json=topicLogStream,proto3,embedded=topic_log_stream" json:""`
}

func (m *LogStreamReplica) Reset()         { *m = LogStreamReplica{} }
func (m *LogStreamReplica) String() string { return proto.CompactTextString(m) }
func (*LogStreamReplica) ProtoMessage()    {}
func (*LogStreamReplica) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{8}
}
func (m *LogStreamReplica) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogStreamReplica) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogStreamReplica.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 *LogStreamReplica) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogStreamReplica.Merge(m, src)
}
func (m *LogStreamReplica) XXX_Size() int {
	return m.ProtoSize()
}
func (m *LogStreamReplica) XXX_DiscardUnknown() {
	xxx_messageInfo_LogStreamReplica.DiscardUnknown(m)
}

var xxx_messageInfo_LogStreamReplica proto.InternalMessageInfo

// LogSequenceNumber wraps LLSN and GLSN.
// LLSN is the sequence number of logs in a log stream.
// GLSN is the sequence number of logs in a topic.
type LogSequenceNumber struct {
	LLSN github_com_kakao_varlog_pkg_types.LLSN `protobuf:"varint,1,opt,name=llsn,proto3,casttype=github.com/kakao/varlog/pkg/types.LLSN" json:"llsn,omitempty"`
	GLSN github_com_kakao_varlog_pkg_types.GLSN `protobuf:"varint,2,opt,name=glsn,proto3,casttype=github.com/kakao/varlog/pkg/types.GLSN" json:"glsn,omitempty"`
}

func (m *LogSequenceNumber) Reset()         { *m = LogSequenceNumber{} }
func (m *LogSequenceNumber) String() string { return proto.CompactTextString(m) }
func (*LogSequenceNumber) ProtoMessage()    {}
func (*LogSequenceNumber) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{9}
}
func (m *LogSequenceNumber) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogSequenceNumber) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogSequenceNumber.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 *LogSequenceNumber) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogSequenceNumber.Merge(m, src)
}
func (m *LogSequenceNumber) XXX_Size() int {
	return m.ProtoSize()
}
func (m *LogSequenceNumber) XXX_DiscardUnknown() {
	xxx_messageInfo_LogSequenceNumber.DiscardUnknown(m)
}

var xxx_messageInfo_LogSequenceNumber proto.InternalMessageInfo

func (m *LogSequenceNumber) GetLLSN() github_com_kakao_varlog_pkg_types.LLSN {
	if m != nil {
		return m.LLSN
	}
	return 0
}

func (m *LogSequenceNumber) GetGLSN() github_com_kakao_varlog_pkg_types.GLSN {
	if m != nil {
		return m.GLSN
	}
	return 0
}

type LogEntryMeta 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"`
	LogStreamID github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,2,opt,name=log_stream_id,json=logStreamId,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"log_stream_id,omitempty"`
	GLSN        github_com_kakao_varlog_pkg_types.GLSN        `protobuf:"varint,3,opt,name=glsn,proto3,casttype=github.com/kakao/varlog/pkg/types.GLSN" json:"glsn,omitempty"`
	LLSN        github_com_kakao_varlog_pkg_types.LLSN        `protobuf:"varint,4,opt,name=llsn,proto3,casttype=github.com/kakao/varlog/pkg/types.LLSN" json:"llsn,omitempty"`
}

func (m *LogEntryMeta) Reset()         { *m = LogEntryMeta{} }
func (m *LogEntryMeta) String() string { return proto.CompactTextString(m) }
func (*LogEntryMeta) ProtoMessage()    {}
func (*LogEntryMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{10}
}
func (m *LogEntryMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogEntryMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogEntryMeta.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 *LogEntryMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogEntryMeta.Merge(m, src)
}
func (m *LogEntryMeta) XXX_Size() int {
	return m.ProtoSize()
}
func (m *LogEntryMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_LogEntryMeta.DiscardUnknown(m)
}

var xxx_messageInfo_LogEntryMeta proto.InternalMessageInfo

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

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

func (m *LogEntryMeta) GetGLSN() github_com_kakao_varlog_pkg_types.GLSN {
	if m != nil {
		return m.GLSN
	}
	return 0
}

func (m *LogEntryMeta) GetLLSN() github_com_kakao_varlog_pkg_types.LLSN {
	if m != nil {
		return m.LLSN
	}
	return 0
}

type LogEntry struct {
	LogEntryMeta `protobuf:"bytes,1,opt,name=meta,proto3,embedded=meta" json:"meta"`
	Data         []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *LogEntry) Reset()         { *m = LogEntry{} }
func (m *LogEntry) String() string { return proto.CompactTextString(m) }
func (*LogEntry) ProtoMessage()    {}
func (*LogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{11}
}
func (m *LogEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogEntry.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 *LogEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogEntry.Merge(m, src)
}
func (m *LogEntry) XXX_Size() int {
	return m.ProtoSize()
}
func (m *LogEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_LogEntry.DiscardUnknown(m)
}

var xxx_messageInfo_LogEntry proto.InternalMessageInfo

func (m *LogEntry) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type CommitContext struct {
	Version            github_com_kakao_varlog_pkg_types.Version `protobuf:"varint,1,opt,name=version,proto3,casttype=github.com/kakao/varlog/pkg/types.Version" json:"version,omitempty"`
	HighWatermark      github_com_kakao_varlog_pkg_types.GLSN    `protobuf:"varint,2,opt,name=high_watermark,json=highWatermark,proto3,casttype=github.com/kakao/varlog/pkg/types.GLSN" json:"high_watermark,omitempty"`
	CommittedGLSNBegin github_com_kakao_varlog_pkg_types.GLSN    `protobuf:"varint,3,opt,name=committed_glsn_begin,json=committedGlsnBegin,proto3,casttype=github.com/kakao/varlog/pkg/types.GLSN" json:"committed_glsn_begin,omitempty"`
	CommittedGLSNEnd   github_com_kakao_varlog_pkg_types.GLSN    `protobuf:"varint,4,opt,name=committed_glsn_end,json=committedGlsnEnd,proto3,casttype=github.com/kakao/varlog/pkg/types.GLSN" json:"committed_glsn_end,omitempty"`
	CommittedLLSNBegin github_com_kakao_varlog_pkg_types.LLSN    `protobuf:"varint,5,opt,name=committed_llsn_begin,json=committedLlsnBegin,proto3,casttype=github.com/kakao/varlog/pkg/types.LLSN" json:"committed_llsn_begin,omitempty"`
}

func (m *CommitContext) Reset()         { *m = CommitContext{} }
func (m *CommitContext) String() string { return proto.CompactTextString(m) }
func (*CommitContext) ProtoMessage()    {}
func (*CommitContext) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{12}
}
func (m *CommitContext) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CommitContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommitContext.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 *CommitContext) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitContext.Merge(m, src)
}
func (m *CommitContext) XXX_Size() int {
	return m.ProtoSize()
}
func (m *CommitContext) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitContext.DiscardUnknown(m)
}

var xxx_messageInfo_CommitContext proto.InternalMessageInfo

func (m *CommitContext) GetVersion() github_com_kakao_varlog_pkg_types.Version {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *CommitContext) GetHighWatermark() github_com_kakao_varlog_pkg_types.GLSN {
	if m != nil {
		return m.HighWatermark
	}
	return 0
}

func (m *CommitContext) GetCommittedGLSNBegin() github_com_kakao_varlog_pkg_types.GLSN {
	if m != nil {
		return m.CommittedGLSNBegin
	}
	return 0
}

func (m *CommitContext) GetCommittedGLSNEnd() github_com_kakao_varlog_pkg_types.GLSN {
	if m != nil {
		return m.CommittedGLSNEnd
	}
	return 0
}

func (m *CommitContext) GetCommittedLLSNBegin() github_com_kakao_varlog_pkg_types.LLSN {
	if m != nil {
		return m.CommittedLLSNBegin
	}
	return 0
}

type MetadataRepositoryNode 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:"nodeId"`
	RaftURL string                                   `protobuf:"bytes,2,opt,name=raft_url,json=raftUrl,proto3" json:"raftURL"`
	RPCAddr string                                   `protobuf:"bytes,3,opt,name=rpc_addr,json=rpcAddr,proto3" json:"rpcAddr"`
	Leader  bool                                     `protobuf:"varint,4,opt,name=leader,proto3" json:"leader"`
	Learner bool                                     `protobuf:"varint,5,opt,name=learner,proto3" json:"learner"`
}

func (m *MetadataRepositoryNode) Reset()         { *m = MetadataRepositoryNode{} }
func (m *MetadataRepositoryNode) String() string { return proto.CompactTextString(m) }
func (*MetadataRepositoryNode) ProtoMessage()    {}
func (*MetadataRepositoryNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_eb4411772ca3492a, []int{13}
}
func (m *MetadataRepositoryNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetadataRepositoryNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetadataRepositoryNode.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 *MetadataRepositoryNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataRepositoryNode.Merge(m, src)
}
func (m *MetadataRepositoryNode) XXX_Size() int {
	return m.ProtoSize()
}
func (m *MetadataRepositoryNode) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataRepositoryNode.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataRepositoryNode proto.InternalMessageInfo

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

func (m *MetadataRepositoryNode) GetRaftURL() string {
	if m != nil {
		return m.RaftURL
	}
	return ""
}

func (m *MetadataRepositoryNode) GetRPCAddr() string {
	if m != nil {
		return m.RPCAddr
	}
	return ""
}

func (m *MetadataRepositoryNode) GetLeader() bool {
	if m != nil {
		return m.Leader
	}
	return false
}

func (m *MetadataRepositoryNode) GetLearner() bool {
	if m != nil {
		return m.Learner
	}
	return false
}

func init() {
	proto.RegisterEnum("varlog.varlogpb.StorageNodeStatus", StorageNodeStatus_name, StorageNodeStatus_value)
	proto.RegisterEnum("varlog.varlogpb.LogStreamStatus", LogStreamStatus_name, LogStreamStatus_value)
	proto.RegisterEnum("varlog.varlogpb.TopicStatus", TopicStatus_name, TopicStatus_value)
	proto.RegisterType((*MetadataDescriptor)(nil), "varlog.varlogpb.MetadataDescriptor")
	proto.RegisterType((*StorageNodeDescriptor)(nil), "varlog.varlogpb.StorageNodeDescriptor")
	proto.RegisterType((*StorageDescriptor)(nil), "varlog.varlogpb.StorageDescriptor")
	proto.RegisterType((*LogStreamDescriptor)(nil), "varlog.varlogpb.LogStreamDescriptor")
	proto.RegisterType((*ReplicaDescriptor)(nil), "varlog.varlogpb.ReplicaDescriptor")
	proto.RegisterType((*TopicDescriptor)(nil), "varlog.varlogpb.TopicDescriptor")
	proto.RegisterType((*StorageNode)(nil), "varlog.varlogpb.StorageNode")
	proto.RegisterType((*TopicLogStream)(nil), "varlog.varlogpb.TopicLogStream")
	proto.RegisterType((*LogStreamReplica)(nil), "varlog.varlogpb.LogStreamReplica")
	proto.RegisterType((*LogSequenceNumber)(nil), "varlog.varlogpb.LogSequenceNumber")
	proto.RegisterType((*LogEntryMeta)(nil), "varlog.varlogpb.LogEntryMeta")
	proto.RegisterType((*LogEntry)(nil), "varlog.varlogpb.LogEntry")
	proto.RegisterType((*CommitContext)(nil), "varlog.varlogpb.CommitContext")
	proto.RegisterType((*MetadataRepositoryNode)(nil), "varlog.varlogpb.MetadataRepositoryNode")
}

func init() { proto.RegisterFile("proto/varlogpb/metadata.proto", fileDescriptor_eb4411772ca3492a) }

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

func (this *MetadataDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataDescriptor)
	if !ok {
		that2, ok := that.(MetadataDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AppliedIndex != that1.AppliedIndex {
		return false
	}
	if len(this.StorageNodes) != len(that1.StorageNodes) {
		return false
	}
	for i := range this.StorageNodes {
		if !this.StorageNodes[i].Equal(that1.StorageNodes[i]) {
			return false
		}
	}
	if len(this.LogStreams) != len(that1.LogStreams) {
		return false
	}
	for i := range this.LogStreams {
		if !this.LogStreams[i].Equal(that1.LogStreams[i]) {
			return false
		}
	}
	if len(this.Topics) != len(that1.Topics) {
		return false
	}
	for i := range this.Topics {
		if !this.Topics[i].Equal(that1.Topics[i]) {
			return false
		}
	}
	return true
}
func (this *StorageNodeDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StorageNodeDescriptor)
	if !ok {
		that2, ok := that.(StorageNodeDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.StorageNode.Equal(&that1.StorageNode) {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if len(this.Paths) != len(that1.Paths) {
		return false
	}
	for i := range this.Paths {
		if this.Paths[i] != that1.Paths[i] {
			return false
		}
	}
	if !this.CreateTime.Equal(that1.CreateTime) {
		return false
	}
	return true
}
func (this *StorageDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StorageDescriptor)
	if !ok {
		that2, ok := that.(StorageDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Path != that1.Path {
		return false
	}
	if this.Used != that1.Used {
		return false
	}
	if this.Total != that1.Total {
		return false
	}
	return true
}
func (this *LogStreamDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogStreamDescriptor)
	if !ok {
		that2, ok := that.(LogStreamDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TopicID != that1.TopicID {
		return false
	}
	if this.LogStreamID != that1.LogStreamID {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if len(this.Replicas) != len(that1.Replicas) {
		return false
	}
	for i := range this.Replicas {
		if !this.Replicas[i].Equal(that1.Replicas[i]) {
			return false
		}
	}
	if !this.Head.Equal(&that1.Head) {
		return false
	}
	if !this.Tail.Equal(&that1.Tail) {
		return false
	}
	return true
}
func (this *ReplicaDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaDescriptor)
	if !ok {
		that2, ok := that.(ReplicaDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StorageNodeID != that1.StorageNodeID {
		return false
	}
	if this.StorageNodePath != that1.StorageNodePath {
		return false
	}
	if this.DataPath != that1.DataPath {
		return false
	}
	return true
}
func (this *TopicDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TopicDescriptor)
	if !ok {
		that2, ok := that.(TopicDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TopicID != that1.TopicID {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if len(this.LogStreams) != len(that1.LogStreams) {
		return false
	}
	for i := range this.LogStreams {
		if this.LogStreams[i] != that1.LogStreams[i] {
			return false
		}
	}
	return true
}
func (this *StorageNode) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StorageNode)
	if !ok {
		that2, ok := that.(StorageNode)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StorageNodeID != that1.StorageNodeID {
		return false
	}
	if this.Address != that1.Address {
		return false
	}
	return true
}
func (this *TopicLogStream) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TopicLogStream)
	if !ok {
		that2, ok := that.(TopicLogStream)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TopicID != that1.TopicID {
		return false
	}
	if this.LogStreamID != that1.LogStreamID {
		return false
	}
	return true
}
func (this *LogStreamReplica) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogStreamReplica)
	if !ok {
		that2, ok := that.(LogStreamReplica)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.StorageNode.Equal(&that1.StorageNode) {
		return false
	}
	if !this.TopicLogStream.Equal(&that1.TopicLogStream) {
		return false
	}
	return true
}
func (this *LogSequenceNumber) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogSequenceNumber)
	if !ok {
		that2, ok := that.(LogSequenceNumber)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.LLSN != that1.LLSN {
		return false
	}
	if this.GLSN != that1.GLSN {
		return false
	}
	return true
}
func (this *LogEntryMeta) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogEntryMeta)
	if !ok {
		that2, ok := that.(LogEntryMeta)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TopicID != that1.TopicID {
		return false
	}
	if this.LogStreamID != that1.LogStreamID {
		return false
	}
	if this.GLSN != that1.GLSN {
		return false
	}
	if this.LLSN != that1.LLSN {
		return false
	}
	return true
}
func (this *LogEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogEntry)
	if !ok {
		that2, ok := that.(LogEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.LogEntryMeta.Equal(&that1.LogEntryMeta) {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	return true
}
func (m *MetadataDescriptor) 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 *MetadataDescriptor) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Topics) > 0 {
		for iNdEx := len(m.Topics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Topics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.LogStreams) > 0 {
		for iNdEx := len(m.LogStreams) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LogStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.StorageNodes) > 0 {
		for iNdEx := len(m.StorageNodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StorageNodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.AppliedIndex != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.AppliedIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StorageNodeDescriptor) 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 *StorageNodeDescriptor) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StorageNodeDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreateTime):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintMetadata(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x22
	if len(m.Paths) > 0 {
		for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Paths[iNdEx])
			copy(dAtA[i:], m.Paths[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.Paths[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Status != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.StorageNode.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetadata(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *StorageDescriptor) 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 *StorageDescriptor) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StorageDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Total != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x18
	}
	if m.Used != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Used))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LogStreamDescriptor) 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 *LogStreamDescriptor) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogStreamDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Tail.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetadata(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size, err := m.Head.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetadata(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Replicas) > 0 {
		for iNdEx := len(m.Replicas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Replicas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Status != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x18
	}
	if m.LogStreamID != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.LogStreamID))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicID != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.TopicID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ReplicaDescriptor) 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 *ReplicaDescriptor) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReplicaDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DataPath) > 0 {
		i -= len(m.DataPath)
		copy(dAtA[i:], m.DataPath)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.DataPath)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.StorageNodePath) > 0 {
		i -= len(m.StorageNodePath)
		copy(dAtA[i:], m.StorageNodePath)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.StorageNodePath)))
		i--
		dAtA[i] = 0x12
	}
	if m.StorageNodeID != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StorageNodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicDescriptor) 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 *TopicDescriptor) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TopicDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LogStreams) > 0 {
		dAtA6 := make([]byte, len(m.LogStreams)*10)
		var j5 int
		for _, num1 := range m.LogStreams {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		i -= j5
		copy(dAtA[i:], dAtA6[:j5])
		i = encodeVarintMetadata(dAtA, i, uint64(j5))
		i--
		dAtA[i] = 0x1a
	}
	if m.Status != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicID != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.TopicID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StorageNode) 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 *StorageNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *TopicLogStream) 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 *TopicLogStream) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *LogStreamReplica) 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 *LogStreamReplica) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *LogSequenceNumber) 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 *LogSequenceNumber) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogSequenceNumber) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GLSN != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.GLSN))
		i--
		dAtA[i] = 0x10
	}
	if m.LLSN != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.LLSN))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LogEntryMeta) 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 *LogEntryMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogEntryMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LLSN != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.LLSN))
		i--
		dAtA[i] = 0x20
	}
	if m.GLSN != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.GLSN))
		i--
		dAtA[i] = 0x18
	}
	if m.LogStreamID != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.LogStreamID))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicID != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.TopicID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LogEntry) 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 *LogEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.LogEntryMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetadata(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *CommitContext) 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 *CommitContext) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CommitContext) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CommittedLLSNBegin != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.CommittedLLSNBegin))
		i--
		dAtA[i] = 0x28
	}
	if m.CommittedGLSNEnd != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.CommittedGLSNEnd))
		i--
		dAtA[i] = 0x20
	}
	if m.CommittedGLSNBegin != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.CommittedGLSNBegin))
		i--
		dAtA[i] = 0x18
	}
	if m.HighWatermark != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.HighWatermark))
		i--
		dAtA[i] = 0x10
	}
	if m.Version != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MetadataRepositoryNode) 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 *MetadataRepositoryNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataRepositoryNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Learner {
		i--
		if m.Learner {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Leader {
		i--
		if m.Leader {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.RPCAddr) > 0 {
		i -= len(m.RPCAddr)
		copy(dAtA[i:], m.RPCAddr)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.RPCAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.RaftURL) > 0 {
		i -= len(m.RaftURL)
		copy(dAtA[i:], m.RaftURL)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.RaftURL)))
		i--
		dAtA[i] = 0x12
	}
	if m.NodeID != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.NodeID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintMetadata(dAtA []byte, offset int, v uint64) int {
	offset -= sovMetadata(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MetadataDescriptor) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AppliedIndex != 0 {
		n += 1 + sovMetadata(uint64(m.AppliedIndex))
	}
	if len(m.StorageNodes) > 0 {
		for _, e := range m.StorageNodes {
			l = e.ProtoSize()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.LogStreams) > 0 {
		for _, e := range m.LogStreams {
			l = e.ProtoSize()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.Topics) > 0 {
		for _, e := range m.Topics {
			l = e.ProtoSize()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *StorageNodeDescriptor) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.StorageNode.ProtoSize()
	n += 1 + l + sovMetadata(uint64(l))
	if m.Status != 0 {
		n += 1 + sovMetadata(uint64(m.Status))
	}
	if len(m.Paths) > 0 {
		for _, s := range m.Paths {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreateTime)
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *StorageDescriptor) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Used != 0 {
		n += 1 + sovMetadata(uint64(m.Used))
	}
	if m.Total != 0 {
		n += 1 + sovMetadata(uint64(m.Total))
	}
	return n
}

func (m *LogStreamDescriptor) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicID != 0 {
		n += 1 + sovMetadata(uint64(m.TopicID))
	}
	if m.LogStreamID != 0 {
		n += 1 + sovMetadata(uint64(m.LogStreamID))
	}
	if m.Status != 0 {
		n += 1 + sovMetadata(uint64(m.Status))
	}
	if len(m.Replicas) > 0 {
		for _, e := range m.Replicas {
			l = e.ProtoSize()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = m.Head.ProtoSize()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.Tail.ProtoSize()
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *ReplicaDescriptor) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StorageNodeID != 0 {
		n += 1 + sovMetadata(uint64(m.StorageNodeID))
	}
	l = len(m.StorageNodePath)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.DataPath)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *TopicDescriptor) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicID != 0 {
		n += 1 + sovMetadata(uint64(m.TopicID))
	}
	if m.Status != 0 {
		n += 1 + sovMetadata(uint64(m.Status))
	}
	if len(m.LogStreams) > 0 {
		l = 0
		for _, e := range m.LogStreams {
			l += sovMetadata(uint64(e))
		}
		n += 1 + sovMetadata(uint64(l)) + l
	}
	return n
}

func (m *StorageNode) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StorageNodeID != 0 {
		n += 1 + sovMetadata(uint64(m.StorageNodeID))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

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

func (m *LogStreamReplica) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.StorageNode.ProtoSize()
	n += 1 + l + sovMetadata(uint64(l))
	l = m.TopicLogStream.ProtoSize()
	n += 1 + l + sovMetadata(uint64(l))
	return n
}

func (m *LogSequenceNumber) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LLSN != 0 {
		n += 1 + sovMetadata(uint64(m.LLSN))
	}
	if m.GLSN != 0 {
		n += 1 + sovMetadata(uint64(m.GLSN))
	}
	return n
}

func (m *LogEntryMeta) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicID != 0 {
		n += 1 + sovMetadata(uint64(m.TopicID))
	}
	if m.LogStreamID != 0 {
		n += 1 + sovMetadata(uint64(m.LogStreamID))
	}
	if m.GLSN != 0 {
		n += 1 + sovMetadata(uint64(m.GLSN))
	}
	if m.LLSN != 0 {
		n += 1 + sovMetadata(uint64(m.LLSN))
	}
	return n
}

func (m *LogEntry) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.LogEntryMeta.ProtoSize()
	n += 1 + l + sovMetadata(uint64(l))
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *CommitContext) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Version != 0 {
		n += 1 + sovMetadata(uint64(m.Version))
	}
	if m.HighWatermark != 0 {
		n += 1 + sovMetadata(uint64(m.HighWatermark))
	}
	if m.CommittedGLSNBegin != 0 {
		n += 1 + sovMetadata(uint64(m.CommittedGLSNBegin))
	}
	if m.CommittedGLSNEnd != 0 {
		n += 1 + sovMetadata(uint64(m.CommittedGLSNEnd))
	}
	if m.CommittedLLSNBegin != 0 {
		n += 1 + sovMetadata(uint64(m.CommittedLLSNBegin))
	}
	return n
}

func (m *MetadataRepositoryNode) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeID != 0 {
		n += 1 + sovMetadata(uint64(m.NodeID))
	}
	l = len(m.RaftURL)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.RPCAddr)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Leader {
		n += 2
	}
	if m.Learner {
		n += 2
	}
	return n
}

func sovMetadata(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMetadata(x uint64) (n int) {
	return sovMetadata(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MetadataDescriptor) 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 ErrIntOverflowMetadata
			}
			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: MetadataDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataDescriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AppliedIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageNodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StorageNodes = append(m.StorageNodes, &StorageNodeDescriptor{})
			if err := m.StorageNodes[len(m.StorageNodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogStreams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogStreams = append(m.LogStreams, &LogStreamDescriptor{})
			if err := m.LogStreams[len(m.LogStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Topics = append(m.Topics, &TopicDescriptor{})
			if err := m.Topics[len(m.Topics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StorageNodeDescriptor) 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 ErrIntOverflowMetadata
			}
			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: StorageNodeDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageNodeDescriptor: 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 ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StorageNode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= StorageNodeStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreateTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StorageDescriptor) 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 ErrIntOverflowMetadata
			}
			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: StorageDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageDescriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Used", wireType)
			}
			m.Used = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Used |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogStreamDescriptor) 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 ErrIntOverflowMetadata
			}
			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: LogStreamDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogStreamDescriptor: 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 ErrIntOverflowMetadata
				}
				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
				}
			}
		case 2:
			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 ErrIntOverflowMetadata
				}
				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
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= LogStreamStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Replicas = append(m.Replicas, &ReplicaDescriptor{})
			if err := m.Replicas[len(m.Replicas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Head", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Head.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tail", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Tail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaDescriptor) 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 ErrIntOverflowMetadata
			}
			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: ReplicaDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaDescriptor: 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 ErrIntOverflowMetadata
				}
				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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageNodePath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StorageNodePath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicDescriptor) 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 ErrIntOverflowMetadata
			}
			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: TopicDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicDescriptor: 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 ErrIntOverflowMetadata
				}
				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
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= TopicStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType == 0 {
				var v github_com_kakao_varlog_pkg_types.LogStreamID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetadata
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= github_com_kakao_varlog_pkg_types.LogStreamID(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.LogStreams = append(m.LogStreams, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetadata
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMetadata
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMetadata
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.LogStreams) == 0 {
					m.LogStreams = make([]github_com_kakao_varlog_pkg_types.LogStreamID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v github_com_kakao_varlog_pkg_types.LogStreamID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= github_com_kakao_varlog_pkg_types.LogStreamID(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.LogStreams = append(m.LogStreams, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field LogStreams", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StorageNode) 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 ErrIntOverflowMetadata
			}
			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: StorageNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageNode: 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 ErrIntOverflowMetadata
				}
				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 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicLogStream) 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 ErrIntOverflowMetadata
			}
			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: TopicLogStream: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicLogStream: 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 ErrIntOverflowMetadata
				}
				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
				}
			}
		case 2:
			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 ErrIntOverflowMetadata
				}
				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 := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogStreamReplica) 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 ErrIntOverflowMetadata
			}
			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: LogStreamReplica: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogStreamReplica: 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 ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StorageNode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicLogStream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TopicLogStream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogSequenceNumber) 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 ErrIntOverflowMetadata
			}
			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: LogSequenceNumber: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogSequenceNumber: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LLSN", wireType)
			}
			m.LLSN = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LLSN |= github_com_kakao_varlog_pkg_types.LLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GLSN", wireType)
			}
			m.GLSN = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GLSN |= github_com_kakao_varlog_pkg_types.GLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogEntryMeta) 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 ErrIntOverflowMetadata
			}
			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: LogEntryMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogEntryMeta: 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 ErrIntOverflowMetadata
				}
				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
				}
			}
		case 2:
			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 ErrIntOverflowMetadata
				}
				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
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GLSN", wireType)
			}
			m.GLSN = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GLSN |= github_com_kakao_varlog_pkg_types.GLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LLSN", wireType)
			}
			m.LLSN = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LLSN |= github_com_kakao_varlog_pkg_types.LLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommitContext) 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 ErrIntOverflowMetadata
			}
			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: CommitContext: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommitContext: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= github_com_kakao_varlog_pkg_types.Version(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HighWatermark", wireType)
			}
			m.HighWatermark = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HighWatermark |= github_com_kakao_varlog_pkg_types.GLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedGLSNBegin", wireType)
			}
			m.CommittedGLSNBegin = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedGLSNBegin |= github_com_kakao_varlog_pkg_types.GLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedGLSNEnd", wireType)
			}
			m.CommittedGLSNEnd = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedGLSNEnd |= github_com_kakao_varlog_pkg_types.GLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedLLSNBegin", wireType)
			}
			m.CommittedLLSNBegin = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedLLSNBegin |= github_com_kakao_varlog_pkg_types.LLSN(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetadataRepositoryNode) 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 ErrIntOverflowMetadata
			}
			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: MetadataRepositoryNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataRepositoryNode: 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 ErrIntOverflowMetadata
				}
				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 RaftURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RaftURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RPCAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				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 ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RPCAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Leader = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Learner", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Learner = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMetadata(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, ErrIntOverflowMetadata
			}
			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, ErrIntOverflowMetadata
				}
				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, ErrIntOverflowMetadata
				}
				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, ErrInvalidLengthMetadata
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMetadata
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMetadata
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMetadata        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetadata          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMetadata = fmt.Errorf("proto: unexpected end of group")
)