You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					
					
						
							4617 lines
						
					
					
						
							148 KiB
						
					
					
				
			
		
		
		
			
			
			
		
		
	
	
							4617 lines
						
					
					
						
							148 KiB
						
					
					
				
								// Code generated by protoc-gen-go. DO NOT EDIT.
							 | 
						|
								// versions:
							 | 
						|
								// 	protoc-gen-go v1.36.6
							 | 
						|
								// 	protoc        v5.29.3
							 | 
						|
								// source: master.proto
							 | 
						|
								
							 | 
						|
								package master_pb
							 | 
						|
								
							 | 
						|
								import (
							 | 
						|
									protoreflect "google.golang.org/protobuf/reflect/protoreflect"
							 | 
						|
									protoimpl "google.golang.org/protobuf/runtime/protoimpl"
							 | 
						|
									reflect "reflect"
							 | 
						|
									sync "sync"
							 | 
						|
									unsafe "unsafe"
							 | 
						|
								)
							 | 
						|
								
							 | 
						|
								const (
							 | 
						|
									// Verify that this generated code is sufficiently up-to-date.
							 | 
						|
									_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
							 | 
						|
									// Verify that runtime/protoimpl is sufficiently up-to-date.
							 | 
						|
									_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
							 | 
						|
								)
							 | 
						|
								
							 | 
						|
								type Heartbeat struct {
							 | 
						|
									state      protoimpl.MessageState      `protogen:"open.v1"`
							 | 
						|
									Ip         string                      `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
							 | 
						|
									Port       uint32                      `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
							 | 
						|
									PublicUrl  string                      `protobuf:"bytes,3,opt,name=public_url,json=publicUrl,proto3" json:"public_url,omitempty"`
							 | 
						|
									MaxFileKey uint64                      `protobuf:"varint,5,opt,name=max_file_key,json=maxFileKey,proto3" json:"max_file_key,omitempty"`
							 | 
						|
									DataCenter string                      `protobuf:"bytes,6,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"`
							 | 
						|
									Rack       string                      `protobuf:"bytes,7,opt,name=rack,proto3" json:"rack,omitempty"`
							 | 
						|
									AdminPort  uint32                      `protobuf:"varint,8,opt,name=admin_port,json=adminPort,proto3" json:"admin_port,omitempty"`
							 | 
						|
									Volumes    []*VolumeInformationMessage `protobuf:"bytes,9,rep,name=volumes,proto3" json:"volumes,omitempty"`
							 | 
						|
									// delta volumes
							 | 
						|
									NewVolumes     []*VolumeShortInformationMessage `protobuf:"bytes,10,rep,name=new_volumes,json=newVolumes,proto3" json:"new_volumes,omitempty"`
							 | 
						|
									DeletedVolumes []*VolumeShortInformationMessage `protobuf:"bytes,11,rep,name=deleted_volumes,json=deletedVolumes,proto3" json:"deleted_volumes,omitempty"`
							 | 
						|
									HasNoVolumes   bool                             `protobuf:"varint,12,opt,name=has_no_volumes,json=hasNoVolumes,proto3" json:"has_no_volumes,omitempty"`
							 | 
						|
									// erasure coding
							 | 
						|
									EcShards []*VolumeEcShardInformationMessage `protobuf:"bytes,16,rep,name=ec_shards,json=ecShards,proto3" json:"ec_shards,omitempty"`
							 | 
						|
									// delta erasure coding shards
							 | 
						|
									NewEcShards     []*VolumeEcShardInformationMessage `protobuf:"bytes,17,rep,name=new_ec_shards,json=newEcShards,proto3" json:"new_ec_shards,omitempty"`
							 | 
						|
									DeletedEcShards []*VolumeEcShardInformationMessage `protobuf:"bytes,18,rep,name=deleted_ec_shards,json=deletedEcShards,proto3" json:"deleted_ec_shards,omitempty"`
							 | 
						|
									HasNoEcShards   bool                               `protobuf:"varint,19,opt,name=has_no_ec_shards,json=hasNoEcShards,proto3" json:"has_no_ec_shards,omitempty"`
							 | 
						|
									MaxVolumeCounts map[string]uint32                  `protobuf:"bytes,4,rep,name=max_volume_counts,json=maxVolumeCounts,proto3" json:"max_volume_counts,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
							 | 
						|
									GrpcPort        uint32                             `protobuf:"varint,20,opt,name=grpc_port,json=grpcPort,proto3" json:"grpc_port,omitempty"`
							 | 
						|
									LocationUuids   []string                           `protobuf:"bytes,21,rep,name=location_uuids,json=locationUuids,proto3" json:"location_uuids,omitempty"`
							 | 
						|
									unknownFields   protoimpl.UnknownFields
							 | 
						|
									sizeCache       protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) Reset() {
							 | 
						|
									*x = Heartbeat{}
							 | 
						|
									mi := &file_master_proto_msgTypes[0]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*Heartbeat) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[0]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use Heartbeat.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*Heartbeat) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{0}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetIp() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ip
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetPort() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Port
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetPublicUrl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.PublicUrl
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetMaxFileKey() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MaxFileKey
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetDataCenter() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenter
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetRack() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Rack
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetAdminPort() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.AdminPort
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetVolumes() []*VolumeInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Volumes
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetNewVolumes() []*VolumeShortInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.NewVolumes
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetDeletedVolumes() []*VolumeShortInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DeletedVolumes
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetHasNoVolumes() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.HasNoVolumes
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetEcShards() []*VolumeEcShardInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.EcShards
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetNewEcShards() []*VolumeEcShardInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.NewEcShards
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetDeletedEcShards() []*VolumeEcShardInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DeletedEcShards
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetHasNoEcShards() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.HasNoEcShards
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetMaxVolumeCounts() map[string]uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MaxVolumeCounts
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetGrpcPort() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.GrpcPort
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Heartbeat) GetLocationUuids() []string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.LocationUuids
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type HeartbeatResponse struct {
							 | 
						|
									state                  protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									VolumeSizeLimit        uint64                 `protobuf:"varint,1,opt,name=volume_size_limit,json=volumeSizeLimit,proto3" json:"volume_size_limit,omitempty"`
							 | 
						|
									Leader                 string                 `protobuf:"bytes,2,opt,name=leader,proto3" json:"leader,omitempty"`
							 | 
						|
									MetricsAddress         string                 `protobuf:"bytes,3,opt,name=metrics_address,json=metricsAddress,proto3" json:"metrics_address,omitempty"`
							 | 
						|
									MetricsIntervalSeconds uint32                 `protobuf:"varint,4,opt,name=metrics_interval_seconds,json=metricsIntervalSeconds,proto3" json:"metrics_interval_seconds,omitempty"`
							 | 
						|
									StorageBackends        []*StorageBackend      `protobuf:"bytes,5,rep,name=storage_backends,json=storageBackends,proto3" json:"storage_backends,omitempty"`
							 | 
						|
									DuplicatedUuids        []string               `protobuf:"bytes,6,rep,name=duplicated_uuids,json=duplicatedUuids,proto3" json:"duplicated_uuids,omitempty"`
							 | 
						|
									Preallocate            bool                   `protobuf:"varint,7,opt,name=preallocate,proto3" json:"preallocate,omitempty"`
							 | 
						|
									unknownFields          protoimpl.UnknownFields
							 | 
						|
									sizeCache              protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) Reset() {
							 | 
						|
									*x = HeartbeatResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[1]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*HeartbeatResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[1]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use HeartbeatResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{1}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) GetVolumeSizeLimit() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeSizeLimit
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) GetLeader() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Leader
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) GetMetricsAddress() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MetricsAddress
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) GetMetricsIntervalSeconds() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MetricsIntervalSeconds
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) GetStorageBackends() []*StorageBackend {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.StorageBackends
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) GetDuplicatedUuids() []string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DuplicatedUuids
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *HeartbeatResponse) GetPreallocate() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Preallocate
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeInformationMessage struct {
							 | 
						|
									state             protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id                uint32                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									Size              uint64                 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
							 | 
						|
									Collection        string                 `protobuf:"bytes,3,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									FileCount         uint64                 `protobuf:"varint,4,opt,name=file_count,json=fileCount,proto3" json:"file_count,omitempty"`
							 | 
						|
									DeleteCount       uint64                 `protobuf:"varint,5,opt,name=delete_count,json=deleteCount,proto3" json:"delete_count,omitempty"`
							 | 
						|
									DeletedByteCount  uint64                 `protobuf:"varint,6,opt,name=deleted_byte_count,json=deletedByteCount,proto3" json:"deleted_byte_count,omitempty"`
							 | 
						|
									ReadOnly          bool                   `protobuf:"varint,7,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
							 | 
						|
									ReplicaPlacement  uint32                 `protobuf:"varint,8,opt,name=replica_placement,json=replicaPlacement,proto3" json:"replica_placement,omitempty"`
							 | 
						|
									Version           uint32                 `protobuf:"varint,9,opt,name=version,proto3" json:"version,omitempty"`
							 | 
						|
									Ttl               uint32                 `protobuf:"varint,10,opt,name=ttl,proto3" json:"ttl,omitempty"`
							 | 
						|
									CompactRevision   uint32                 `protobuf:"varint,11,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"`
							 | 
						|
									ModifiedAtSecond  int64                  `protobuf:"varint,12,opt,name=modified_at_second,json=modifiedAtSecond,proto3" json:"modified_at_second,omitempty"`
							 | 
						|
									RemoteStorageName string                 `protobuf:"bytes,13,opt,name=remote_storage_name,json=remoteStorageName,proto3" json:"remote_storage_name,omitempty"`
							 | 
						|
									RemoteStorageKey  string                 `protobuf:"bytes,14,opt,name=remote_storage_key,json=remoteStorageKey,proto3" json:"remote_storage_key,omitempty"`
							 | 
						|
									DiskType          string                 `protobuf:"bytes,15,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"`
							 | 
						|
									DiskId            uint32                 `protobuf:"varint,16,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
							 | 
						|
									unknownFields     protoimpl.UnknownFields
							 | 
						|
									sizeCache         protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) Reset() {
							 | 
						|
									*x = VolumeInformationMessage{}
							 | 
						|
									mi := &file_master_proto_msgTypes[2]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeInformationMessage) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[2]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeInformationMessage.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeInformationMessage) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{2}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetSize() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Size
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetFileCount() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.FileCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetDeleteCount() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DeleteCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetDeletedByteCount() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DeletedByteCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetReadOnly() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ReadOnly
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetReplicaPlacement() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ReplicaPlacement
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetVersion() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Version
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetTtl() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ttl
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetCompactRevision() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.CompactRevision
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetModifiedAtSecond() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ModifiedAtSecond
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetRemoteStorageName() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.RemoteStorageName
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetRemoteStorageKey() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.RemoteStorageKey
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetDiskType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeInformationMessage) GetDiskId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeShortInformationMessage struct {
							 | 
						|
									state            protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id               uint32                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									Collection       string                 `protobuf:"bytes,3,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									ReplicaPlacement uint32                 `protobuf:"varint,8,opt,name=replica_placement,json=replicaPlacement,proto3" json:"replica_placement,omitempty"`
							 | 
						|
									Version          uint32                 `protobuf:"varint,9,opt,name=version,proto3" json:"version,omitempty"`
							 | 
						|
									Ttl              uint32                 `protobuf:"varint,10,opt,name=ttl,proto3" json:"ttl,omitempty"`
							 | 
						|
									DiskType         string                 `protobuf:"bytes,15,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"`
							 | 
						|
									DiskId           uint32                 `protobuf:"varint,16,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
							 | 
						|
									unknownFields    protoimpl.UnknownFields
							 | 
						|
									sizeCache        protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) Reset() {
							 | 
						|
									*x = VolumeShortInformationMessage{}
							 | 
						|
									mi := &file_master_proto_msgTypes[3]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeShortInformationMessage) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[3]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeShortInformationMessage.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeShortInformationMessage) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{3}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) GetId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) GetReplicaPlacement() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ReplicaPlacement
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) GetVersion() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Version
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) GetTtl() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ttl
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) GetDiskType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeShortInformationMessage) GetDiskId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeEcShardInformationMessage struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id            uint32                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									Collection    string                 `protobuf:"bytes,2,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									EcIndexBits   uint32                 `protobuf:"varint,3,opt,name=ec_index_bits,json=ecIndexBits,proto3" json:"ec_index_bits,omitempty"`
							 | 
						|
									DiskType      string                 `protobuf:"bytes,4,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"`
							 | 
						|
									ExpireAtSec   uint64                 `protobuf:"varint,5,opt,name=expire_at_sec,json=expireAtSec,proto3" json:"expire_at_sec,omitempty"` // used to record the destruction time of ec volume
							 | 
						|
									DiskId        uint32                 `protobuf:"varint,6,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
							 | 
						|
									ShardSizes    []int64                `protobuf:"varint,7,rep,packed,name=shard_sizes,json=shardSizes,proto3" json:"shard_sizes,omitempty"` // optimized: sizes for shards in order of set bits in ec_index_bits
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) Reset() {
							 | 
						|
									*x = VolumeEcShardInformationMessage{}
							 | 
						|
									mi := &file_master_proto_msgTypes[4]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeEcShardInformationMessage) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[4]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeEcShardInformationMessage.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeEcShardInformationMessage) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{4}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) GetId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) GetEcIndexBits() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.EcIndexBits
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) GetDiskType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) GetExpireAtSec() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ExpireAtSec
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) GetDiskId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeEcShardInformationMessage) GetShardSizes() []int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ShardSizes
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type StorageBackend struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Type          string                 `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
							 | 
						|
									Id            string                 `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									Properties    map[string]string      `protobuf:"bytes,3,rep,name=properties,proto3" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StorageBackend) Reset() {
							 | 
						|
									*x = StorageBackend{}
							 | 
						|
									mi := &file_master_proto_msgTypes[5]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StorageBackend) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*StorageBackend) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *StorageBackend) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[5]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use StorageBackend.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*StorageBackend) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{5}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StorageBackend) GetType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Type
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StorageBackend) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StorageBackend) GetProperties() map[string]string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Properties
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type Empty struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Empty) Reset() {
							 | 
						|
									*x = Empty{}
							 | 
						|
									mi := &file_master_proto_msgTypes[6]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Empty) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*Empty) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *Empty) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[6]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*Empty) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{6}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type SuperBlockExtra struct {
							 | 
						|
									state         protoimpl.MessageState         `protogen:"open.v1"`
							 | 
						|
									ErasureCoding *SuperBlockExtra_ErasureCoding `protobuf:"bytes,1,opt,name=erasure_coding,json=erasureCoding,proto3" json:"erasure_coding,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra) Reset() {
							 | 
						|
									*x = SuperBlockExtra{}
							 | 
						|
									mi := &file_master_proto_msgTypes[7]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*SuperBlockExtra) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[7]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use SuperBlockExtra.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*SuperBlockExtra) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{7}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra) GetErasureCoding() *SuperBlockExtra_ErasureCoding {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ErasureCoding
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type KeepConnectedRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									ClientType    string                 `protobuf:"bytes,1,opt,name=client_type,json=clientType,proto3" json:"client_type,omitempty"`
							 | 
						|
									ClientAddress string                 `protobuf:"bytes,3,opt,name=client_address,json=clientAddress,proto3" json:"client_address,omitempty"`
							 | 
						|
									Version       string                 `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
							 | 
						|
									FilerGroup    string                 `protobuf:"bytes,5,opt,name=filer_group,json=filerGroup,proto3" json:"filer_group,omitempty"`
							 | 
						|
									DataCenter    string                 `protobuf:"bytes,6,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"`
							 | 
						|
									Rack          string                 `protobuf:"bytes,7,opt,name=rack,proto3" json:"rack,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) Reset() {
							 | 
						|
									*x = KeepConnectedRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[8]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*KeepConnectedRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[8]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use KeepConnectedRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*KeepConnectedRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{8}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) GetClientType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ClientType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) GetClientAddress() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ClientAddress
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) GetVersion() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Version
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) GetFilerGroup() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.FilerGroup
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) GetDataCenter() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenter
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedRequest) GetRack() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Rack
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeLocation struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Url           string                 `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
							 | 
						|
									PublicUrl     string                 `protobuf:"bytes,2,opt,name=public_url,json=publicUrl,proto3" json:"public_url,omitempty"`
							 | 
						|
									NewVids       []uint32               `protobuf:"varint,3,rep,packed,name=new_vids,json=newVids,proto3" json:"new_vids,omitempty"`
							 | 
						|
									DeletedVids   []uint32               `protobuf:"varint,4,rep,packed,name=deleted_vids,json=deletedVids,proto3" json:"deleted_vids,omitempty"`
							 | 
						|
									Leader        string                 `protobuf:"bytes,5,opt,name=leader,proto3" json:"leader,omitempty"`                           // optional when leader is not itself
							 | 
						|
									DataCenter    string                 `protobuf:"bytes,6,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"` // optional when DataCenter is in use
							 | 
						|
									GrpcPort      uint32                 `protobuf:"varint,7,opt,name=grpc_port,json=grpcPort,proto3" json:"grpc_port,omitempty"`
							 | 
						|
									NewEcVids     []uint32               `protobuf:"varint,8,rep,packed,name=new_ec_vids,json=newEcVids,proto3" json:"new_ec_vids,omitempty"`
							 | 
						|
									DeletedEcVids []uint32               `protobuf:"varint,9,rep,packed,name=deleted_ec_vids,json=deletedEcVids,proto3" json:"deleted_ec_vids,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) Reset() {
							 | 
						|
									*x = VolumeLocation{}
							 | 
						|
									mi := &file_master_proto_msgTypes[9]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeLocation) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[9]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeLocation.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeLocation) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{9}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetUrl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Url
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetPublicUrl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.PublicUrl
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetNewVids() []uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.NewVids
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetDeletedVids() []uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DeletedVids
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetLeader() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Leader
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetDataCenter() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenter
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetGrpcPort() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.GrpcPort
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetNewEcVids() []uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.NewEcVids
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeLocation) GetDeletedEcVids() []uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DeletedEcVids
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type ClusterNodeUpdate struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									NodeType      string                 `protobuf:"bytes,1,opt,name=node_type,json=nodeType,proto3" json:"node_type,omitempty"`
							 | 
						|
									Address       string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
							 | 
						|
									IsAdd         bool                   `protobuf:"varint,4,opt,name=is_add,json=isAdd,proto3" json:"is_add,omitempty"`
							 | 
						|
									FilerGroup    string                 `protobuf:"bytes,5,opt,name=filer_group,json=filerGroup,proto3" json:"filer_group,omitempty"`
							 | 
						|
									CreatedAtNs   int64                  `protobuf:"varint,6,opt,name=created_at_ns,json=createdAtNs,proto3" json:"created_at_ns,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) Reset() {
							 | 
						|
									*x = ClusterNodeUpdate{}
							 | 
						|
									mi := &file_master_proto_msgTypes[10]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*ClusterNodeUpdate) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[10]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use ClusterNodeUpdate.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*ClusterNodeUpdate) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{10}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) GetNodeType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.NodeType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) GetAddress() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Address
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) GetIsAdd() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.IsAdd
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) GetFilerGroup() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.FilerGroup
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ClusterNodeUpdate) GetCreatedAtNs() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.CreatedAtNs
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type KeepConnectedResponse struct {
							 | 
						|
									state             protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									VolumeLocation    *VolumeLocation        `protobuf:"bytes,1,opt,name=volume_location,json=volumeLocation,proto3" json:"volume_location,omitempty"`
							 | 
						|
									ClusterNodeUpdate *ClusterNodeUpdate     `protobuf:"bytes,2,opt,name=cluster_node_update,json=clusterNodeUpdate,proto3" json:"cluster_node_update,omitempty"`
							 | 
						|
									unknownFields     protoimpl.UnknownFields
							 | 
						|
									sizeCache         protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedResponse) Reset() {
							 | 
						|
									*x = KeepConnectedResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[11]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*KeepConnectedResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[11]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use KeepConnectedResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*KeepConnectedResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{11}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedResponse) GetVolumeLocation() *VolumeLocation {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeLocation
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *KeepConnectedResponse) GetClusterNodeUpdate() *ClusterNodeUpdate {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ClusterNodeUpdate
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LookupVolumeRequest struct {
							 | 
						|
									state           protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									VolumeOrFileIds []string               `protobuf:"bytes,1,rep,name=volume_or_file_ids,json=volumeOrFileIds,proto3" json:"volume_or_file_ids,omitempty"`
							 | 
						|
									Collection      string                 `protobuf:"bytes,2,opt,name=collection,proto3" json:"collection,omitempty"` // optional, a bit faster if provided.
							 | 
						|
									unknownFields   protoimpl.UnknownFields
							 | 
						|
									sizeCache       protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeRequest) Reset() {
							 | 
						|
									*x = LookupVolumeRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[12]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LookupVolumeRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[12]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LookupVolumeRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LookupVolumeRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{12}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeRequest) GetVolumeOrFileIds() []string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeOrFileIds
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeRequest) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LookupVolumeResponse struct {
							 | 
						|
									state             protoimpl.MessageState                   `protogen:"open.v1"`
							 | 
						|
									VolumeIdLocations []*LookupVolumeResponse_VolumeIdLocation `protobuf:"bytes,1,rep,name=volume_id_locations,json=volumeIdLocations,proto3" json:"volume_id_locations,omitempty"`
							 | 
						|
									unknownFields     protoimpl.UnknownFields
							 | 
						|
									sizeCache         protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse) Reset() {
							 | 
						|
									*x = LookupVolumeResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[13]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LookupVolumeResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[13]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LookupVolumeResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LookupVolumeResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{13}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse) GetVolumeIdLocations() []*LookupVolumeResponse_VolumeIdLocation {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeIdLocations
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type Location struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Url           string                 `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
							 | 
						|
									PublicUrl     string                 `protobuf:"bytes,2,opt,name=public_url,json=publicUrl,proto3" json:"public_url,omitempty"`
							 | 
						|
									GrpcPort      uint32                 `protobuf:"varint,3,opt,name=grpc_port,json=grpcPort,proto3" json:"grpc_port,omitempty"`
							 | 
						|
									DataCenter    string                 `protobuf:"bytes,4,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Location) Reset() {
							 | 
						|
									*x = Location{}
							 | 
						|
									mi := &file_master_proto_msgTypes[14]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Location) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*Location) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *Location) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[14]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use Location.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*Location) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{14}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Location) GetUrl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Url
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Location) GetPublicUrl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.PublicUrl
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Location) GetGrpcPort() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.GrpcPort
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Location) GetDataCenter() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenter
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type AssignRequest struct {
							 | 
						|
									state               protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Count               uint64                 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
							 | 
						|
									Replication         string                 `protobuf:"bytes,2,opt,name=replication,proto3" json:"replication,omitempty"`
							 | 
						|
									Collection          string                 `protobuf:"bytes,3,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									Ttl                 string                 `protobuf:"bytes,4,opt,name=ttl,proto3" json:"ttl,omitempty"`
							 | 
						|
									DataCenter          string                 `protobuf:"bytes,5,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"`
							 | 
						|
									Rack                string                 `protobuf:"bytes,6,opt,name=rack,proto3" json:"rack,omitempty"`
							 | 
						|
									DataNode            string                 `protobuf:"bytes,7,opt,name=data_node,json=dataNode,proto3" json:"data_node,omitempty"`
							 | 
						|
									MemoryMapMaxSizeMb  uint32                 `protobuf:"varint,8,opt,name=memory_map_max_size_mb,json=memoryMapMaxSizeMb,proto3" json:"memory_map_max_size_mb,omitempty"`
							 | 
						|
									WritableVolumeCount uint32                 `protobuf:"varint,9,opt,name=writable_volume_count,json=writableVolumeCount,proto3" json:"writable_volume_count,omitempty"`
							 | 
						|
									DiskType            string                 `protobuf:"bytes,10,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"`
							 | 
						|
									unknownFields       protoimpl.UnknownFields
							 | 
						|
									sizeCache           protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) Reset() {
							 | 
						|
									*x = AssignRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[15]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*AssignRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[15]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use AssignRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*AssignRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{15}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetCount() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Count
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetReplication() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Replication
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetTtl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ttl
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetDataCenter() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenter
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetRack() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Rack
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetDataNode() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataNode
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetMemoryMapMaxSizeMb() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MemoryMapMaxSizeMb
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetWritableVolumeCount() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.WritableVolumeCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignRequest) GetDiskType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeGrowRequest struct {
							 | 
						|
									state               protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									WritableVolumeCount uint32                 `protobuf:"varint,1,opt,name=writable_volume_count,json=writableVolumeCount,proto3" json:"writable_volume_count,omitempty"`
							 | 
						|
									Replication         string                 `protobuf:"bytes,2,opt,name=replication,proto3" json:"replication,omitempty"`
							 | 
						|
									Collection          string                 `protobuf:"bytes,3,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									Ttl                 string                 `protobuf:"bytes,4,opt,name=ttl,proto3" json:"ttl,omitempty"`
							 | 
						|
									DataCenter          string                 `protobuf:"bytes,5,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"`
							 | 
						|
									Rack                string                 `protobuf:"bytes,6,opt,name=rack,proto3" json:"rack,omitempty"`
							 | 
						|
									DataNode            string                 `protobuf:"bytes,7,opt,name=data_node,json=dataNode,proto3" json:"data_node,omitempty"`
							 | 
						|
									MemoryMapMaxSizeMb  uint32                 `protobuf:"varint,8,opt,name=memory_map_max_size_mb,json=memoryMapMaxSizeMb,proto3" json:"memory_map_max_size_mb,omitempty"`
							 | 
						|
									DiskType            string                 `protobuf:"bytes,9,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"`
							 | 
						|
									unknownFields       protoimpl.UnknownFields
							 | 
						|
									sizeCache           protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) Reset() {
							 | 
						|
									*x = VolumeGrowRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[16]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeGrowRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[16]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeGrowRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeGrowRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{16}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetWritableVolumeCount() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.WritableVolumeCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetReplication() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Replication
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetTtl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ttl
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetDataCenter() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenter
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetRack() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Rack
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetDataNode() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataNode
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetMemoryMapMaxSizeMb() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MemoryMapMaxSizeMb
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowRequest) GetDiskType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type AssignResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Fid           string                 `protobuf:"bytes,1,opt,name=fid,proto3" json:"fid,omitempty"`
							 | 
						|
									Count         uint64                 `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`
							 | 
						|
									Error         string                 `protobuf:"bytes,5,opt,name=error,proto3" json:"error,omitempty"`
							 | 
						|
									Auth          string                 `protobuf:"bytes,6,opt,name=auth,proto3" json:"auth,omitempty"`
							 | 
						|
									Replicas      []*Location            `protobuf:"bytes,7,rep,name=replicas,proto3" json:"replicas,omitempty"`
							 | 
						|
									Location      *Location              `protobuf:"bytes,8,opt,name=location,proto3" json:"location,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) Reset() {
							 | 
						|
									*x = AssignResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[17]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*AssignResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[17]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use AssignResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*AssignResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{17}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) GetFid() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Fid
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) GetCount() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Count
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) GetError() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Error
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) GetAuth() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Auth
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) GetReplicas() []*Location {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Replicas
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *AssignResponse) GetLocation() *Location {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Location
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type StatisticsRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Replication   string                 `protobuf:"bytes,1,opt,name=replication,proto3" json:"replication,omitempty"`
							 | 
						|
									Collection    string                 `protobuf:"bytes,2,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									Ttl           string                 `protobuf:"bytes,3,opt,name=ttl,proto3" json:"ttl,omitempty"`
							 | 
						|
									DiskType      string                 `protobuf:"bytes,4,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsRequest) Reset() {
							 | 
						|
									*x = StatisticsRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[18]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*StatisticsRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[18]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use StatisticsRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*StatisticsRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{18}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsRequest) GetReplication() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Replication
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsRequest) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsRequest) GetTtl() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ttl
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsRequest) GetDiskType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type StatisticsResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									TotalSize     uint64                 `protobuf:"varint,4,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"`
							 | 
						|
									UsedSize      uint64                 `protobuf:"varint,5,opt,name=used_size,json=usedSize,proto3" json:"used_size,omitempty"`
							 | 
						|
									FileCount     uint64                 `protobuf:"varint,6,opt,name=file_count,json=fileCount,proto3" json:"file_count,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsResponse) Reset() {
							 | 
						|
									*x = StatisticsResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[19]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*StatisticsResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[19]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use StatisticsResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*StatisticsResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{19}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsResponse) GetTotalSize() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.TotalSize
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsResponse) GetUsedSize() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.UsedSize
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *StatisticsResponse) GetFileCount() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.FileCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// collection related
							 | 
						|
								type Collection struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Collection) Reset() {
							 | 
						|
									*x = Collection{}
							 | 
						|
									mi := &file_master_proto_msgTypes[20]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Collection) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*Collection) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *Collection) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[20]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use Collection.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*Collection) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{20}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *Collection) GetName() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Name
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type CollectionListRequest struct {
							 | 
						|
									state                protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									IncludeNormalVolumes bool                   `protobuf:"varint,1,opt,name=include_normal_volumes,json=includeNormalVolumes,proto3" json:"include_normal_volumes,omitempty"`
							 | 
						|
									IncludeEcVolumes     bool                   `protobuf:"varint,2,opt,name=include_ec_volumes,json=includeEcVolumes,proto3" json:"include_ec_volumes,omitempty"`
							 | 
						|
									unknownFields        protoimpl.UnknownFields
							 | 
						|
									sizeCache            protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListRequest) Reset() {
							 | 
						|
									*x = CollectionListRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[21]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*CollectionListRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[21]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use CollectionListRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*CollectionListRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{21}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListRequest) GetIncludeNormalVolumes() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.IncludeNormalVolumes
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListRequest) GetIncludeEcVolumes() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.IncludeEcVolumes
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type CollectionListResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Collections   []*Collection          `protobuf:"bytes,1,rep,name=collections,proto3" json:"collections,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListResponse) Reset() {
							 | 
						|
									*x = CollectionListResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[22]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*CollectionListResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[22]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use CollectionListResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*CollectionListResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{22}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionListResponse) GetCollections() []*Collection {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collections
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type CollectionDeleteRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionDeleteRequest) Reset() {
							 | 
						|
									*x = CollectionDeleteRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[23]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionDeleteRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*CollectionDeleteRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *CollectionDeleteRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[23]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use CollectionDeleteRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*CollectionDeleteRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{23}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionDeleteRequest) GetName() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Name
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type CollectionDeleteResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionDeleteResponse) Reset() {
							 | 
						|
									*x = CollectionDeleteResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[24]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *CollectionDeleteResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*CollectionDeleteResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *CollectionDeleteResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[24]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use CollectionDeleteResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*CollectionDeleteResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{24}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// volume related
							 | 
						|
								type DiskInfo struct {
							 | 
						|
									state             protoimpl.MessageState             `protogen:"open.v1"`
							 | 
						|
									Type              string                             `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
							 | 
						|
									VolumeCount       int64                              `protobuf:"varint,2,opt,name=volume_count,json=volumeCount,proto3" json:"volume_count,omitempty"`
							 | 
						|
									MaxVolumeCount    int64                              `protobuf:"varint,3,opt,name=max_volume_count,json=maxVolumeCount,proto3" json:"max_volume_count,omitempty"`
							 | 
						|
									FreeVolumeCount   int64                              `protobuf:"varint,4,opt,name=free_volume_count,json=freeVolumeCount,proto3" json:"free_volume_count,omitempty"`
							 | 
						|
									ActiveVolumeCount int64                              `protobuf:"varint,5,opt,name=active_volume_count,json=activeVolumeCount,proto3" json:"active_volume_count,omitempty"`
							 | 
						|
									VolumeInfos       []*VolumeInformationMessage        `protobuf:"bytes,6,rep,name=volume_infos,json=volumeInfos,proto3" json:"volume_infos,omitempty"`
							 | 
						|
									EcShardInfos      []*VolumeEcShardInformationMessage `protobuf:"bytes,7,rep,name=ec_shard_infos,json=ecShardInfos,proto3" json:"ec_shard_infos,omitempty"`
							 | 
						|
									RemoteVolumeCount int64                              `protobuf:"varint,8,opt,name=remote_volume_count,json=remoteVolumeCount,proto3" json:"remote_volume_count,omitempty"`
							 | 
						|
									DiskId            uint32                             `protobuf:"varint,9,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
							 | 
						|
									unknownFields     protoimpl.UnknownFields
							 | 
						|
									sizeCache         protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) Reset() {
							 | 
						|
									*x = DiskInfo{}
							 | 
						|
									mi := &file_master_proto_msgTypes[25]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*DiskInfo) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[25]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use DiskInfo.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*DiskInfo) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{25}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Type
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetVolumeCount() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetMaxVolumeCount() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MaxVolumeCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetFreeVolumeCount() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.FreeVolumeCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetActiveVolumeCount() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ActiveVolumeCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetVolumeInfos() []*VolumeInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetEcShardInfos() []*VolumeEcShardInformationMessage {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.EcShardInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetRemoteVolumeCount() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.RemoteVolumeCount
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DiskInfo) GetDiskId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type DataNodeInfo struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									DiskInfos     map[string]*DiskInfo   `protobuf:"bytes,2,rep,name=diskInfos,proto3" json:"diskInfos,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
							 | 
						|
									GrpcPort      uint32                 `protobuf:"varint,3,opt,name=grpc_port,json=grpcPort,proto3" json:"grpc_port,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataNodeInfo) Reset() {
							 | 
						|
									*x = DataNodeInfo{}
							 | 
						|
									mi := &file_master_proto_msgTypes[26]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataNodeInfo) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*DataNodeInfo) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *DataNodeInfo) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[26]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use DataNodeInfo.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*DataNodeInfo) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{26}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataNodeInfo) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataNodeInfo) GetDiskInfos() map[string]*DiskInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataNodeInfo) GetGrpcPort() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.GrpcPort
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RackInfo struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									DataNodeInfos []*DataNodeInfo        `protobuf:"bytes,2,rep,name=data_node_infos,json=dataNodeInfos,proto3" json:"data_node_infos,omitempty"`
							 | 
						|
									DiskInfos     map[string]*DiskInfo   `protobuf:"bytes,3,rep,name=diskInfos,proto3" json:"diskInfos,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RackInfo) Reset() {
							 | 
						|
									*x = RackInfo{}
							 | 
						|
									mi := &file_master_proto_msgTypes[27]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RackInfo) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RackInfo) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RackInfo) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[27]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RackInfo.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RackInfo) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{27}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RackInfo) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RackInfo) GetDataNodeInfos() []*DataNodeInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataNodeInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RackInfo) GetDiskInfos() map[string]*DiskInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type DataCenterInfo struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									RackInfos     []*RackInfo            `protobuf:"bytes,2,rep,name=rack_infos,json=rackInfos,proto3" json:"rack_infos,omitempty"`
							 | 
						|
									DiskInfos     map[string]*DiskInfo   `protobuf:"bytes,3,rep,name=diskInfos,proto3" json:"diskInfos,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataCenterInfo) Reset() {
							 | 
						|
									*x = DataCenterInfo{}
							 | 
						|
									mi := &file_master_proto_msgTypes[28]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataCenterInfo) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*DataCenterInfo) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *DataCenterInfo) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[28]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use DataCenterInfo.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*DataCenterInfo) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{28}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataCenterInfo) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataCenterInfo) GetRackInfos() []*RackInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.RackInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DataCenterInfo) GetDiskInfos() map[string]*DiskInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type TopologyInfo struct {
							 | 
						|
									state           protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id              string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									DataCenterInfos []*DataCenterInfo      `protobuf:"bytes,2,rep,name=data_center_infos,json=dataCenterInfos,proto3" json:"data_center_infos,omitempty"`
							 | 
						|
									DiskInfos       map[string]*DiskInfo   `protobuf:"bytes,3,rep,name=diskInfos,proto3" json:"diskInfos,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
							 | 
						|
									unknownFields   protoimpl.UnknownFields
							 | 
						|
									sizeCache       protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *TopologyInfo) Reset() {
							 | 
						|
									*x = TopologyInfo{}
							 | 
						|
									mi := &file_master_proto_msgTypes[29]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *TopologyInfo) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*TopologyInfo) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *TopologyInfo) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[29]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use TopologyInfo.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*TopologyInfo) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{29}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *TopologyInfo) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *TopologyInfo) GetDataCenterInfos() []*DataCenterInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenterInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *TopologyInfo) GetDiskInfos() map[string]*DiskInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskInfos
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeListRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListRequest) Reset() {
							 | 
						|
									*x = VolumeListRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[30]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeListRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[30]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeListRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeListRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{30}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeListResponse struct {
							 | 
						|
									state             protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									TopologyInfo      *TopologyInfo          `protobuf:"bytes,1,opt,name=topology_info,json=topologyInfo,proto3" json:"topology_info,omitempty"`
							 | 
						|
									VolumeSizeLimitMb uint64                 `protobuf:"varint,2,opt,name=volume_size_limit_mb,json=volumeSizeLimitMb,proto3" json:"volume_size_limit_mb,omitempty"`
							 | 
						|
									unknownFields     protoimpl.UnknownFields
							 | 
						|
									sizeCache         protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListResponse) Reset() {
							 | 
						|
									*x = VolumeListResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[31]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeListResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[31]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeListResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeListResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{31}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListResponse) GetTopologyInfo() *TopologyInfo {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.TopologyInfo
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeListResponse) GetVolumeSizeLimitMb() uint64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeSizeLimitMb
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LookupEcVolumeRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									VolumeId      uint32                 `protobuf:"varint,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeRequest) Reset() {
							 | 
						|
									*x = LookupEcVolumeRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[32]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LookupEcVolumeRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[32]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LookupEcVolumeRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LookupEcVolumeRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{32}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeRequest) GetVolumeId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LookupEcVolumeResponse struct {
							 | 
						|
									state            protoimpl.MessageState                      `protogen:"open.v1"`
							 | 
						|
									VolumeId         uint32                                      `protobuf:"varint,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
							 | 
						|
									ShardIdLocations []*LookupEcVolumeResponse_EcShardIdLocation `protobuf:"bytes,2,rep,name=shard_id_locations,json=shardIdLocations,proto3" json:"shard_id_locations,omitempty"`
							 | 
						|
									unknownFields    protoimpl.UnknownFields
							 | 
						|
									sizeCache        protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse) Reset() {
							 | 
						|
									*x = LookupEcVolumeResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[33]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LookupEcVolumeResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[33]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LookupEcVolumeResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LookupEcVolumeResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{33}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse) GetVolumeId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse) GetShardIdLocations() []*LookupEcVolumeResponse_EcShardIdLocation {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ShardIdLocations
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VacuumVolumeRequest struct {
							 | 
						|
									state            protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									GarbageThreshold float32                `protobuf:"fixed32,1,opt,name=garbage_threshold,json=garbageThreshold,proto3" json:"garbage_threshold,omitempty"`
							 | 
						|
									VolumeId         uint32                 `protobuf:"varint,2,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
							 | 
						|
									Collection       string                 `protobuf:"bytes,3,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									unknownFields    protoimpl.UnknownFields
							 | 
						|
									sizeCache        protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeRequest) Reset() {
							 | 
						|
									*x = VacuumVolumeRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[34]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VacuumVolumeRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[34]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VacuumVolumeRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VacuumVolumeRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{34}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeRequest) GetGarbageThreshold() float32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.GarbageThreshold
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeRequest) GetVolumeId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeRequest) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VacuumVolumeResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeResponse) Reset() {
							 | 
						|
									*x = VacuumVolumeResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[35]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VacuumVolumeResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VacuumVolumeResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[35]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VacuumVolumeResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VacuumVolumeResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{35}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type DisableVacuumRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DisableVacuumRequest) Reset() {
							 | 
						|
									*x = DisableVacuumRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[36]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DisableVacuumRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*DisableVacuumRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *DisableVacuumRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[36]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use DisableVacuumRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*DisableVacuumRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{36}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type DisableVacuumResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DisableVacuumResponse) Reset() {
							 | 
						|
									*x = DisableVacuumResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[37]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *DisableVacuumResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*DisableVacuumResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *DisableVacuumResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[37]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use DisableVacuumResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*DisableVacuumResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{37}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type EnableVacuumRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *EnableVacuumRequest) Reset() {
							 | 
						|
									*x = EnableVacuumRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[38]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *EnableVacuumRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*EnableVacuumRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *EnableVacuumRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[38]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use EnableVacuumRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*EnableVacuumRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{38}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type EnableVacuumResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *EnableVacuumResponse) Reset() {
							 | 
						|
									*x = EnableVacuumResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[39]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *EnableVacuumResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*EnableVacuumResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *EnableVacuumResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[39]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use EnableVacuumResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*EnableVacuumResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{39}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeMarkReadonlyRequest struct {
							 | 
						|
									state            protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Ip               string                 `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
							 | 
						|
									Port             uint32                 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
							 | 
						|
									VolumeId         uint32                 `protobuf:"varint,4,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
							 | 
						|
									Collection       string                 `protobuf:"bytes,5,opt,name=collection,proto3" json:"collection,omitempty"`
							 | 
						|
									ReplicaPlacement uint32                 `protobuf:"varint,6,opt,name=replica_placement,json=replicaPlacement,proto3" json:"replica_placement,omitempty"`
							 | 
						|
									Version          uint32                 `protobuf:"varint,7,opt,name=version,proto3" json:"version,omitempty"`
							 | 
						|
									Ttl              uint32                 `protobuf:"varint,8,opt,name=ttl,proto3" json:"ttl,omitempty"`
							 | 
						|
									DiskType         string                 `protobuf:"bytes,9,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"`
							 | 
						|
									IsReadonly       bool                   `protobuf:"varint,10,opt,name=is_readonly,json=isReadonly,proto3" json:"is_readonly,omitempty"`
							 | 
						|
									unknownFields    protoimpl.UnknownFields
							 | 
						|
									sizeCache        protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) Reset() {
							 | 
						|
									*x = VolumeMarkReadonlyRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[40]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeMarkReadonlyRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[40]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeMarkReadonlyRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeMarkReadonlyRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{40}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetIp() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ip
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetPort() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Port
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetVolumeId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetCollection() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Collection
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetReplicaPlacement() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ReplicaPlacement
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetVersion() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Version
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetTtl() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Ttl
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetDiskType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DiskType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyRequest) GetIsReadonly() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.IsReadonly
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeMarkReadonlyResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyResponse) Reset() {
							 | 
						|
									*x = VolumeMarkReadonlyResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[41]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeMarkReadonlyResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeMarkReadonlyResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[41]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeMarkReadonlyResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeMarkReadonlyResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{41}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type GetMasterConfigurationRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationRequest) Reset() {
							 | 
						|
									*x = GetMasterConfigurationRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[42]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*GetMasterConfigurationRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[42]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use GetMasterConfigurationRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*GetMasterConfigurationRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{42}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type GetMasterConfigurationResponse struct {
							 | 
						|
									state                  protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									MetricsAddress         string                 `protobuf:"bytes,1,opt,name=metrics_address,json=metricsAddress,proto3" json:"metrics_address,omitempty"`
							 | 
						|
									MetricsIntervalSeconds uint32                 `protobuf:"varint,2,opt,name=metrics_interval_seconds,json=metricsIntervalSeconds,proto3" json:"metrics_interval_seconds,omitempty"`
							 | 
						|
									StorageBackends        []*StorageBackend      `protobuf:"bytes,3,rep,name=storage_backends,json=storageBackends,proto3" json:"storage_backends,omitempty"`
							 | 
						|
									DefaultReplication     string                 `protobuf:"bytes,4,opt,name=default_replication,json=defaultReplication,proto3" json:"default_replication,omitempty"`
							 | 
						|
									Leader                 string                 `protobuf:"bytes,5,opt,name=leader,proto3" json:"leader,omitempty"`
							 | 
						|
									VolumeSizeLimitMB      uint32                 `protobuf:"varint,6,opt,name=volume_size_limit_m_b,json=volumeSizeLimitMB,proto3" json:"volume_size_limit_m_b,omitempty"`
							 | 
						|
									VolumePreallocate      bool                   `protobuf:"varint,7,opt,name=volume_preallocate,json=volumePreallocate,proto3" json:"volume_preallocate,omitempty"`
							 | 
						|
									unknownFields          protoimpl.UnknownFields
							 | 
						|
									sizeCache              protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) Reset() {
							 | 
						|
									*x = GetMasterConfigurationResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[43]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*GetMasterConfigurationResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[43]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use GetMasterConfigurationResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*GetMasterConfigurationResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{43}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) GetMetricsAddress() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MetricsAddress
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) GetMetricsIntervalSeconds() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.MetricsIntervalSeconds
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) GetStorageBackends() []*StorageBackend {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.StorageBackends
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) GetDefaultReplication() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DefaultReplication
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) GetLeader() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Leader
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) GetVolumeSizeLimitMB() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeSizeLimitMB
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *GetMasterConfigurationResponse) GetVolumePreallocate() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumePreallocate
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type ListClusterNodesRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									ClientType    string                 `protobuf:"bytes,1,opt,name=client_type,json=clientType,proto3" json:"client_type,omitempty"`
							 | 
						|
									FilerGroup    string                 `protobuf:"bytes,2,opt,name=filer_group,json=filerGroup,proto3" json:"filer_group,omitempty"`
							 | 
						|
									Limit         int32                  `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesRequest) Reset() {
							 | 
						|
									*x = ListClusterNodesRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[44]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*ListClusterNodesRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[44]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use ListClusterNodesRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*ListClusterNodesRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{44}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesRequest) GetClientType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ClientType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesRequest) GetFilerGroup() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.FilerGroup
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesRequest) GetLimit() int32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Limit
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type ListClusterNodesResponse struct {
							 | 
						|
									state         protoimpl.MessageState                  `protogen:"open.v1"`
							 | 
						|
									ClusterNodes  []*ListClusterNodesResponse_ClusterNode `protobuf:"bytes,1,rep,name=cluster_nodes,json=clusterNodes,proto3" json:"cluster_nodes,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse) Reset() {
							 | 
						|
									*x = ListClusterNodesResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[45]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*ListClusterNodesResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[45]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use ListClusterNodesResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*ListClusterNodesResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{45}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse) GetClusterNodes() []*ListClusterNodesResponse_ClusterNode {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ClusterNodes
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LeaseAdminTokenRequest struct {
							 | 
						|
									state            protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									PreviousToken    int64                  `protobuf:"varint,1,opt,name=previous_token,json=previousToken,proto3" json:"previous_token,omitempty"`
							 | 
						|
									PreviousLockTime int64                  `protobuf:"varint,2,opt,name=previous_lock_time,json=previousLockTime,proto3" json:"previous_lock_time,omitempty"`
							 | 
						|
									LockName         string                 `protobuf:"bytes,3,opt,name=lock_name,json=lockName,proto3" json:"lock_name,omitempty"`
							 | 
						|
									ClientName       string                 `protobuf:"bytes,4,opt,name=client_name,json=clientName,proto3" json:"client_name,omitempty"`
							 | 
						|
									Message          string                 `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
							 | 
						|
									unknownFields    protoimpl.UnknownFields
							 | 
						|
									sizeCache        protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) Reset() {
							 | 
						|
									*x = LeaseAdminTokenRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[46]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LeaseAdminTokenRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[46]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LeaseAdminTokenRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LeaseAdminTokenRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{46}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) GetPreviousToken() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.PreviousToken
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) GetPreviousLockTime() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.PreviousLockTime
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) GetLockName() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.LockName
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) GetClientName() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ClientName
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenRequest) GetMessage() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Message
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LeaseAdminTokenResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Token         int64                  `protobuf:"varint,1,opt,name=token,proto3" json:"token,omitempty"`
							 | 
						|
									LockTsNs      int64                  `protobuf:"varint,2,opt,name=lock_ts_ns,json=lockTsNs,proto3" json:"lock_ts_ns,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenResponse) Reset() {
							 | 
						|
									*x = LeaseAdminTokenResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[47]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LeaseAdminTokenResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[47]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LeaseAdminTokenResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LeaseAdminTokenResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{47}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenResponse) GetToken() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Token
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LeaseAdminTokenResponse) GetLockTsNs() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.LockTsNs
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type ReleaseAdminTokenRequest struct {
							 | 
						|
									state            protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									PreviousToken    int64                  `protobuf:"varint,1,opt,name=previous_token,json=previousToken,proto3" json:"previous_token,omitempty"`
							 | 
						|
									PreviousLockTime int64                  `protobuf:"varint,2,opt,name=previous_lock_time,json=previousLockTime,proto3" json:"previous_lock_time,omitempty"`
							 | 
						|
									LockName         string                 `protobuf:"bytes,3,opt,name=lock_name,json=lockName,proto3" json:"lock_name,omitempty"`
							 | 
						|
									unknownFields    protoimpl.UnknownFields
							 | 
						|
									sizeCache        protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenRequest) Reset() {
							 | 
						|
									*x = ReleaseAdminTokenRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[48]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*ReleaseAdminTokenRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[48]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use ReleaseAdminTokenRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*ReleaseAdminTokenRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{48}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenRequest) GetPreviousToken() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.PreviousToken
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenRequest) GetPreviousLockTime() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.PreviousLockTime
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenRequest) GetLockName() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.LockName
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type ReleaseAdminTokenResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenResponse) Reset() {
							 | 
						|
									*x = ReleaseAdminTokenResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[49]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*ReleaseAdminTokenResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *ReleaseAdminTokenResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[49]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use ReleaseAdminTokenResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*ReleaseAdminTokenResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{49}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type PingRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Target        string                 `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"` // default to ping itself
							 | 
						|
									TargetType    string                 `protobuf:"bytes,2,opt,name=target_type,json=targetType,proto3" json:"target_type,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingRequest) Reset() {
							 | 
						|
									*x = PingRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[50]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*PingRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *PingRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[50]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use PingRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*PingRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{50}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingRequest) GetTarget() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Target
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingRequest) GetTargetType() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.TargetType
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type PingResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									StartTimeNs   int64                  `protobuf:"varint,1,opt,name=start_time_ns,json=startTimeNs,proto3" json:"start_time_ns,omitempty"`
							 | 
						|
									RemoteTimeNs  int64                  `protobuf:"varint,2,opt,name=remote_time_ns,json=remoteTimeNs,proto3" json:"remote_time_ns,omitempty"`
							 | 
						|
									StopTimeNs    int64                  `protobuf:"varint,3,opt,name=stop_time_ns,json=stopTimeNs,proto3" json:"stop_time_ns,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingResponse) Reset() {
							 | 
						|
									*x = PingResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[51]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*PingResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *PingResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[51]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use PingResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*PingResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{51}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingResponse) GetStartTimeNs() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.StartTimeNs
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingResponse) GetRemoteTimeNs() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.RemoteTimeNs
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *PingResponse) GetStopTimeNs() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.StopTimeNs
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RaftAddServerRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									Address       string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
							 | 
						|
									Voter         bool                   `protobuf:"varint,3,opt,name=voter,proto3" json:"voter,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerRequest) Reset() {
							 | 
						|
									*x = RaftAddServerRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[52]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RaftAddServerRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[52]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RaftAddServerRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RaftAddServerRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{52}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerRequest) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerRequest) GetAddress() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Address
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerRequest) GetVoter() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Voter
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RaftAddServerResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerResponse) Reset() {
							 | 
						|
									*x = RaftAddServerResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[53]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RaftAddServerResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RaftAddServerResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[53]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RaftAddServerResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RaftAddServerResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{53}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RaftRemoveServerRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									Force         bool                   `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerRequest) Reset() {
							 | 
						|
									*x = RaftRemoveServerRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[54]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RaftRemoveServerRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[54]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RaftRemoveServerRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RaftRemoveServerRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{54}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerRequest) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerRequest) GetForce() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Force
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RaftRemoveServerResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerResponse) Reset() {
							 | 
						|
									*x = RaftRemoveServerResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[55]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RaftRemoveServerResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RaftRemoveServerResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[55]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RaftRemoveServerResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RaftRemoveServerResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{55}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RaftListClusterServersRequest struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersRequest) Reset() {
							 | 
						|
									*x = RaftListClusterServersRequest{}
							 | 
						|
									mi := &file_master_proto_msgTypes[56]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersRequest) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RaftListClusterServersRequest) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersRequest) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[56]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RaftListClusterServersRequest.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RaftListClusterServersRequest) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{56}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RaftListClusterServersResponse struct {
							 | 
						|
									state          protoimpl.MessageState                           `protogen:"open.v1"`
							 | 
						|
									ClusterServers []*RaftListClusterServersResponse_ClusterServers `protobuf:"bytes,1,rep,name=cluster_servers,json=clusterServers,proto3" json:"cluster_servers,omitempty"`
							 | 
						|
									unknownFields  protoimpl.UnknownFields
							 | 
						|
									sizeCache      protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse) Reset() {
							 | 
						|
									*x = RaftListClusterServersResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[57]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RaftListClusterServersResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[57]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RaftListClusterServersResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RaftListClusterServersResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{57}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse) GetClusterServers() []*RaftListClusterServersResponse_ClusterServers {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ClusterServers
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type VolumeGrowResponse struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowResponse) Reset() {
							 | 
						|
									*x = VolumeGrowResponse{}
							 | 
						|
									mi := &file_master_proto_msgTypes[58]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowResponse) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*VolumeGrowResponse) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *VolumeGrowResponse) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[58]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use VolumeGrowResponse.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*VolumeGrowResponse) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{58}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type SuperBlockExtra_ErasureCoding struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Data          uint32                 `protobuf:"varint,1,opt,name=data,proto3" json:"data,omitempty"`
							 | 
						|
									Parity        uint32                 `protobuf:"varint,2,opt,name=parity,proto3" json:"parity,omitempty"`
							 | 
						|
									VolumeIds     []uint32               `protobuf:"varint,3,rep,packed,name=volume_ids,json=volumeIds,proto3" json:"volume_ids,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra_ErasureCoding) Reset() {
							 | 
						|
									*x = SuperBlockExtra_ErasureCoding{}
							 | 
						|
									mi := &file_master_proto_msgTypes[61]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra_ErasureCoding) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*SuperBlockExtra_ErasureCoding) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra_ErasureCoding) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[61]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use SuperBlockExtra_ErasureCoding.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*SuperBlockExtra_ErasureCoding) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{7, 0}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra_ErasureCoding) GetData() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Data
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra_ErasureCoding) GetParity() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Parity
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *SuperBlockExtra_ErasureCoding) GetVolumeIds() []uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeIds
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LookupVolumeResponse_VolumeIdLocation struct {
							 | 
						|
									state          protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									VolumeOrFileId string                 `protobuf:"bytes,1,opt,name=volume_or_file_id,json=volumeOrFileId,proto3" json:"volume_or_file_id,omitempty"`
							 | 
						|
									Locations      []*Location            `protobuf:"bytes,2,rep,name=locations,proto3" json:"locations,omitempty"`
							 | 
						|
									Error          string                 `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
							 | 
						|
									Auth           string                 `protobuf:"bytes,4,opt,name=auth,proto3" json:"auth,omitempty"`
							 | 
						|
									unknownFields  protoimpl.UnknownFields
							 | 
						|
									sizeCache      protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse_VolumeIdLocation) Reset() {
							 | 
						|
									*x = LookupVolumeResponse_VolumeIdLocation{}
							 | 
						|
									mi := &file_master_proto_msgTypes[62]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse_VolumeIdLocation) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LookupVolumeResponse_VolumeIdLocation) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse_VolumeIdLocation) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[62]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LookupVolumeResponse_VolumeIdLocation.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LookupVolumeResponse_VolumeIdLocation) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{13, 0}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse_VolumeIdLocation) GetVolumeOrFileId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.VolumeOrFileId
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse_VolumeIdLocation) GetLocations() []*Location {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Locations
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse_VolumeIdLocation) GetError() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Error
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupVolumeResponse_VolumeIdLocation) GetAuth() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Auth
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type LookupEcVolumeResponse_EcShardIdLocation struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									ShardId       uint32                 `protobuf:"varint,1,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
							 | 
						|
									Locations     []*Location            `protobuf:"bytes,2,rep,name=locations,proto3" json:"locations,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse_EcShardIdLocation) Reset() {
							 | 
						|
									*x = LookupEcVolumeResponse_EcShardIdLocation{}
							 | 
						|
									mi := &file_master_proto_msgTypes[67]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse_EcShardIdLocation) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*LookupEcVolumeResponse_EcShardIdLocation) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse_EcShardIdLocation) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[67]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use LookupEcVolumeResponse_EcShardIdLocation.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*LookupEcVolumeResponse_EcShardIdLocation) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{33, 0}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse_EcShardIdLocation) GetShardId() uint32 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.ShardId
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *LookupEcVolumeResponse_EcShardIdLocation) GetLocations() []*Location {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Locations
							 | 
						|
									}
							 | 
						|
									return nil
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type ListClusterNodesResponse_ClusterNode struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Address       string                 `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
							 | 
						|
									Version       string                 `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
							 | 
						|
									CreatedAtNs   int64                  `protobuf:"varint,4,opt,name=created_at_ns,json=createdAtNs,proto3" json:"created_at_ns,omitempty"`
							 | 
						|
									DataCenter    string                 `protobuf:"bytes,5,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"`
							 | 
						|
									Rack          string                 `protobuf:"bytes,6,opt,name=rack,proto3" json:"rack,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) Reset() {
							 | 
						|
									*x = ListClusterNodesResponse_ClusterNode{}
							 | 
						|
									mi := &file_master_proto_msgTypes[68]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*ListClusterNodesResponse_ClusterNode) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[68]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use ListClusterNodesResponse_ClusterNode.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*ListClusterNodesResponse_ClusterNode) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{45, 0}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) GetAddress() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Address
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) GetVersion() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Version
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) GetCreatedAtNs() int64 {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.CreatedAtNs
							 | 
						|
									}
							 | 
						|
									return 0
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) GetDataCenter() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.DataCenter
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *ListClusterNodesResponse_ClusterNode) GetRack() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Rack
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								type RaftListClusterServersResponse_ClusterServers struct {
							 | 
						|
									state         protoimpl.MessageState `protogen:"open.v1"`
							 | 
						|
									Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
							 | 
						|
									Address       string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
							 | 
						|
									Suffrage      string                 `protobuf:"bytes,3,opt,name=suffrage,proto3" json:"suffrage,omitempty"`
							 | 
						|
									IsLeader      bool                   `protobuf:"varint,4,opt,name=isLeader,proto3" json:"isLeader,omitempty"`
							 | 
						|
									unknownFields protoimpl.UnknownFields
							 | 
						|
									sizeCache     protoimpl.SizeCache
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse_ClusterServers) Reset() {
							 | 
						|
									*x = RaftListClusterServersResponse_ClusterServers{}
							 | 
						|
									mi := &file_master_proto_msgTypes[69]
							 | 
						|
									ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
									ms.StoreMessageInfo(mi)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse_ClusterServers) String() string {
							 | 
						|
									return protoimpl.X.MessageStringOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (*RaftListClusterServersResponse_ClusterServers) ProtoMessage() {}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse_ClusterServers) ProtoReflect() protoreflect.Message {
							 | 
						|
									mi := &file_master_proto_msgTypes[69]
							 | 
						|
									if x != nil {
							 | 
						|
										ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
							 | 
						|
										if ms.LoadMessageInfo() == nil {
							 | 
						|
											ms.StoreMessageInfo(mi)
							 | 
						|
										}
							 | 
						|
										return ms
							 | 
						|
									}
							 | 
						|
									return mi.MessageOf(x)
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								// Deprecated: Use RaftListClusterServersResponse_ClusterServers.ProtoReflect.Descriptor instead.
							 | 
						|
								func (*RaftListClusterServersResponse_ClusterServers) Descriptor() ([]byte, []int) {
							 | 
						|
									return file_master_proto_rawDescGZIP(), []int{57, 0}
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse_ClusterServers) GetId() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Id
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse_ClusterServers) GetAddress() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Address
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse_ClusterServers) GetSuffrage() string {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.Suffrage
							 | 
						|
									}
							 | 
						|
									return ""
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func (x *RaftListClusterServersResponse_ClusterServers) GetIsLeader() bool {
							 | 
						|
									if x != nil {
							 | 
						|
										return x.IsLeader
							 | 
						|
									}
							 | 
						|
									return false
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								var File_master_proto protoreflect.FileDescriptor
							 | 
						|
								
							 | 
						|
								const file_master_proto_rawDesc = "" +
							 | 
						|
									"\n" +
							 | 
						|
									"\fmaster.proto\x12\tmaster_pb\"\xc0\a\n" +
							 | 
						|
									"\tHeartbeat\x12\x0e\n" +
							 | 
						|
									"\x02ip\x18\x01 \x01(\tR\x02ip\x12\x12\n" +
							 | 
						|
									"\x04port\x18\x02 \x01(\rR\x04port\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"public_url\x18\x03 \x01(\tR\tpublicUrl\x12 \n" +
							 | 
						|
									"\fmax_file_key\x18\x05 \x01(\x04R\n" +
							 | 
						|
									"maxFileKey\x12\x1f\n" +
							 | 
						|
									"\vdata_center\x18\x06 \x01(\tR\n" +
							 | 
						|
									"dataCenter\x12\x12\n" +
							 | 
						|
									"\x04rack\x18\a \x01(\tR\x04rack\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"admin_port\x18\b \x01(\rR\tadminPort\x12=\n" +
							 | 
						|
									"\avolumes\x18\t \x03(\v2#.master_pb.VolumeInformationMessageR\avolumes\x12I\n" +
							 | 
						|
									"\vnew_volumes\x18\n" +
							 | 
						|
									" \x03(\v2(.master_pb.VolumeShortInformationMessageR\n" +
							 | 
						|
									"newVolumes\x12Q\n" +
							 | 
						|
									"\x0fdeleted_volumes\x18\v \x03(\v2(.master_pb.VolumeShortInformationMessageR\x0edeletedVolumes\x12$\n" +
							 | 
						|
									"\x0ehas_no_volumes\x18\f \x01(\bR\fhasNoVolumes\x12G\n" +
							 | 
						|
									"\tec_shards\x18\x10 \x03(\v2*.master_pb.VolumeEcShardInformationMessageR\becShards\x12N\n" +
							 | 
						|
									"\rnew_ec_shards\x18\x11 \x03(\v2*.master_pb.VolumeEcShardInformationMessageR\vnewEcShards\x12V\n" +
							 | 
						|
									"\x11deleted_ec_shards\x18\x12 \x03(\v2*.master_pb.VolumeEcShardInformationMessageR\x0fdeletedEcShards\x12'\n" +
							 | 
						|
									"\x10has_no_ec_shards\x18\x13 \x01(\bR\rhasNoEcShards\x12U\n" +
							 | 
						|
									"\x11max_volume_counts\x18\x04 \x03(\v2).master_pb.Heartbeat.MaxVolumeCountsEntryR\x0fmaxVolumeCounts\x12\x1b\n" +
							 | 
						|
									"\tgrpc_port\x18\x14 \x01(\rR\bgrpcPort\x12%\n" +
							 | 
						|
									"\x0elocation_uuids\x18\x15 \x03(\tR\rlocationUuids\x1aB\n" +
							 | 
						|
									"\x14MaxVolumeCountsEntry\x12\x10\n" +
							 | 
						|
									"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
							 | 
						|
									"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\"\xcd\x02\n" +
							 | 
						|
									"\x11HeartbeatResponse\x12*\n" +
							 | 
						|
									"\x11volume_size_limit\x18\x01 \x01(\x04R\x0fvolumeSizeLimit\x12\x16\n" +
							 | 
						|
									"\x06leader\x18\x02 \x01(\tR\x06leader\x12'\n" +
							 | 
						|
									"\x0fmetrics_address\x18\x03 \x01(\tR\x0emetricsAddress\x128\n" +
							 | 
						|
									"\x18metrics_interval_seconds\x18\x04 \x01(\rR\x16metricsIntervalSeconds\x12D\n" +
							 | 
						|
									"\x10storage_backends\x18\x05 \x03(\v2\x19.master_pb.StorageBackendR\x0fstorageBackends\x12)\n" +
							 | 
						|
									"\x10duplicated_uuids\x18\x06 \x03(\tR\x0fduplicatedUuids\x12 \n" +
							 | 
						|
									"\vpreallocate\x18\a \x01(\bR\vpreallocate\"\xb1\x04\n" +
							 | 
						|
									"\x18VolumeInformationMessage\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\rR\x02id\x12\x12\n" +
							 | 
						|
									"\x04size\x18\x02 \x01(\x04R\x04size\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x03 \x01(\tR\n" +
							 | 
						|
									"collection\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"file_count\x18\x04 \x01(\x04R\tfileCount\x12!\n" +
							 | 
						|
									"\fdelete_count\x18\x05 \x01(\x04R\vdeleteCount\x12,\n" +
							 | 
						|
									"\x12deleted_byte_count\x18\x06 \x01(\x04R\x10deletedByteCount\x12\x1b\n" +
							 | 
						|
									"\tread_only\x18\a \x01(\bR\breadOnly\x12+\n" +
							 | 
						|
									"\x11replica_placement\x18\b \x01(\rR\x10replicaPlacement\x12\x18\n" +
							 | 
						|
									"\aversion\x18\t \x01(\rR\aversion\x12\x10\n" +
							 | 
						|
									"\x03ttl\x18\n" +
							 | 
						|
									" \x01(\rR\x03ttl\x12)\n" +
							 | 
						|
									"\x10compact_revision\x18\v \x01(\rR\x0fcompactRevision\x12,\n" +
							 | 
						|
									"\x12modified_at_second\x18\f \x01(\x03R\x10modifiedAtSecond\x12.\n" +
							 | 
						|
									"\x13remote_storage_name\x18\r \x01(\tR\x11remoteStorageName\x12,\n" +
							 | 
						|
									"\x12remote_storage_key\x18\x0e \x01(\tR\x10remoteStorageKey\x12\x1b\n" +
							 | 
						|
									"\tdisk_type\x18\x0f \x01(\tR\bdiskType\x12\x17\n" +
							 | 
						|
									"\adisk_id\x18\x10 \x01(\rR\x06diskId\"\xde\x01\n" +
							 | 
						|
									"\x1dVolumeShortInformationMessage\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\rR\x02id\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x03 \x01(\tR\n" +
							 | 
						|
									"collection\x12+\n" +
							 | 
						|
									"\x11replica_placement\x18\b \x01(\rR\x10replicaPlacement\x12\x18\n" +
							 | 
						|
									"\aversion\x18\t \x01(\rR\aversion\x12\x10\n" +
							 | 
						|
									"\x03ttl\x18\n" +
							 | 
						|
									" \x01(\rR\x03ttl\x12\x1b\n" +
							 | 
						|
									"\tdisk_type\x18\x0f \x01(\tR\bdiskType\x12\x17\n" +
							 | 
						|
									"\adisk_id\x18\x10 \x01(\rR\x06diskId\"\xf0\x01\n" +
							 | 
						|
									"\x1fVolumeEcShardInformationMessage\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\rR\x02id\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x02 \x01(\tR\n" +
							 | 
						|
									"collection\x12\"\n" +
							 | 
						|
									"\rec_index_bits\x18\x03 \x01(\rR\vecIndexBits\x12\x1b\n" +
							 | 
						|
									"\tdisk_type\x18\x04 \x01(\tR\bdiskType\x12\"\n" +
							 | 
						|
									"\rexpire_at_sec\x18\x05 \x01(\x04R\vexpireAtSec\x12\x17\n" +
							 | 
						|
									"\adisk_id\x18\x06 \x01(\rR\x06diskId\x12\x1f\n" +
							 | 
						|
									"\vshard_sizes\x18\a \x03(\x03R\n" +
							 | 
						|
									"shardSizes\"\xbe\x01\n" +
							 | 
						|
									"\x0eStorageBackend\x12\x12\n" +
							 | 
						|
									"\x04type\x18\x01 \x01(\tR\x04type\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x02 \x01(\tR\x02id\x12I\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"properties\x18\x03 \x03(\v2).master_pb.StorageBackend.PropertiesEntryR\n" +
							 | 
						|
									"properties\x1a=\n" +
							 | 
						|
									"\x0fPropertiesEntry\x12\x10\n" +
							 | 
						|
									"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
							 | 
						|
									"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\a\n" +
							 | 
						|
									"\x05Empty\"\xbe\x01\n" +
							 | 
						|
									"\x0fSuperBlockExtra\x12O\n" +
							 | 
						|
									"\x0eerasure_coding\x18\x01 \x01(\v2(.master_pb.SuperBlockExtra.ErasureCodingR\rerasureCoding\x1aZ\n" +
							 | 
						|
									"\rErasureCoding\x12\x12\n" +
							 | 
						|
									"\x04data\x18\x01 \x01(\rR\x04data\x12\x16\n" +
							 | 
						|
									"\x06parity\x18\x02 \x01(\rR\x06parity\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"volume_ids\x18\x03 \x03(\rR\tvolumeIds\"\xce\x01\n" +
							 | 
						|
									"\x14KeepConnectedRequest\x12\x1f\n" +
							 | 
						|
									"\vclient_type\x18\x01 \x01(\tR\n" +
							 | 
						|
									"clientType\x12%\n" +
							 | 
						|
									"\x0eclient_address\x18\x03 \x01(\tR\rclientAddress\x12\x18\n" +
							 | 
						|
									"\aversion\x18\x04 \x01(\tR\aversion\x12\x1f\n" +
							 | 
						|
									"\vfiler_group\x18\x05 \x01(\tR\n" +
							 | 
						|
									"filerGroup\x12\x1f\n" +
							 | 
						|
									"\vdata_center\x18\x06 \x01(\tR\n" +
							 | 
						|
									"dataCenter\x12\x12\n" +
							 | 
						|
									"\x04rack\x18\a \x01(\tR\x04rack\"\x9d\x02\n" +
							 | 
						|
									"\x0eVolumeLocation\x12\x10\n" +
							 | 
						|
									"\x03url\x18\x01 \x01(\tR\x03url\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"public_url\x18\x02 \x01(\tR\tpublicUrl\x12\x19\n" +
							 | 
						|
									"\bnew_vids\x18\x03 \x03(\rR\anewVids\x12!\n" +
							 | 
						|
									"\fdeleted_vids\x18\x04 \x03(\rR\vdeletedVids\x12\x16\n" +
							 | 
						|
									"\x06leader\x18\x05 \x01(\tR\x06leader\x12\x1f\n" +
							 | 
						|
									"\vdata_center\x18\x06 \x01(\tR\n" +
							 | 
						|
									"dataCenter\x12\x1b\n" +
							 | 
						|
									"\tgrpc_port\x18\a \x01(\rR\bgrpcPort\x12\x1e\n" +
							 | 
						|
									"\vnew_ec_vids\x18\b \x03(\rR\tnewEcVids\x12&\n" +
							 | 
						|
									"\x0fdeleted_ec_vids\x18\t \x03(\rR\rdeletedEcVids\"\xa6\x01\n" +
							 | 
						|
									"\x11ClusterNodeUpdate\x12\x1b\n" +
							 | 
						|
									"\tnode_type\x18\x01 \x01(\tR\bnodeType\x12\x18\n" +
							 | 
						|
									"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x15\n" +
							 | 
						|
									"\x06is_add\x18\x04 \x01(\bR\x05isAdd\x12\x1f\n" +
							 | 
						|
									"\vfiler_group\x18\x05 \x01(\tR\n" +
							 | 
						|
									"filerGroup\x12\"\n" +
							 | 
						|
									"\rcreated_at_ns\x18\x06 \x01(\x03R\vcreatedAtNs\"\xa9\x01\n" +
							 | 
						|
									"\x15KeepConnectedResponse\x12B\n" +
							 | 
						|
									"\x0fvolume_location\x18\x01 \x01(\v2\x19.master_pb.VolumeLocationR\x0evolumeLocation\x12L\n" +
							 | 
						|
									"\x13cluster_node_update\x18\x02 \x01(\v2\x1c.master_pb.ClusterNodeUpdateR\x11clusterNodeUpdate\"b\n" +
							 | 
						|
									"\x13LookupVolumeRequest\x12+\n" +
							 | 
						|
									"\x12volume_or_file_ids\x18\x01 \x03(\tR\x0fvolumeOrFileIds\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x02 \x01(\tR\n" +
							 | 
						|
									"collection\"\x95\x02\n" +
							 | 
						|
									"\x14LookupVolumeResponse\x12`\n" +
							 | 
						|
									"\x13volume_id_locations\x18\x01 \x03(\v20.master_pb.LookupVolumeResponse.VolumeIdLocationR\x11volumeIdLocations\x1a\x9a\x01\n" +
							 | 
						|
									"\x10VolumeIdLocation\x12)\n" +
							 | 
						|
									"\x11volume_or_file_id\x18\x01 \x01(\tR\x0evolumeOrFileId\x121\n" +
							 | 
						|
									"\tlocations\x18\x02 \x03(\v2\x13.master_pb.LocationR\tlocations\x12\x14\n" +
							 | 
						|
									"\x05error\x18\x03 \x01(\tR\x05error\x12\x12\n" +
							 | 
						|
									"\x04auth\x18\x04 \x01(\tR\x04auth\"y\n" +
							 | 
						|
									"\bLocation\x12\x10\n" +
							 | 
						|
									"\x03url\x18\x01 \x01(\tR\x03url\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"public_url\x18\x02 \x01(\tR\tpublicUrl\x12\x1b\n" +
							 | 
						|
									"\tgrpc_port\x18\x03 \x01(\rR\bgrpcPort\x12\x1f\n" +
							 | 
						|
									"\vdata_center\x18\x04 \x01(\tR\n" +
							 | 
						|
									"dataCenter\"\xd0\x02\n" +
							 | 
						|
									"\rAssignRequest\x12\x14\n" +
							 | 
						|
									"\x05count\x18\x01 \x01(\x04R\x05count\x12 \n" +
							 | 
						|
									"\vreplication\x18\x02 \x01(\tR\vreplication\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x03 \x01(\tR\n" +
							 | 
						|
									"collection\x12\x10\n" +
							 | 
						|
									"\x03ttl\x18\x04 \x01(\tR\x03ttl\x12\x1f\n" +
							 | 
						|
									"\vdata_center\x18\x05 \x01(\tR\n" +
							 | 
						|
									"dataCenter\x12\x12\n" +
							 | 
						|
									"\x04rack\x18\x06 \x01(\tR\x04rack\x12\x1b\n" +
							 | 
						|
									"\tdata_node\x18\a \x01(\tR\bdataNode\x122\n" +
							 | 
						|
									"\x16memory_map_max_size_mb\x18\b \x01(\rR\x12memoryMapMaxSizeMb\x122\n" +
							 | 
						|
									"\x15writable_volume_count\x18\t \x01(\rR\x13writableVolumeCount\x12\x1b\n" +
							 | 
						|
									"\tdisk_type\x18\n" +
							 | 
						|
									" \x01(\tR\bdiskType\"\xbe\x02\n" +
							 | 
						|
									"\x11VolumeGrowRequest\x122\n" +
							 | 
						|
									"\x15writable_volume_count\x18\x01 \x01(\rR\x13writableVolumeCount\x12 \n" +
							 | 
						|
									"\vreplication\x18\x02 \x01(\tR\vreplication\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x03 \x01(\tR\n" +
							 | 
						|
									"collection\x12\x10\n" +
							 | 
						|
									"\x03ttl\x18\x04 \x01(\tR\x03ttl\x12\x1f\n" +
							 | 
						|
									"\vdata_center\x18\x05 \x01(\tR\n" +
							 | 
						|
									"dataCenter\x12\x12\n" +
							 | 
						|
									"\x04rack\x18\x06 \x01(\tR\x04rack\x12\x1b\n" +
							 | 
						|
									"\tdata_node\x18\a \x01(\tR\bdataNode\x122\n" +
							 | 
						|
									"\x16memory_map_max_size_mb\x18\b \x01(\rR\x12memoryMapMaxSizeMb\x12\x1b\n" +
							 | 
						|
									"\tdisk_type\x18\t \x01(\tR\bdiskType\"\xc4\x01\n" +
							 | 
						|
									"\x0eAssignResponse\x12\x10\n" +
							 | 
						|
									"\x03fid\x18\x01 \x01(\tR\x03fid\x12\x14\n" +
							 | 
						|
									"\x05count\x18\x04 \x01(\x04R\x05count\x12\x14\n" +
							 | 
						|
									"\x05error\x18\x05 \x01(\tR\x05error\x12\x12\n" +
							 | 
						|
									"\x04auth\x18\x06 \x01(\tR\x04auth\x12/\n" +
							 | 
						|
									"\breplicas\x18\a \x03(\v2\x13.master_pb.LocationR\breplicas\x12/\n" +
							 | 
						|
									"\blocation\x18\b \x01(\v2\x13.master_pb.LocationR\blocation\"\x84\x01\n" +
							 | 
						|
									"\x11StatisticsRequest\x12 \n" +
							 | 
						|
									"\vreplication\x18\x01 \x01(\tR\vreplication\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x02 \x01(\tR\n" +
							 | 
						|
									"collection\x12\x10\n" +
							 | 
						|
									"\x03ttl\x18\x03 \x01(\tR\x03ttl\x12\x1b\n" +
							 | 
						|
									"\tdisk_type\x18\x04 \x01(\tR\bdiskType\"o\n" +
							 | 
						|
									"\x12StatisticsResponse\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"total_size\x18\x04 \x01(\x04R\ttotalSize\x12\x1b\n" +
							 | 
						|
									"\tused_size\x18\x05 \x01(\x04R\busedSize\x12\x1d\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"file_count\x18\x06 \x01(\x04R\tfileCount\" \n" +
							 | 
						|
									"\n" +
							 | 
						|
									"Collection\x12\x12\n" +
							 | 
						|
									"\x04name\x18\x01 \x01(\tR\x04name\"{\n" +
							 | 
						|
									"\x15CollectionListRequest\x124\n" +
							 | 
						|
									"\x16include_normal_volumes\x18\x01 \x01(\bR\x14includeNormalVolumes\x12,\n" +
							 | 
						|
									"\x12include_ec_volumes\x18\x02 \x01(\bR\x10includeEcVolumes\"Q\n" +
							 | 
						|
									"\x16CollectionListResponse\x127\n" +
							 | 
						|
									"\vcollections\x18\x01 \x03(\v2\x15.master_pb.CollectionR\vcollections\"-\n" +
							 | 
						|
									"\x17CollectionDeleteRequest\x12\x12\n" +
							 | 
						|
									"\x04name\x18\x01 \x01(\tR\x04name\"\x1a\n" +
							 | 
						|
									"\x18CollectionDeleteResponse\"\xaa\x03\n" +
							 | 
						|
									"\bDiskInfo\x12\x12\n" +
							 | 
						|
									"\x04type\x18\x01 \x01(\tR\x04type\x12!\n" +
							 | 
						|
									"\fvolume_count\x18\x02 \x01(\x03R\vvolumeCount\x12(\n" +
							 | 
						|
									"\x10max_volume_count\x18\x03 \x01(\x03R\x0emaxVolumeCount\x12*\n" +
							 | 
						|
									"\x11free_volume_count\x18\x04 \x01(\x03R\x0ffreeVolumeCount\x12.\n" +
							 | 
						|
									"\x13active_volume_count\x18\x05 \x01(\x03R\x11activeVolumeCount\x12F\n" +
							 | 
						|
									"\fvolume_infos\x18\x06 \x03(\v2#.master_pb.VolumeInformationMessageR\vvolumeInfos\x12P\n" +
							 | 
						|
									"\x0eec_shard_infos\x18\a \x03(\v2*.master_pb.VolumeEcShardInformationMessageR\fecShardInfos\x12.\n" +
							 | 
						|
									"\x13remote_volume_count\x18\b \x01(\x03R\x11remoteVolumeCount\x12\x17\n" +
							 | 
						|
									"\adisk_id\x18\t \x01(\rR\x06diskId\"\xd4\x01\n" +
							 | 
						|
									"\fDataNodeInfo\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\tR\x02id\x12D\n" +
							 | 
						|
									"\tdiskInfos\x18\x02 \x03(\v2&.master_pb.DataNodeInfo.DiskInfosEntryR\tdiskInfos\x12\x1b\n" +
							 | 
						|
									"\tgrpc_port\x18\x03 \x01(\rR\bgrpcPort\x1aQ\n" +
							 | 
						|
									"\x0eDiskInfosEntry\x12\x10\n" +
							 | 
						|
									"\x03key\x18\x01 \x01(\tR\x03key\x12)\n" +
							 | 
						|
									"\x05value\x18\x02 \x01(\v2\x13.master_pb.DiskInfoR\x05value:\x028\x01\"\xf0\x01\n" +
							 | 
						|
									"\bRackInfo\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\tR\x02id\x12?\n" +
							 | 
						|
									"\x0fdata_node_infos\x18\x02 \x03(\v2\x17.master_pb.DataNodeInfoR\rdataNodeInfos\x12@\n" +
							 | 
						|
									"\tdiskInfos\x18\x03 \x03(\v2\".master_pb.RackInfo.DiskInfosEntryR\tdiskInfos\x1aQ\n" +
							 | 
						|
									"\x0eDiskInfosEntry\x12\x10\n" +
							 | 
						|
									"\x03key\x18\x01 \x01(\tR\x03key\x12)\n" +
							 | 
						|
									"\x05value\x18\x02 \x01(\v2\x13.master_pb.DiskInfoR\x05value:\x028\x01\"\xef\x01\n" +
							 | 
						|
									"\x0eDataCenterInfo\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\tR\x02id\x122\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"rack_infos\x18\x02 \x03(\v2\x13.master_pb.RackInfoR\trackInfos\x12F\n" +
							 | 
						|
									"\tdiskInfos\x18\x03 \x03(\v2(.master_pb.DataCenterInfo.DiskInfosEntryR\tdiskInfos\x1aQ\n" +
							 | 
						|
									"\x0eDiskInfosEntry\x12\x10\n" +
							 | 
						|
									"\x03key\x18\x01 \x01(\tR\x03key\x12)\n" +
							 | 
						|
									"\x05value\x18\x02 \x01(\v2\x13.master_pb.DiskInfoR\x05value:\x028\x01\"\xfe\x01\n" +
							 | 
						|
									"\fTopologyInfo\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\tR\x02id\x12E\n" +
							 | 
						|
									"\x11data_center_infos\x18\x02 \x03(\v2\x19.master_pb.DataCenterInfoR\x0fdataCenterInfos\x12D\n" +
							 | 
						|
									"\tdiskInfos\x18\x03 \x03(\v2&.master_pb.TopologyInfo.DiskInfosEntryR\tdiskInfos\x1aQ\n" +
							 | 
						|
									"\x0eDiskInfosEntry\x12\x10\n" +
							 | 
						|
									"\x03key\x18\x01 \x01(\tR\x03key\x12)\n" +
							 | 
						|
									"\x05value\x18\x02 \x01(\v2\x13.master_pb.DiskInfoR\x05value:\x028\x01\"\x13\n" +
							 | 
						|
									"\x11VolumeListRequest\"\x83\x01\n" +
							 | 
						|
									"\x12VolumeListResponse\x12<\n" +
							 | 
						|
									"\rtopology_info\x18\x01 \x01(\v2\x17.master_pb.TopologyInfoR\ftopologyInfo\x12/\n" +
							 | 
						|
									"\x14volume_size_limit_mb\x18\x02 \x01(\x04R\x11volumeSizeLimitMb\"4\n" +
							 | 
						|
									"\x15LookupEcVolumeRequest\x12\x1b\n" +
							 | 
						|
									"\tvolume_id\x18\x01 \x01(\rR\bvolumeId\"\xfb\x01\n" +
							 | 
						|
									"\x16LookupEcVolumeResponse\x12\x1b\n" +
							 | 
						|
									"\tvolume_id\x18\x01 \x01(\rR\bvolumeId\x12a\n" +
							 | 
						|
									"\x12shard_id_locations\x18\x02 \x03(\v23.master_pb.LookupEcVolumeResponse.EcShardIdLocationR\x10shardIdLocations\x1aa\n" +
							 | 
						|
									"\x11EcShardIdLocation\x12\x19\n" +
							 | 
						|
									"\bshard_id\x18\x01 \x01(\rR\ashardId\x121\n" +
							 | 
						|
									"\tlocations\x18\x02 \x03(\v2\x13.master_pb.LocationR\tlocations\"\x7f\n" +
							 | 
						|
									"\x13VacuumVolumeRequest\x12+\n" +
							 | 
						|
									"\x11garbage_threshold\x18\x01 \x01(\x02R\x10garbageThreshold\x12\x1b\n" +
							 | 
						|
									"\tvolume_id\x18\x02 \x01(\rR\bvolumeId\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x03 \x01(\tR\n" +
							 | 
						|
									"collection\"\x16\n" +
							 | 
						|
									"\x14VacuumVolumeResponse\"\x16\n" +
							 | 
						|
									"\x14DisableVacuumRequest\"\x17\n" +
							 | 
						|
									"\x15DisableVacuumResponse\"\x15\n" +
							 | 
						|
									"\x13EnableVacuumRequest\"\x16\n" +
							 | 
						|
									"\x14EnableVacuumResponse\"\x93\x02\n" +
							 | 
						|
									"\x19VolumeMarkReadonlyRequest\x12\x0e\n" +
							 | 
						|
									"\x02ip\x18\x01 \x01(\tR\x02ip\x12\x12\n" +
							 | 
						|
									"\x04port\x18\x02 \x01(\rR\x04port\x12\x1b\n" +
							 | 
						|
									"\tvolume_id\x18\x04 \x01(\rR\bvolumeId\x12\x1e\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"collection\x18\x05 \x01(\tR\n" +
							 | 
						|
									"collection\x12+\n" +
							 | 
						|
									"\x11replica_placement\x18\x06 \x01(\rR\x10replicaPlacement\x12\x18\n" +
							 | 
						|
									"\aversion\x18\a \x01(\rR\aversion\x12\x10\n" +
							 | 
						|
									"\x03ttl\x18\b \x01(\rR\x03ttl\x12\x1b\n" +
							 | 
						|
									"\tdisk_type\x18\t \x01(\tR\bdiskType\x12\x1f\n" +
							 | 
						|
									"\vis_readonly\x18\n" +
							 | 
						|
									" \x01(\bR\n" +
							 | 
						|
									"isReadonly\"\x1c\n" +
							 | 
						|
									"\x1aVolumeMarkReadonlyResponse\"\x1f\n" +
							 | 
						|
									"\x1dGetMasterConfigurationRequest\"\xf3\x02\n" +
							 | 
						|
									"\x1eGetMasterConfigurationResponse\x12'\n" +
							 | 
						|
									"\x0fmetrics_address\x18\x01 \x01(\tR\x0emetricsAddress\x128\n" +
							 | 
						|
									"\x18metrics_interval_seconds\x18\x02 \x01(\rR\x16metricsIntervalSeconds\x12D\n" +
							 | 
						|
									"\x10storage_backends\x18\x03 \x03(\v2\x19.master_pb.StorageBackendR\x0fstorageBackends\x12/\n" +
							 | 
						|
									"\x13default_replication\x18\x04 \x01(\tR\x12defaultReplication\x12\x16\n" +
							 | 
						|
									"\x06leader\x18\x05 \x01(\tR\x06leader\x120\n" +
							 | 
						|
									"\x15volume_size_limit_m_b\x18\x06 \x01(\rR\x11volumeSizeLimitMB\x12-\n" +
							 | 
						|
									"\x12volume_preallocate\x18\a \x01(\bR\x11volumePreallocate\"q\n" +
							 | 
						|
									"\x17ListClusterNodesRequest\x12\x1f\n" +
							 | 
						|
									"\vclient_type\x18\x01 \x01(\tR\n" +
							 | 
						|
									"clientType\x12\x1f\n" +
							 | 
						|
									"\vfiler_group\x18\x02 \x01(\tR\n" +
							 | 
						|
									"filerGroup\x12\x14\n" +
							 | 
						|
									"\x05limit\x18\x04 \x01(\x05R\x05limit\"\x8d\x02\n" +
							 | 
						|
									"\x18ListClusterNodesResponse\x12T\n" +
							 | 
						|
									"\rcluster_nodes\x18\x01 \x03(\v2/.master_pb.ListClusterNodesResponse.ClusterNodeR\fclusterNodes\x1a\x9a\x01\n" +
							 | 
						|
									"\vClusterNode\x12\x18\n" +
							 | 
						|
									"\aaddress\x18\x01 \x01(\tR\aaddress\x12\x18\n" +
							 | 
						|
									"\aversion\x18\x02 \x01(\tR\aversion\x12\"\n" +
							 | 
						|
									"\rcreated_at_ns\x18\x04 \x01(\x03R\vcreatedAtNs\x12\x1f\n" +
							 | 
						|
									"\vdata_center\x18\x05 \x01(\tR\n" +
							 | 
						|
									"dataCenter\x12\x12\n" +
							 | 
						|
									"\x04rack\x18\x06 \x01(\tR\x04rack\"\xc5\x01\n" +
							 | 
						|
									"\x16LeaseAdminTokenRequest\x12%\n" +
							 | 
						|
									"\x0eprevious_token\x18\x01 \x01(\x03R\rpreviousToken\x12,\n" +
							 | 
						|
									"\x12previous_lock_time\x18\x02 \x01(\x03R\x10previousLockTime\x12\x1b\n" +
							 | 
						|
									"\tlock_name\x18\x03 \x01(\tR\blockName\x12\x1f\n" +
							 | 
						|
									"\vclient_name\x18\x04 \x01(\tR\n" +
							 | 
						|
									"clientName\x12\x18\n" +
							 | 
						|
									"\amessage\x18\x05 \x01(\tR\amessage\"M\n" +
							 | 
						|
									"\x17LeaseAdminTokenResponse\x12\x14\n" +
							 | 
						|
									"\x05token\x18\x01 \x01(\x03R\x05token\x12\x1c\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"lock_ts_ns\x18\x02 \x01(\x03R\blockTsNs\"\x8c\x01\n" +
							 | 
						|
									"\x18ReleaseAdminTokenRequest\x12%\n" +
							 | 
						|
									"\x0eprevious_token\x18\x01 \x01(\x03R\rpreviousToken\x12,\n" +
							 | 
						|
									"\x12previous_lock_time\x18\x02 \x01(\x03R\x10previousLockTime\x12\x1b\n" +
							 | 
						|
									"\tlock_name\x18\x03 \x01(\tR\blockName\"\x1b\n" +
							 | 
						|
									"\x19ReleaseAdminTokenResponse\"F\n" +
							 | 
						|
									"\vPingRequest\x12\x16\n" +
							 | 
						|
									"\x06target\x18\x01 \x01(\tR\x06target\x12\x1f\n" +
							 | 
						|
									"\vtarget_type\x18\x02 \x01(\tR\n" +
							 | 
						|
									"targetType\"z\n" +
							 | 
						|
									"\fPingResponse\x12\"\n" +
							 | 
						|
									"\rstart_time_ns\x18\x01 \x01(\x03R\vstartTimeNs\x12$\n" +
							 | 
						|
									"\x0eremote_time_ns\x18\x02 \x01(\x03R\fremoteTimeNs\x12 \n" +
							 | 
						|
									"\fstop_time_ns\x18\x03 \x01(\x03R\n" +
							 | 
						|
									"stopTimeNs\"V\n" +
							 | 
						|
									"\x14RaftAddServerRequest\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\tR\x02id\x12\x18\n" +
							 | 
						|
									"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x14\n" +
							 | 
						|
									"\x05voter\x18\x03 \x01(\bR\x05voter\"\x17\n" +
							 | 
						|
									"\x15RaftAddServerResponse\"?\n" +
							 | 
						|
									"\x17RaftRemoveServerRequest\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +
							 | 
						|
									"\x05force\x18\x02 \x01(\bR\x05force\"\x1a\n" +
							 | 
						|
									"\x18RaftRemoveServerResponse\"\x1f\n" +
							 | 
						|
									"\x1dRaftListClusterServersRequest\"\xf7\x01\n" +
							 | 
						|
									"\x1eRaftListClusterServersResponse\x12a\n" +
							 | 
						|
									"\x0fcluster_servers\x18\x01 \x03(\v28.master_pb.RaftListClusterServersResponse.ClusterServersR\x0eclusterServers\x1ar\n" +
							 | 
						|
									"\x0eClusterServers\x12\x0e\n" +
							 | 
						|
									"\x02id\x18\x01 \x01(\tR\x02id\x12\x18\n" +
							 | 
						|
									"\aaddress\x18\x02 \x01(\tR\aaddress\x12\x1a\n" +
							 | 
						|
									"\bsuffrage\x18\x03 \x01(\tR\bsuffrage\x12\x1a\n" +
							 | 
						|
									"\bisLeader\x18\x04 \x01(\bR\bisLeader\"\x14\n" +
							 | 
						|
									"\x12VolumeGrowResponse2\xd5\x0f\n" +
							 | 
						|
									"\aSeaweed\x12I\n" +
							 | 
						|
									"\rSendHeartbeat\x12\x14.master_pb.Heartbeat\x1a\x1c.master_pb.HeartbeatResponse\"\x00(\x010\x01\x12X\n" +
							 | 
						|
									"\rKeepConnected\x12\x1f.master_pb.KeepConnectedRequest\x1a .master_pb.KeepConnectedResponse\"\x00(\x010\x01\x12Q\n" +
							 | 
						|
									"\fLookupVolume\x12\x1e.master_pb.LookupVolumeRequest\x1a\x1f.master_pb.LookupVolumeResponse\"\x00\x12?\n" +
							 | 
						|
									"\x06Assign\x12\x18.master_pb.AssignRequest\x1a\x19.master_pb.AssignResponse\"\x00\x12I\n" +
							 | 
						|
									"\fStreamAssign\x12\x18.master_pb.AssignRequest\x1a\x19.master_pb.AssignResponse\"\x00(\x010\x01\x12K\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"Statistics\x12\x1c.master_pb.StatisticsRequest\x1a\x1d.master_pb.StatisticsResponse\"\x00\x12W\n" +
							 | 
						|
									"\x0eCollectionList\x12 .master_pb.CollectionListRequest\x1a!.master_pb.CollectionListResponse\"\x00\x12]\n" +
							 | 
						|
									"\x10CollectionDelete\x12\".master_pb.CollectionDeleteRequest\x1a#.master_pb.CollectionDeleteResponse\"\x00\x12K\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"VolumeList\x12\x1c.master_pb.VolumeListRequest\x1a\x1d.master_pb.VolumeListResponse\"\x00\x12W\n" +
							 | 
						|
									"\x0eLookupEcVolume\x12 .master_pb.LookupEcVolumeRequest\x1a!.master_pb.LookupEcVolumeResponse\"\x00\x12Q\n" +
							 | 
						|
									"\fVacuumVolume\x12\x1e.master_pb.VacuumVolumeRequest\x1a\x1f.master_pb.VacuumVolumeResponse\"\x00\x12T\n" +
							 | 
						|
									"\rDisableVacuum\x12\x1f.master_pb.DisableVacuumRequest\x1a .master_pb.DisableVacuumResponse\"\x00\x12Q\n" +
							 | 
						|
									"\fEnableVacuum\x12\x1e.master_pb.EnableVacuumRequest\x1a\x1f.master_pb.EnableVacuumResponse\"\x00\x12c\n" +
							 | 
						|
									"\x12VolumeMarkReadonly\x12$.master_pb.VolumeMarkReadonlyRequest\x1a%.master_pb.VolumeMarkReadonlyResponse\"\x00\x12o\n" +
							 | 
						|
									"\x16GetMasterConfiguration\x12(.master_pb.GetMasterConfigurationRequest\x1a).master_pb.GetMasterConfigurationResponse\"\x00\x12]\n" +
							 | 
						|
									"\x10ListClusterNodes\x12\".master_pb.ListClusterNodesRequest\x1a#.master_pb.ListClusterNodesResponse\"\x00\x12Z\n" +
							 | 
						|
									"\x0fLeaseAdminToken\x12!.master_pb.LeaseAdminTokenRequest\x1a\".master_pb.LeaseAdminTokenResponse\"\x00\x12`\n" +
							 | 
						|
									"\x11ReleaseAdminToken\x12#.master_pb.ReleaseAdminTokenRequest\x1a$.master_pb.ReleaseAdminTokenResponse\"\x00\x129\n" +
							 | 
						|
									"\x04Ping\x12\x16.master_pb.PingRequest\x1a\x17.master_pb.PingResponse\"\x00\x12o\n" +
							 | 
						|
									"\x16RaftListClusterServers\x12(.master_pb.RaftListClusterServersRequest\x1a).master_pb.RaftListClusterServersResponse\"\x00\x12T\n" +
							 | 
						|
									"\rRaftAddServer\x12\x1f.master_pb.RaftAddServerRequest\x1a .master_pb.RaftAddServerResponse\"\x00\x12]\n" +
							 | 
						|
									"\x10RaftRemoveServer\x12\".master_pb.RaftRemoveServerRequest\x1a#.master_pb.RaftRemoveServerResponse\"\x00\x12K\n" +
							 | 
						|
									"\n" +
							 | 
						|
									"VolumeGrow\x12\x1c.master_pb.VolumeGrowRequest\x1a\x1d.master_pb.VolumeGrowResponse\"\x00B2Z0github.com/seaweedfs/seaweedfs/weed/pb/master_pbb\x06proto3"
							 | 
						|
								
							 | 
						|
								var (
							 | 
						|
									file_master_proto_rawDescOnce sync.Once
							 | 
						|
									file_master_proto_rawDescData []byte
							 | 
						|
								)
							 | 
						|
								
							 | 
						|
								func file_master_proto_rawDescGZIP() []byte {
							 | 
						|
									file_master_proto_rawDescOnce.Do(func() {
							 | 
						|
										file_master_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_master_proto_rawDesc), len(file_master_proto_rawDesc)))
							 | 
						|
									})
							 | 
						|
									return file_master_proto_rawDescData
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								var file_master_proto_msgTypes = make([]protoimpl.MessageInfo, 70)
							 | 
						|
								var file_master_proto_goTypes = []any{
							 | 
						|
									(*Heartbeat)(nil),                             // 0: master_pb.Heartbeat
							 | 
						|
									(*HeartbeatResponse)(nil),                     // 1: master_pb.HeartbeatResponse
							 | 
						|
									(*VolumeInformationMessage)(nil),              // 2: master_pb.VolumeInformationMessage
							 | 
						|
									(*VolumeShortInformationMessage)(nil),         // 3: master_pb.VolumeShortInformationMessage
							 | 
						|
									(*VolumeEcShardInformationMessage)(nil),       // 4: master_pb.VolumeEcShardInformationMessage
							 | 
						|
									(*StorageBackend)(nil),                        // 5: master_pb.StorageBackend
							 | 
						|
									(*Empty)(nil),                                 // 6: master_pb.Empty
							 | 
						|
									(*SuperBlockExtra)(nil),                       // 7: master_pb.SuperBlockExtra
							 | 
						|
									(*KeepConnectedRequest)(nil),                  // 8: master_pb.KeepConnectedRequest
							 | 
						|
									(*VolumeLocation)(nil),                        // 9: master_pb.VolumeLocation
							 | 
						|
									(*ClusterNodeUpdate)(nil),                     // 10: master_pb.ClusterNodeUpdate
							 | 
						|
									(*KeepConnectedResponse)(nil),                 // 11: master_pb.KeepConnectedResponse
							 | 
						|
									(*LookupVolumeRequest)(nil),                   // 12: master_pb.LookupVolumeRequest
							 | 
						|
									(*LookupVolumeResponse)(nil),                  // 13: master_pb.LookupVolumeResponse
							 | 
						|
									(*Location)(nil),                              // 14: master_pb.Location
							 | 
						|
									(*AssignRequest)(nil),                         // 15: master_pb.AssignRequest
							 | 
						|
									(*VolumeGrowRequest)(nil),                     // 16: master_pb.VolumeGrowRequest
							 | 
						|
									(*AssignResponse)(nil),                        // 17: master_pb.AssignResponse
							 | 
						|
									(*StatisticsRequest)(nil),                     // 18: master_pb.StatisticsRequest
							 | 
						|
									(*StatisticsResponse)(nil),                    // 19: master_pb.StatisticsResponse
							 | 
						|
									(*Collection)(nil),                            // 20: master_pb.Collection
							 | 
						|
									(*CollectionListRequest)(nil),                 // 21: master_pb.CollectionListRequest
							 | 
						|
									(*CollectionListResponse)(nil),                // 22: master_pb.CollectionListResponse
							 | 
						|
									(*CollectionDeleteRequest)(nil),               // 23: master_pb.CollectionDeleteRequest
							 | 
						|
									(*CollectionDeleteResponse)(nil),              // 24: master_pb.CollectionDeleteResponse
							 | 
						|
									(*DiskInfo)(nil),                              // 25: master_pb.DiskInfo
							 | 
						|
									(*DataNodeInfo)(nil),                          // 26: master_pb.DataNodeInfo
							 | 
						|
									(*RackInfo)(nil),                              // 27: master_pb.RackInfo
							 | 
						|
									(*DataCenterInfo)(nil),                        // 28: master_pb.DataCenterInfo
							 | 
						|
									(*TopologyInfo)(nil),                          // 29: master_pb.TopologyInfo
							 | 
						|
									(*VolumeListRequest)(nil),                     // 30: master_pb.VolumeListRequest
							 | 
						|
									(*VolumeListResponse)(nil),                    // 31: master_pb.VolumeListResponse
							 | 
						|
									(*LookupEcVolumeRequest)(nil),                 // 32: master_pb.LookupEcVolumeRequest
							 | 
						|
									(*LookupEcVolumeResponse)(nil),                // 33: master_pb.LookupEcVolumeResponse
							 | 
						|
									(*VacuumVolumeRequest)(nil),                   // 34: master_pb.VacuumVolumeRequest
							 | 
						|
									(*VacuumVolumeResponse)(nil),                  // 35: master_pb.VacuumVolumeResponse
							 | 
						|
									(*DisableVacuumRequest)(nil),                  // 36: master_pb.DisableVacuumRequest
							 | 
						|
									(*DisableVacuumResponse)(nil),                 // 37: master_pb.DisableVacuumResponse
							 | 
						|
									(*EnableVacuumRequest)(nil),                   // 38: master_pb.EnableVacuumRequest
							 | 
						|
									(*EnableVacuumResponse)(nil),                  // 39: master_pb.EnableVacuumResponse
							 | 
						|
									(*VolumeMarkReadonlyRequest)(nil),             // 40: master_pb.VolumeMarkReadonlyRequest
							 | 
						|
									(*VolumeMarkReadonlyResponse)(nil),            // 41: master_pb.VolumeMarkReadonlyResponse
							 | 
						|
									(*GetMasterConfigurationRequest)(nil),         // 42: master_pb.GetMasterConfigurationRequest
							 | 
						|
									(*GetMasterConfigurationResponse)(nil),        // 43: master_pb.GetMasterConfigurationResponse
							 | 
						|
									(*ListClusterNodesRequest)(nil),               // 44: master_pb.ListClusterNodesRequest
							 | 
						|
									(*ListClusterNodesResponse)(nil),              // 45: master_pb.ListClusterNodesResponse
							 | 
						|
									(*LeaseAdminTokenRequest)(nil),                // 46: master_pb.LeaseAdminTokenRequest
							 | 
						|
									(*LeaseAdminTokenResponse)(nil),               // 47: master_pb.LeaseAdminTokenResponse
							 | 
						|
									(*ReleaseAdminTokenRequest)(nil),              // 48: master_pb.ReleaseAdminTokenRequest
							 | 
						|
									(*ReleaseAdminTokenResponse)(nil),             // 49: master_pb.ReleaseAdminTokenResponse
							 | 
						|
									(*PingRequest)(nil),                           // 50: master_pb.PingRequest
							 | 
						|
									(*PingResponse)(nil),                          // 51: master_pb.PingResponse
							 | 
						|
									(*RaftAddServerRequest)(nil),                  // 52: master_pb.RaftAddServerRequest
							 | 
						|
									(*RaftAddServerResponse)(nil),                 // 53: master_pb.RaftAddServerResponse
							 | 
						|
									(*RaftRemoveServerRequest)(nil),               // 54: master_pb.RaftRemoveServerRequest
							 | 
						|
									(*RaftRemoveServerResponse)(nil),              // 55: master_pb.RaftRemoveServerResponse
							 | 
						|
									(*RaftListClusterServersRequest)(nil),         // 56: master_pb.RaftListClusterServersRequest
							 | 
						|
									(*RaftListClusterServersResponse)(nil),        // 57: master_pb.RaftListClusterServersResponse
							 | 
						|
									(*VolumeGrowResponse)(nil),                    // 58: master_pb.VolumeGrowResponse
							 | 
						|
									nil,                                           // 59: master_pb.Heartbeat.MaxVolumeCountsEntry
							 | 
						|
									nil,                                           // 60: master_pb.StorageBackend.PropertiesEntry
							 | 
						|
									(*SuperBlockExtra_ErasureCoding)(nil),         // 61: master_pb.SuperBlockExtra.ErasureCoding
							 | 
						|
									(*LookupVolumeResponse_VolumeIdLocation)(nil), // 62: master_pb.LookupVolumeResponse.VolumeIdLocation
							 | 
						|
									nil, // 63: master_pb.DataNodeInfo.DiskInfosEntry
							 | 
						|
									nil, // 64: master_pb.RackInfo.DiskInfosEntry
							 | 
						|
									nil, // 65: master_pb.DataCenterInfo.DiskInfosEntry
							 | 
						|
									nil, // 66: master_pb.TopologyInfo.DiskInfosEntry
							 | 
						|
									(*LookupEcVolumeResponse_EcShardIdLocation)(nil),      // 67: master_pb.LookupEcVolumeResponse.EcShardIdLocation
							 | 
						|
									(*ListClusterNodesResponse_ClusterNode)(nil),          // 68: master_pb.ListClusterNodesResponse.ClusterNode
							 | 
						|
									(*RaftListClusterServersResponse_ClusterServers)(nil), // 69: master_pb.RaftListClusterServersResponse.ClusterServers
							 | 
						|
								}
							 | 
						|
								var file_master_proto_depIdxs = []int32{
							 | 
						|
									2,  // 0: master_pb.Heartbeat.volumes:type_name -> master_pb.VolumeInformationMessage
							 | 
						|
									3,  // 1: master_pb.Heartbeat.new_volumes:type_name -> master_pb.VolumeShortInformationMessage
							 | 
						|
									3,  // 2: master_pb.Heartbeat.deleted_volumes:type_name -> master_pb.VolumeShortInformationMessage
							 | 
						|
									4,  // 3: master_pb.Heartbeat.ec_shards:type_name -> master_pb.VolumeEcShardInformationMessage
							 | 
						|
									4,  // 4: master_pb.Heartbeat.new_ec_shards:type_name -> master_pb.VolumeEcShardInformationMessage
							 | 
						|
									4,  // 5: master_pb.Heartbeat.deleted_ec_shards:type_name -> master_pb.VolumeEcShardInformationMessage
							 | 
						|
									59, // 6: master_pb.Heartbeat.max_volume_counts:type_name -> master_pb.Heartbeat.MaxVolumeCountsEntry
							 | 
						|
									5,  // 7: master_pb.HeartbeatResponse.storage_backends:type_name -> master_pb.StorageBackend
							 | 
						|
									60, // 8: master_pb.StorageBackend.properties:type_name -> master_pb.StorageBackend.PropertiesEntry
							 | 
						|
									61, // 9: master_pb.SuperBlockExtra.erasure_coding:type_name -> master_pb.SuperBlockExtra.ErasureCoding
							 | 
						|
									9,  // 10: master_pb.KeepConnectedResponse.volume_location:type_name -> master_pb.VolumeLocation
							 | 
						|
									10, // 11: master_pb.KeepConnectedResponse.cluster_node_update:type_name -> master_pb.ClusterNodeUpdate
							 | 
						|
									62, // 12: master_pb.LookupVolumeResponse.volume_id_locations:type_name -> master_pb.LookupVolumeResponse.VolumeIdLocation
							 | 
						|
									14, // 13: master_pb.AssignResponse.replicas:type_name -> master_pb.Location
							 | 
						|
									14, // 14: master_pb.AssignResponse.location:type_name -> master_pb.Location
							 | 
						|
									20, // 15: master_pb.CollectionListResponse.collections:type_name -> master_pb.Collection
							 | 
						|
									2,  // 16: master_pb.DiskInfo.volume_infos:type_name -> master_pb.VolumeInformationMessage
							 | 
						|
									4,  // 17: master_pb.DiskInfo.ec_shard_infos:type_name -> master_pb.VolumeEcShardInformationMessage
							 | 
						|
									63, // 18: master_pb.DataNodeInfo.diskInfos:type_name -> master_pb.DataNodeInfo.DiskInfosEntry
							 | 
						|
									26, // 19: master_pb.RackInfo.data_node_infos:type_name -> master_pb.DataNodeInfo
							 | 
						|
									64, // 20: master_pb.RackInfo.diskInfos:type_name -> master_pb.RackInfo.DiskInfosEntry
							 | 
						|
									27, // 21: master_pb.DataCenterInfo.rack_infos:type_name -> master_pb.RackInfo
							 | 
						|
									65, // 22: master_pb.DataCenterInfo.diskInfos:type_name -> master_pb.DataCenterInfo.DiskInfosEntry
							 | 
						|
									28, // 23: master_pb.TopologyInfo.data_center_infos:type_name -> master_pb.DataCenterInfo
							 | 
						|
									66, // 24: master_pb.TopologyInfo.diskInfos:type_name -> master_pb.TopologyInfo.DiskInfosEntry
							 | 
						|
									29, // 25: master_pb.VolumeListResponse.topology_info:type_name -> master_pb.TopologyInfo
							 | 
						|
									67, // 26: master_pb.LookupEcVolumeResponse.shard_id_locations:type_name -> master_pb.LookupEcVolumeResponse.EcShardIdLocation
							 | 
						|
									5,  // 27: master_pb.GetMasterConfigurationResponse.storage_backends:type_name -> master_pb.StorageBackend
							 | 
						|
									68, // 28: master_pb.ListClusterNodesResponse.cluster_nodes:type_name -> master_pb.ListClusterNodesResponse.ClusterNode
							 | 
						|
									69, // 29: master_pb.RaftListClusterServersResponse.cluster_servers:type_name -> master_pb.RaftListClusterServersResponse.ClusterServers
							 | 
						|
									14, // 30: master_pb.LookupVolumeResponse.VolumeIdLocation.locations:type_name -> master_pb.Location
							 | 
						|
									25, // 31: master_pb.DataNodeInfo.DiskInfosEntry.value:type_name -> master_pb.DiskInfo
							 | 
						|
									25, // 32: master_pb.RackInfo.DiskInfosEntry.value:type_name -> master_pb.DiskInfo
							 | 
						|
									25, // 33: master_pb.DataCenterInfo.DiskInfosEntry.value:type_name -> master_pb.DiskInfo
							 | 
						|
									25, // 34: master_pb.TopologyInfo.DiskInfosEntry.value:type_name -> master_pb.DiskInfo
							 | 
						|
									14, // 35: master_pb.LookupEcVolumeResponse.EcShardIdLocation.locations:type_name -> master_pb.Location
							 | 
						|
									0,  // 36: master_pb.Seaweed.SendHeartbeat:input_type -> master_pb.Heartbeat
							 | 
						|
									8,  // 37: master_pb.Seaweed.KeepConnected:input_type -> master_pb.KeepConnectedRequest
							 | 
						|
									12, // 38: master_pb.Seaweed.LookupVolume:input_type -> master_pb.LookupVolumeRequest
							 | 
						|
									15, // 39: master_pb.Seaweed.Assign:input_type -> master_pb.AssignRequest
							 | 
						|
									15, // 40: master_pb.Seaweed.StreamAssign:input_type -> master_pb.AssignRequest
							 | 
						|
									18, // 41: master_pb.Seaweed.Statistics:input_type -> master_pb.StatisticsRequest
							 | 
						|
									21, // 42: master_pb.Seaweed.CollectionList:input_type -> master_pb.CollectionListRequest
							 | 
						|
									23, // 43: master_pb.Seaweed.CollectionDelete:input_type -> master_pb.CollectionDeleteRequest
							 | 
						|
									30, // 44: master_pb.Seaweed.VolumeList:input_type -> master_pb.VolumeListRequest
							 | 
						|
									32, // 45: master_pb.Seaweed.LookupEcVolume:input_type -> master_pb.LookupEcVolumeRequest
							 | 
						|
									34, // 46: master_pb.Seaweed.VacuumVolume:input_type -> master_pb.VacuumVolumeRequest
							 | 
						|
									36, // 47: master_pb.Seaweed.DisableVacuum:input_type -> master_pb.DisableVacuumRequest
							 | 
						|
									38, // 48: master_pb.Seaweed.EnableVacuum:input_type -> master_pb.EnableVacuumRequest
							 | 
						|
									40, // 49: master_pb.Seaweed.VolumeMarkReadonly:input_type -> master_pb.VolumeMarkReadonlyRequest
							 | 
						|
									42, // 50: master_pb.Seaweed.GetMasterConfiguration:input_type -> master_pb.GetMasterConfigurationRequest
							 | 
						|
									44, // 51: master_pb.Seaweed.ListClusterNodes:input_type -> master_pb.ListClusterNodesRequest
							 | 
						|
									46, // 52: master_pb.Seaweed.LeaseAdminToken:input_type -> master_pb.LeaseAdminTokenRequest
							 | 
						|
									48, // 53: master_pb.Seaweed.ReleaseAdminToken:input_type -> master_pb.ReleaseAdminTokenRequest
							 | 
						|
									50, // 54: master_pb.Seaweed.Ping:input_type -> master_pb.PingRequest
							 | 
						|
									56, // 55: master_pb.Seaweed.RaftListClusterServers:input_type -> master_pb.RaftListClusterServersRequest
							 | 
						|
									52, // 56: master_pb.Seaweed.RaftAddServer:input_type -> master_pb.RaftAddServerRequest
							 | 
						|
									54, // 57: master_pb.Seaweed.RaftRemoveServer:input_type -> master_pb.RaftRemoveServerRequest
							 | 
						|
									16, // 58: master_pb.Seaweed.VolumeGrow:input_type -> master_pb.VolumeGrowRequest
							 | 
						|
									1,  // 59: master_pb.Seaweed.SendHeartbeat:output_type -> master_pb.HeartbeatResponse
							 | 
						|
									11, // 60: master_pb.Seaweed.KeepConnected:output_type -> master_pb.KeepConnectedResponse
							 | 
						|
									13, // 61: master_pb.Seaweed.LookupVolume:output_type -> master_pb.LookupVolumeResponse
							 | 
						|
									17, // 62: master_pb.Seaweed.Assign:output_type -> master_pb.AssignResponse
							 | 
						|
									17, // 63: master_pb.Seaweed.StreamAssign:output_type -> master_pb.AssignResponse
							 | 
						|
									19, // 64: master_pb.Seaweed.Statistics:output_type -> master_pb.StatisticsResponse
							 | 
						|
									22, // 65: master_pb.Seaweed.CollectionList:output_type -> master_pb.CollectionListResponse
							 | 
						|
									24, // 66: master_pb.Seaweed.CollectionDelete:output_type -> master_pb.CollectionDeleteResponse
							 | 
						|
									31, // 67: master_pb.Seaweed.VolumeList:output_type -> master_pb.VolumeListResponse
							 | 
						|
									33, // 68: master_pb.Seaweed.LookupEcVolume:output_type -> master_pb.LookupEcVolumeResponse
							 | 
						|
									35, // 69: master_pb.Seaweed.VacuumVolume:output_type -> master_pb.VacuumVolumeResponse
							 | 
						|
									37, // 70: master_pb.Seaweed.DisableVacuum:output_type -> master_pb.DisableVacuumResponse
							 | 
						|
									39, // 71: master_pb.Seaweed.EnableVacuum:output_type -> master_pb.EnableVacuumResponse
							 | 
						|
									41, // 72: master_pb.Seaweed.VolumeMarkReadonly:output_type -> master_pb.VolumeMarkReadonlyResponse
							 | 
						|
									43, // 73: master_pb.Seaweed.GetMasterConfiguration:output_type -> master_pb.GetMasterConfigurationResponse
							 | 
						|
									45, // 74: master_pb.Seaweed.ListClusterNodes:output_type -> master_pb.ListClusterNodesResponse
							 | 
						|
									47, // 75: master_pb.Seaweed.LeaseAdminToken:output_type -> master_pb.LeaseAdminTokenResponse
							 | 
						|
									49, // 76: master_pb.Seaweed.ReleaseAdminToken:output_type -> master_pb.ReleaseAdminTokenResponse
							 | 
						|
									51, // 77: master_pb.Seaweed.Ping:output_type -> master_pb.PingResponse
							 | 
						|
									57, // 78: master_pb.Seaweed.RaftListClusterServers:output_type -> master_pb.RaftListClusterServersResponse
							 | 
						|
									53, // 79: master_pb.Seaweed.RaftAddServer:output_type -> master_pb.RaftAddServerResponse
							 | 
						|
									55, // 80: master_pb.Seaweed.RaftRemoveServer:output_type -> master_pb.RaftRemoveServerResponse
							 | 
						|
									58, // 81: master_pb.Seaweed.VolumeGrow:output_type -> master_pb.VolumeGrowResponse
							 | 
						|
									59, // [59:82] is the sub-list for method output_type
							 | 
						|
									36, // [36:59] is the sub-list for method input_type
							 | 
						|
									36, // [36:36] is the sub-list for extension type_name
							 | 
						|
									36, // [36:36] is the sub-list for extension extendee
							 | 
						|
									0,  // [0:36] is the sub-list for field type_name
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								func init() { file_master_proto_init() }
							 | 
						|
								func file_master_proto_init() {
							 | 
						|
									if File_master_proto != nil {
							 | 
						|
										return
							 | 
						|
									}
							 | 
						|
									type x struct{}
							 | 
						|
									out := protoimpl.TypeBuilder{
							 | 
						|
										File: protoimpl.DescBuilder{
							 | 
						|
											GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
							 | 
						|
											RawDescriptor: unsafe.Slice(unsafe.StringData(file_master_proto_rawDesc), len(file_master_proto_rawDesc)),
							 | 
						|
											NumEnums:      0,
							 | 
						|
											NumMessages:   70,
							 | 
						|
											NumExtensions: 0,
							 | 
						|
											NumServices:   1,
							 | 
						|
										},
							 | 
						|
										GoTypes:           file_master_proto_goTypes,
							 | 
						|
										DependencyIndexes: file_master_proto_depIdxs,
							 | 
						|
										MessageInfos:      file_master_proto_msgTypes,
							 | 
						|
									}.Build()
							 | 
						|
									File_master_proto = out.File
							 | 
						|
									file_master_proto_goTypes = nil
							 | 
						|
									file_master_proto_depIdxs = nil
							 | 
						|
								}
							 |