gitlab-com-seaweedfs/seaweedfs
1
0
Fork 0
mirror of https://github.com/seaweedfs/seaweedfs.git synced 2024-01-19 02:48:24 +00:00
Code Issues Projects Releases Wiki Activity

refactoring

Browse source
This commit is contained in:
Chris Lu 2019-04-17 22:04:49 -07:00
parent 3b9446606a
commit 13ad5c1966
8 changed files with 162 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
weed/command/backup.go
View file

@ -113,7 +113,7 @@ func runBackup(cmd *Command, args []string) bool {
}
defer v.Close()
if err := v.Follow(volumeServer, grpcDialOption); err != nil {
if err := v.IncrementalBackup(volumeServer, grpcDialOption); err != nil {
fmt.Printf("Error synchronizing volume %d: %v\n", vid, err)
return true
}

13
weed/pb/volume_server.proto
View file

@ -24,7 +24,7 @@ service VolumeServer {
rpc VolumeSyncStatus (VolumeSyncStatusRequest) returns (VolumeSyncStatusResponse) {
}
rpc VolumeFollow (VolumeFollowRequest) returns (stream VolumeFollowResponse) {
rpc VolumeIncrementalCopy (VolumeIncrementalCopyRequest) returns (stream VolumeIncrementalCopyResponse) {
}
rpc VolumeMount (VolumeMountRequest) returns (VolumeMountResponse) {
@ -34,7 +34,8 @@ service VolumeServer {
rpc VolumeDelete (VolumeDeleteRequest) returns (VolumeDeleteResponse) {
}
rpc ReplicateVolume (ReplicateVolumeRequest) returns (ReplicateVolumeResponse) {
// copy the .idx .dat files, and mount this volume
rpc VolumeCopy (VolumeCopyRequest) returns (VolumeCopyResponse) {
}
rpc ReadVolumeFileStatus (ReadVolumeFileStatusRequest) returns (ReadVolumeFileStatusResponse) {
}
@ -117,11 +118,11 @@ message VolumeSyncStatusResponse {
uint64 idx_file_size = 8;
}
message VolumeFollowRequest {
message VolumeIncrementalCopyRequest {
uint32 volume_id = 1;
uint64 since = 2;
}
message VolumeFollowResponse {
message VolumeIncrementalCopyResponse {
bytes file_content = 1;
}
@ -143,14 +144,14 @@ message VolumeDeleteRequest {
message VolumeDeleteResponse {
}
message ReplicateVolumeRequest {
message VolumeCopyRequest {
uint32 volume_id = 1;
string collection = 2;
string replication = 3;
string ttl = 4;
string source_data_node = 5;
}
message ReplicateVolumeResponse {
message VolumeCopyResponse {
}
message CopyFileRequest {

287
weed/pb/volume_server_pb/volume_server.pb.go
View file

@ -27,16 +27,16 @@ It has these top-level messages:
AllocateVolumeResponse
VolumeSyncStatusRequest
VolumeSyncStatusResponse
VolumeFollowRequest
VolumeFollowResponse
VolumeIncrementalCopyRequest
VolumeIncrementalCopyResponse
VolumeMountRequest
VolumeMountResponse
VolumeUnmountRequest
VolumeUnmountResponse
VolumeDeleteRequest
VolumeDeleteResponse
ReplicateVolumeRequest
ReplicateVolumeResponse
VolumeCopyRequest
VolumeCopyResponse
CopyFileRequest
CopyFileResponse
ReadVolumeFileStatusRequest
@ -418,40 +418,40 @@ func (m *VolumeSyncStatusResponse) GetIdxFileSize() uint64 {
return 0
}
type VolumeFollowRequest struct {
type VolumeIncrementalCopyRequest struct {
VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
Since uint64 `protobuf:"varint,2,opt,name=since" json:"since,omitempty"`
}
func (m *VolumeFollowRequest) Reset() { *m = VolumeFollowRequest{} }
func (m *VolumeFollowRequest) String() string { return proto.CompactTextString(m) }
func (*VolumeFollowRequest) ProtoMessage() {}
func (*VolumeFollowRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
func (m *VolumeIncrementalCopyRequest) Reset() { *m = VolumeIncrementalCopyRequest{} }
func (m *VolumeIncrementalCopyRequest) String() string { return proto.CompactTextString(m) }
func (*VolumeIncrementalCopyRequest) ProtoMessage() {}
func (*VolumeIncrementalCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
func (m *VolumeFollowRequest) GetVolumeId() uint32 {
func (m *VolumeIncrementalCopyRequest) GetVolumeId() uint32 {
if m != nil {
return m.VolumeId
}
return 0
}
func (m *VolumeFollowRequest) GetSince() uint64 {
func (m *VolumeIncrementalCopyRequest) GetSince() uint64 {
if m != nil {
return m.Since
}
return 0
}
type VolumeFollowResponse struct {
type VolumeIncrementalCopyResponse struct {
FileContent []byte `protobuf:"bytes,1,opt,name=file_content,json=fileContent,proto3" json:"file_content,omitempty"`
}
func (m *VolumeFollowResponse) Reset() { *m = VolumeFollowResponse{} }
func (m *VolumeFollowResponse) String() string { return proto.CompactTextString(m) }
func (*VolumeFollowResponse) ProtoMessage() {}
func (*VolumeFollowResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
func (m *VolumeIncrementalCopyResponse) Reset() { *m = VolumeIncrementalCopyResponse{} }
func (m *VolumeIncrementalCopyResponse) String() string { return proto.CompactTextString(m) }
func (*VolumeIncrementalCopyResponse) ProtoMessage() {}
func (*VolumeIncrementalCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
func (m *VolumeFollowResponse) GetFileContent() []byte {
func (m *VolumeIncrementalCopyResponse) GetFileContent() []byte {
if m != nil {
return m.FileContent
}
@ -530,7 +530,7 @@ func (m *VolumeDeleteResponse) String() string { return proto.Compact
func (*VolumeDeleteResponse) ProtoMessage() {}
func (*VolumeDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
type ReplicateVolumeRequest struct {
type VolumeCopyRequest struct {
VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
Collection string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
Replication string `protobuf:"bytes,3,opt,name=replication" json:"replication,omitempty"`
@ -538,53 +538,53 @@ type ReplicateVolumeRequest struct {
SourceDataNode string `protobuf:"bytes,5,opt,name=source_data_node,json=sourceDataNode" json:"source_data_node,omitempty"`
}
func (m *ReplicateVolumeRequest) Reset() { *m = ReplicateVolumeRequest{} }
func (m *ReplicateVolumeRequest) String() string { return proto.CompactTextString(m) }
func (*ReplicateVolumeRequest) ProtoMessage() {}
func (*ReplicateVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
func (m *VolumeCopyRequest) Reset() { *m = VolumeCopyRequest{} }
func (m *VolumeCopyRequest) String() string { return proto.CompactTextString(m) }
func (*VolumeCopyRequest) ProtoMessage() {}
func (*VolumeCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
func (m *ReplicateVolumeRequest) GetVolumeId() uint32 {
func (m *VolumeCopyRequest) GetVolumeId() uint32 {
if m != nil {
return m.VolumeId
}
return 0
}
func (m *ReplicateVolumeRequest) GetCollection() string {
func (m *VolumeCopyRequest) GetCollection() string {
if m != nil {
return m.Collection
}
return ""
}
func (m *ReplicateVolumeRequest) GetReplication() string {
func (m *VolumeCopyRequest) GetReplication() string {
if m != nil {
return m.Replication
}
return ""
}
func (m *ReplicateVolumeRequest) GetTtl() string {
func (m *VolumeCopyRequest) GetTtl() string {
if m != nil {
return m.Ttl
}
return ""
}
func (m *ReplicateVolumeRequest) GetSourceDataNode() string {
func (m *VolumeCopyRequest) GetSourceDataNode() string {
if m != nil {
return m.SourceDataNode
}
return ""
}
type ReplicateVolumeResponse struct {
type VolumeCopyResponse struct {
}
func (m *ReplicateVolumeResponse) Reset() { *m = ReplicateVolumeResponse{} }
func (m *ReplicateVolumeResponse) String() string { return proto.CompactTextString(m) }
func (*ReplicateVolumeResponse) ProtoMessage() {}
func (*ReplicateVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
func (m *VolumeCopyResponse) Reset() { *m = VolumeCopyResponse{} }
func (m *VolumeCopyResponse) String() string { return proto.CompactTextString(m) }
func (*VolumeCopyResponse) ProtoMessage() {}
func (*VolumeCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
type CopyFileRequest struct {
VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@ -829,16 +829,16 @@ func init() {
proto.RegisterType((*AllocateVolumeResponse)(nil), "volume_server_pb.AllocateVolumeResponse")
proto.RegisterType((*VolumeSyncStatusRequest)(nil), "volume_server_pb.VolumeSyncStatusRequest")
proto.RegisterType((*VolumeSyncStatusResponse)(nil), "volume_server_pb.VolumeSyncStatusResponse")
proto.RegisterType((*VolumeFollowRequest)(nil), "volume_server_pb.VolumeFollowRequest")
proto.RegisterType((*VolumeFollowResponse)(nil), "volume_server_pb.VolumeFollowResponse")
proto.RegisterType((*VolumeIncrementalCopyRequest)(nil), "volume_server_pb.VolumeIncrementalCopyRequest")
proto.RegisterType((*VolumeIncrementalCopyResponse)(nil), "volume_server_pb.VolumeIncrementalCopyResponse")
proto.RegisterType((*VolumeMountRequest)(nil), "volume_server_pb.VolumeMountRequest")
proto.RegisterType((*VolumeMountResponse)(nil), "volume_server_pb.VolumeMountResponse")
proto.RegisterType((*VolumeUnmountRequest)(nil), "volume_server_pb.VolumeUnmountRequest")
proto.RegisterType((*VolumeUnmountResponse)(nil), "volume_server_pb.VolumeUnmountResponse")
proto.RegisterType((*VolumeDeleteRequest)(nil), "volume_server_pb.VolumeDeleteRequest")
proto.RegisterType((*VolumeDeleteResponse)(nil), "volume_server_pb.VolumeDeleteResponse")
proto.RegisterType((*ReplicateVolumeRequest)(nil), "volume_server_pb.ReplicateVolumeRequest")
proto.RegisterType((*ReplicateVolumeResponse)(nil), "volume_server_pb.ReplicateVolumeResponse")
proto.RegisterType((*VolumeCopyRequest)(nil), "volume_server_pb.VolumeCopyRequest")
proto.RegisterType((*VolumeCopyResponse)(nil), "volume_server_pb.VolumeCopyResponse")
proto.RegisterType((*CopyFileRequest)(nil), "volume_server_pb.CopyFileRequest")
proto.RegisterType((*CopyFileResponse)(nil), "volume_server_pb.CopyFileResponse")
proto.RegisterType((*ReadVolumeFileStatusRequest)(nil), "volume_server_pb.ReadVolumeFileStatusRequest")
@ -867,11 +867,12 @@ type VolumeServerClient interface {
DeleteCollection(ctx context.Context, in *DeleteCollectionRequest, opts ...grpc.CallOption) (*DeleteCollectionResponse, error)
AllocateVolume(ctx context.Context, in *AllocateVolumeRequest, opts ...grpc.CallOption) (*AllocateVolumeResponse, error)
VolumeSyncStatus(ctx context.Context, in *VolumeSyncStatusRequest, opts ...grpc.CallOption) (*VolumeSyncStatusResponse, error)
VolumeFollow(ctx context.Context, in *VolumeFollowRequest, opts ...grpc.CallOption) (VolumeServer_VolumeFollowClient, error)
VolumeIncrementalCopy(ctx context.Context, in *VolumeIncrementalCopyRequest, opts ...grpc.CallOption) (VolumeServer_VolumeIncrementalCopyClient, error)
VolumeMount(ctx context.Context, in *VolumeMountRequest, opts ...grpc.CallOption) (*VolumeMountResponse, error)
VolumeUnmount(ctx context.Context, in *VolumeUnmountRequest, opts ...grpc.CallOption) (*VolumeUnmountResponse, error)
VolumeDelete(ctx context.Context, in *VolumeDeleteRequest, opts ...grpc.CallOption) (*VolumeDeleteResponse, error)
ReplicateVolume(ctx context.Context, in *ReplicateVolumeRequest, opts ...grpc.CallOption) (*ReplicateVolumeResponse, error)
// copy the .idx .dat files, and mount this volume
VolumeCopy(ctx context.Context, in *VolumeCopyRequest, opts ...grpc.CallOption) (*VolumeCopyResponse, error)
ReadVolumeFileStatus(ctx context.Context, in *ReadVolumeFileStatusRequest, opts ...grpc.CallOption) (*ReadVolumeFileStatusResponse, error)
CopyFile(ctx context.Context, in *CopyFileRequest, opts ...grpc.CallOption) (VolumeServer_CopyFileClient, error)
}
@ -956,12 +957,12 @@ func (c *volumeServerClient) VolumeSyncStatus(ctx context.Context, in *VolumeSyn
return out, nil
}
func (c *volumeServerClient) VolumeFollow(ctx context.Context, in *VolumeFollowRequest, opts ...grpc.CallOption) (VolumeServer_VolumeFollowClient, error) {
stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[0], c.cc, "/volume_server_pb.VolumeServer/VolumeFollow", opts...)
func (c *volumeServerClient) VolumeIncrementalCopy(ctx context.Context, in *VolumeIncrementalCopyRequest, opts ...grpc.CallOption) (VolumeServer_VolumeIncrementalCopyClient, error) {
stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[0], c.cc, "/volume_server_pb.VolumeServer/VolumeIncrementalCopy", opts...)
if err != nil {
return nil, err
}
x := &volumeServerVolumeFollowClient{stream}
x := &volumeServerVolumeIncrementalCopyClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@ -971,17 +972,17 @@ func (c *volumeServerClient) VolumeFollow(ctx context.Context, in *VolumeFollowR
return x, nil
}
type VolumeServer_VolumeFollowClient interface {
Recv() (*VolumeFollowResponse, error)
type VolumeServer_VolumeIncrementalCopyClient interface {
Recv() (*VolumeIncrementalCopyResponse, error)
grpc.ClientStream
}
type volumeServerVolumeFollowClient struct {
type volumeServerVolumeIncrementalCopyClient struct {
grpc.ClientStream
}
func (x *volumeServerVolumeFollowClient) Recv() (*VolumeFollowResponse, error) {
m := new(VolumeFollowResponse)
func (x *volumeServerVolumeIncrementalCopyClient) Recv() (*VolumeIncrementalCopyResponse, error) {
m := new(VolumeIncrementalCopyResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
@ -1015,9 +1016,9 @@ func (c *volumeServerClient) VolumeDelete(ctx context.Context, in *VolumeDeleteR
return out, nil
}
func (c *volumeServerClient) ReplicateVolume(ctx context.Context, in *ReplicateVolumeRequest, opts ...grpc.CallOption) (*ReplicateVolumeResponse, error) {
out := new(ReplicateVolumeResponse)
err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/ReplicateVolume", in, out, c.cc, opts...)
func (c *volumeServerClient) VolumeCopy(ctx context.Context, in *VolumeCopyRequest, opts ...grpc.CallOption) (*VolumeCopyResponse, error) {
out := new(VolumeCopyResponse)
err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VolumeCopy", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
@ -1077,11 +1078,12 @@ type VolumeServerServer interface {
DeleteCollection(context.Context, *DeleteCollectionRequest) (*DeleteCollectionResponse, error)
AllocateVolume(context.Context, *AllocateVolumeRequest) (*AllocateVolumeResponse, error)
VolumeSyncStatus(context.Context, *VolumeSyncStatusRequest) (*VolumeSyncStatusResponse, error)
VolumeFollow(*VolumeFollowRequest, VolumeServer_VolumeFollowServer) error
VolumeIncrementalCopy(*VolumeIncrementalCopyRequest, VolumeServer_VolumeIncrementalCopyServer) error
VolumeMount(context.Context, *VolumeMountRequest) (*VolumeMountResponse, error)
VolumeUnmount(context.Context, *VolumeUnmountRequest) (*VolumeUnmountResponse, error)
VolumeDelete(context.Context, *VolumeDeleteRequest) (*VolumeDeleteResponse, error)
ReplicateVolume(context.Context, *ReplicateVolumeRequest) (*ReplicateVolumeResponse, error)
// copy the .idx .dat files, and mount this volume
VolumeCopy(context.Context, *VolumeCopyRequest) (*VolumeCopyResponse, error)
ReadVolumeFileStatus(context.Context, *ReadVolumeFileStatusRequest) (*ReadVolumeFileStatusResponse, error)
CopyFile(*CopyFileRequest, VolumeServer_CopyFileServer) error
}
@ -1234,24 +1236,24 @@ func _VolumeServer_VolumeSyncStatus_Handler(srv interface{}, ctx context.Context
return interceptor(ctx, in, info, handler)
}
func _VolumeServer_VolumeFollow_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(VolumeFollowRequest)
func _VolumeServer_VolumeIncrementalCopy_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(VolumeIncrementalCopyRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(VolumeServerServer).VolumeFollow(m, &volumeServerVolumeFollowServer{stream})
return srv.(VolumeServerServer).VolumeIncrementalCopy(m, &volumeServerVolumeIncrementalCopyServer{stream})
}
type VolumeServer_VolumeFollowServer interface {
Send(*VolumeFollowResponse) error
type VolumeServer_VolumeIncrementalCopyServer interface {
Send(*VolumeIncrementalCopyResponse) error
grpc.ServerStream
}
type volumeServerVolumeFollowServer struct {
type volumeServerVolumeIncrementalCopyServer struct {
grpc.ServerStream
}
func (x *volumeServerVolumeFollowServer) Send(m *VolumeFollowResponse) error {
func (x *volumeServerVolumeIncrementalCopyServer) Send(m *VolumeIncrementalCopyResponse) error {
return x.ServerStream.SendMsg(m)
}
@ -1309,20 +1311,20 @@ func _VolumeServer_VolumeDelete_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
func _VolumeServer_ReplicateVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReplicateVolumeRequest)
func _VolumeServer_VolumeCopy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(VolumeCopyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(VolumeServerServer).ReplicateVolume(ctx, in)
return srv.(VolumeServerServer).VolumeCopy(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/volume_server_pb.VolumeServer/ReplicateVolume",
FullMethod: "/volume_server_pb.VolumeServer/VolumeCopy",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(VolumeServerServer).ReplicateVolume(ctx, req.(*ReplicateVolumeRequest))
return srv.(VolumeServerServer).VolumeCopy(ctx, req.(*VolumeCopyRequest))
}
return interceptor(ctx, in, info, handler)
}
@ -1415,8 +1417,8 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
Handler: _VolumeServer_VolumeDelete_Handler,
},
{
MethodName: "ReplicateVolume",
Handler: _VolumeServer_ReplicateVolume_Handler,
MethodName: "VolumeCopy",
Handler: _VolumeServer_VolumeCopy_Handler,
},
{
MethodName: "ReadVolumeFileStatus",
@ -1425,8 +1427,8 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
},
Streams: []grpc.StreamDesc{
{
StreamName: "VolumeFollow",
Handler: _VolumeServer_VolumeFollow_Handler,
StreamName: "VolumeIncrementalCopy",
Handler: _VolumeServer_VolumeIncrementalCopy_Handler,
ServerStreams: true,
},
{
@ -1441,79 +1443,80 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1183 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x5b, 0x73, 0xdb, 0xc4,
0x17, 0x8f, 0x6a, 0x3b, 0x89, 0x8f, 0x9d, 0xc6, 0xff, 0xcd, 0x4d, 0x51, 0xda, 0xfc, 0xdd, 0x85,
0xb4, 0x4e, 0x9b, 0x06, 0x48, 0x07, 0x68, 0x79, 0x02, 0x12, 0x3a, 0xe4, 0xa1, 0x74, 0x46, 0xa1,
0x1d, 0x66, 0x60, 0x46, 0xb3, 0x91, 0x36, 0x89, 0x26, 0xb2, 0x56, 0x95, 0x56, 0x69, 0xc3, 0xd7,
0xe1, 0x8d, 0x57, 0x5e, 0xf9, 0x66, 0xcc, 0x30, 0xcc, 0x5e, 0xa4, 0x58, 0x17, 0xd7, 0xe2, 0xf2,
0xb6, 0x3a, 0x7b, 0xce, 0xef, 0x5c, 0xf6, 0x9c, 0xdd, 0x9f, 0x0d, 0x2b, 0x57, 0x2c, 0x48, 0xc7,
0xd4, 0x49, 0x68, 0x7c, 0x45, 0xe3, 0xfd, 0x28, 0x66, 0x9c, 0xa1, 0x41, 0x41, 0xe8, 0x44, 0xa7,
0xf8, 0x23, 0x40, 0x5f, 0x13, 0xee, 0x5e, 0x1c, 0xd1, 0x80, 0x72, 0x6a, 0xd3, 0x37, 0x29, 0x4d,
0x38, 0xda, 0x84, 0xc5, 0x33, 0x3f, 0xa0, 0x8e, 0xef, 0x25, 0xa6, 0x31, 0x6c, 0x8d, 0xba, 0xf6,
0x82, 0xf8, 0x3e, 0xf6, 0x12, 0xfc, 0x12, 0x56, 0x0a, 0x06, 0x49, 0xc4, 0xc2, 0x84, 0xa2, 0xa7,
0xb0, 0x10, 0xd3, 0x24, 0x0d, 0xb8, 0x32, 0xe8, 0x1d, 0x6c, 0xef, 0x97, 0x7d, 0xed, 0xe7, 0x26,
0x69, 0xc0, 0xed, 0x4c, 0x1d, 0xfb, 0xd0, 0x9f, 0xdc, 0x40, 0x1b, 0xb0, 0xa0, 0x7d, 0x9b, 0xc6,
0xd0, 0x18, 0x75, 0xed, 0x79, 0xe5, 0x1a, 0xad, 0xc3, 0x7c, 0xc2, 0x09, 0x4f, 0x13, 0xf3, 0xd6,
0xd0, 0x18, 0x75, 0x6c, 0xfd, 0x85, 0x56, 0xa1, 0x43, 0xe3, 0x98, 0xc5, 0x66, 0x4b, 0xaa, 0xab,
0x0f, 0x84, 0xa0, 0x9d, 0xf8, 0x3f, 0x53, 0xb3, 0x3d, 0x34, 0x46, 0x4b, 0xb6, 0x5c, 0xe3, 0x05,
0xe8, 0x7c, 0x33, 0x8e, 0xf8, 0x35, 0xfe, 0x1c, 0xcc, 0xd7, 0xc4, 0x4d, 0xd3, 0xf1, 0x6b, 0x19,
0xe3, 0xe1, 0x05, 0x75, 0x2f, 0xb3, 0xdc, 0xb7, 0xa0, 0xab, 0x23, 0xd7, 0x11, 0x2c, 0xd9, 0x8b,
0x4a, 0x70, 0xec, 0xe1, 0x2f, 0x61, 0xb3, 0xc6, 0x50, 0xd7, 0xe0, 0x03, 0x58, 0x3a, 0x27, 0xf1,
0x29, 0x39, 0xa7, 0x4e, 0x4c, 0xb8, 0xcf, 0xa4, 0xb5, 0x61, 0xf7, 0xb5, 0xd0, 0x16, 0x32, 0xfc,
0x23, 0x58, 0x05, 0x04, 0x36, 0x8e, 0x88, 0xcb, 0x9b, 0x38, 0x47, 0x43, 0xe8, 0x45, 0x31, 0x25,
0x41, 0xc0, 0x5c, 0xc2, 0xa9, 0xac, 0x42, 0xcb, 0x9e, 0x14, 0xe1, 0xbb, 0xb0, 0x55, 0x0b, 0xae,
0x02, 0xc4, 0x4f, 0x4b, 0xd1, 0xb3, 0xf1, 0xd8, 0x6f, 0xe4, 0x1a, 0xdf, 0xa9, 0x44, 0x2d, 0x2d,
0x35, 0xee, 0xb3, 0xd2, 0x6e, 0x40, 0x49, 0x98, 0x46, 0x8d, 0x80, 0xcb, 0x11, 0x67, 0xa6, 0x39,
0xf2, 0x86, 0x6a, 0x8e, 0x43, 0x16, 0x04, 0xd4, 0xe5, 0x3e, 0x0b, 0x33, 0xd8, 0x6d, 0x00, 0x37,
0x17, 0xea, 0x56, 0x99, 0x90, 0x60, 0x0b, 0xcc, 0xaa, 0xa9, 0x86, 0xfd, 0xd5, 0x80, 0xb5, 0xaf,
0x74, 0xd1, 0x94, 0xe3, 0x46, 0x07, 0x50, 0x74, 0x79, 0xab, 0xec, 0xb2, 0x7c, 0x40, 0xad, 0xca,
0x01, 0x09, 0x8d, 0x98, 0x46, 0x81, 0xef, 0x12, 0x09, 0xd1, 0x96, 0x10, 0x93, 0x22, 0x34, 0x80,
0x16, 0xe7, 0x81, 0xd9, 0x91, 0x3b, 0x62, 0x89, 0x4d, 0x58, 0x2f, 0xc7, 0xaa, 0xd3, 0xf8, 0x0c,
0x36, 0x94, 0xe4, 0xe4, 0x3a, 0x74, 0x4f, 0xe4, 0x34, 0x34, 0x2a, 0xfa, 0x1f, 0x06, 0x98, 0x55,
0x43, 0xdd, 0xc5, 0xff, 0xb6, 0x02, 0x7f, 0x37, 0x3f, 0xf4, 0x7f, 0xe8, 0x71, 0xe2, 0x07, 0x0e,
0x3b, 0x3b, 0x4b, 0x28, 0x37, 0xe7, 0x87, 0xc6, 0xa8, 0x6d, 0x83, 0x10, 0xbd, 0x94, 0x12, 0xb4,
0x0b, 0x03, 0x57, 0x75, 0xb2, 0x13, 0xd3, 0x2b, 0x3f, 0x11, 0xc8, 0x0b, 0x32, 0xb0, 0x65, 0x37,
0xeb, 0x70, 0x25, 0x46, 0x18, 0x96, 0x7c, 0xef, 0x9d, 0x23, 0x2f, 0x10, 0x39, 0xfe, 0x8b, 0x12,
0xad, 0xe7, 0x7b, 0xef, 0x9e, 0xfb, 0x01, 0x3d, 0x11, 0xb7, 0xc0, 0xb7, 0xb0, 0xa2, 0x92, 0x7f,
0xce, 0x82, 0x80, 0xbd, 0x6d, 0x74, 0xf2, 0xab, 0xd0, 0x49, 0xfc, 0xd0, 0x55, 0x43, 0xd7, 0xb6,
0xd5, 0x07, 0x7e, 0x06, 0xab, 0x45, 0x24, 0x5d, 0xc2, 0x7b, 0xd0, 0x97, 0x11, 0xb8, 0x2c, 0xe4,
0x34, 0xe4, 0x12, 0xad, 0x6f, 0xf7, 0x84, 0xec, 0x50, 0x89, 0xf0, 0x27, 0x80, 0x94, 0xe9, 0x0b,
0x96, 0x86, 0xcd, 0x66, 0x70, 0x2d, 0x8b, 0x5b, 0x9b, 0xe8, 0x26, 0x78, 0x92, 0x05, 0xf1, 0x2a,
0x1c, 0x37, 0xc6, 0xda, 0x80, 0xb5, 0x92, 0x91, 0x46, 0x3b, 0xc8, 0x9c, 0x14, 0x1f, 0x84, 0xf7,
0x82, 0xad, 0x67, 0x11, 0x14, 0xdf, 0x04, 0xfc, 0x9b, 0x01, 0xeb, 0xb6, 0x3e, 0xfa, 0xff, 0x78,
0xcc, 0x26, 0x9b, 0xac, 0x35, 0xb5, 0xc9, 0xda, 0x37, 0x4d, 0x36, 0x82, 0x41, 0xc2, 0xd2, 0xd8,
0xa5, 0x8e, 0x47, 0x38, 0x71, 0x42, 0xe6, 0x51, 0xdd, 0x83, 0xb7, 0x95, 0xfc, 0x88, 0x70, 0xf2,
0x1d, 0xf3, 0x28, 0xde, 0x84, 0x8d, 0x4a, 0xd0, 0x3a, 0xa1, 0x10, 0x96, 0x0f, 0x59, 0x74, 0x2d,
0x3a, 0xa9, 0x61, 0x22, 0x3d, 0x3f, 0x71, 0xb2, 0x86, 0x94, 0x99, 0x2c, 0xda, 0x5d, 0x3f, 0x39,
0x56, 0xdd, 0xa8, 0xf7, 0x3d, 0xc2, 0xd5, 0x7e, 0x2b, 0xdb, 0x3f, 0x22, 0x5c, 0xec, 0xe3, 0x4f,
0x61, 0x70, 0xe3, 0xaf, 0x79, 0x6f, 0x7d, 0x01, 0x5b, 0x36, 0x25, 0x9e, 0x6e, 0x4d, 0xd1, 0xf6,
0xcd, 0xaf, 0x86, 0x3f, 0x0d, 0xb8, 0x53, 0x6f, 0xdc, 0xe4, 0x7a, 0xd8, 0x03, 0x94, 0x8f, 0x1f,
0xf7, 0xc7, 0x34, 0xe1, 0x64, 0x1c, 0xe9, 0x99, 0x19, 0xe8, 0x19, 0xfc, 0x3e, 0x93, 0x57, 0x87,
0xb5, 0x55, 0x19, 0x56, 0x81, 0x98, 0xd5, 0x67, 0x02, 0xb1, 0xad, 0x10, 0x3d, 0x55, 0xa7, 0x02,
0x62, 0xae, 0x2d, 0x11, 0x3b, 0x0a, 0x51, 0x2b, 0x4a, 0xc4, 0xbb, 0x00, 0xba, 0x80, 0x69, 0x98,
0xdd, 0x36, 0x5d, 0x55, 0xbe, 0x34, 0xe4, 0xf8, 0x07, 0x80, 0x23, 0x3f, 0xb9, 0x54, 0x59, 0x8b,
0x46, 0xf2, 0xfc, 0x58, 0xbf, 0x2e, 0x62, 0x29, 0x24, 0x24, 0x08, 0x74, 0x4e, 0x62, 0x29, 0x98,
0x46, 0x9a, 0x50, 0x4f, 0x47, 0x2f, 0xd7, 0x42, 0x76, 0x16, 0x53, 0xaa, 0x03, 0x95, 0x6b, 0xfc,
0x8b, 0x01, 0xdd, 0x17, 0x74, 0xac, 0x91, 0xb7, 0x01, 0xce, 0x59, 0xcc, 0x52, 0xee, 0x87, 0x34,
0x91, 0x0e, 0x3a, 0xf6, 0x84, 0xe4, 0x9f, 0xfb, 0x91, 0xcc, 0x87, 0x06, 0x67, 0x3a, 0x77, 0xb9,
0x16, 0xb2, 0x0b, 0x4a, 0x22, 0x9d, 0xae, 0x5c, 0xcb, 0x3b, 0x8d, 0x13, 0xf7, 0x52, 0xde, 0xa5,
0xe2, 0x4e, 0x13, 0x1f, 0x07, 0xbf, 0xf7, 0xa1, 0xaf, 0xdf, 0x06, 0x49, 0xdc, 0xd0, 0x4f, 0xd0,
0x9b, 0x20, 0x7c, 0xe8, 0xc3, 0x2a, 0xaf, 0xab, 0x12, 0x48, 0x6b, 0x67, 0x86, 0x96, 0x1e, 0xa8,
0x39, 0x14, 0xc2, 0xff, 0x2a, 0x84, 0x0a, 0x3d, 0xac, 0x5a, 0x4f, 0xa3, 0x6b, 0xd6, 0xa3, 0x46,
0xba, 0xb9, 0x3f, 0x0e, 0x2b, 0x35, 0x0c, 0x09, 0xed, 0xcd, 0x40, 0x29, 0xb0, 0x34, 0xeb, 0x71,
0x43, 0xed, 0xdc, 0xeb, 0x1b, 0x40, 0x55, 0xfa, 0x84, 0x1e, 0xcd, 0x84, 0xb9, 0xa1, 0x67, 0xd6,
0x5e, 0x33, 0xe5, 0xa9, 0x89, 0x2a, 0x62, 0x35, 0x33, 0xd1, 0x02, 0x75, 0x9b, 0x99, 0x68, 0x89,
0xad, 0xcd, 0xa1, 0x4b, 0x18, 0x94, 0x49, 0x17, 0xda, 0x9d, 0xf6, 0x4b, 0xa0, 0xc2, 0xe9, 0xac,
0x87, 0x4d, 0x54, 0x73, 0x67, 0x14, 0x6e, 0x17, 0x89, 0x11, 0x7a, 0x50, 0xb5, 0xaf, 0xa5, 0x79,
0xd6, 0x68, 0xb6, 0xe2, 0x64, 0x4e, 0x65, 0xb2, 0x54, 0x97, 0xd3, 0x14, 0x26, 0x56, 0x97, 0xd3,
0x34, 0xee, 0x85, 0xe7, 0x10, 0xc9, 0xa6, 0x4f, 0x51, 0x0a, 0xb4, 0x33, 0xcd, 0xba, 0x40, 0x5e,
0xac, 0xfb, 0xb3, 0xd4, 0x32, 0x07, 0x1f, 0x1b, 0x62, 0xa0, 0x27, 0x78, 0x44, 0xdd, 0x40, 0x57,
0x99, 0x89, 0xb5, 0x33, 0x43, 0x2b, 0x4f, 0xe0, 0x14, 0x96, 0x0a, 0xcc, 0x02, 0x4d, 0x0d, 0xad,
0xc8, 0x57, 0xac, 0x07, 0x33, 0xf5, 0x72, 0x1f, 0x4e, 0x56, 0x24, 0x7d, 0x27, 0x4d, 0x0d, 0xae,
0x78, 0x29, 0xdd, 0x9f, 0xa5, 0x96, 0x3b, 0xb8, 0x80, 0xe5, 0x12, 0x07, 0x40, 0x35, 0x1d, 0x53,
0xcf, 0x6d, 0xac, 0xdd, 0x06, 0x9a, 0xb9, 0xa7, 0xb7, 0xb0, 0x5a, 0xf7, 0xdc, 0xa2, 0xc7, 0x75,
0x20, 0x53, 0xdf, 0x74, 0x6b, 0xbf, 0xa9, 0x7a, 0xee, 0xf8, 0x15, 0x2c, 0x66, 0xdc, 0x02, 0xdd,
0xab, 0x5a, 0x97, 0x78, 0x8e, 0x85, 0xdf, 0xa7, 0x72, 0xd3, 0x5c, 0xa7, 0xf3, 0xf2, 0x8f, 0x86,
0x27, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x8c, 0xa8, 0xce, 0x0c, 0x7f, 0x10, 0x00, 0x00,
// 1190 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x58, 0xdb, 0x72, 0xdc, 0x44,
0x13, 0xb6, 0xb2, 0xbb, 0xb6, 0xb7, 0x77, 0x9d, 0x6c, 0xc6, 0xa7, 0x8d, 0x7c, 0xf8, 0x37, 0x93,
0xfc, 0xc9, 0x26, 0x31, 0x0e, 0x38, 0x05, 0x04, 0xae, 0x20, 0x36, 0x54, 0xf9, 0x22, 0xa4, 0x90,
0x49, 0x0a, 0x0a, 0xaa, 0x54, 0x63, 0x69, 0x6c, 0xab, 0xac, 0x53, 0xa4, 0x91, 0x89, 0x29, 0xde,
0x86, 0x3b, 0x2e, 0x78, 0x0e, 0xde, 0x89, 0x2a, 0x8a, 0x9a, 0x83, 0x64, 0x1d, 0xbd, 0x0a, 0xdc,
0x8d, 0x7a, 0xba, 0xbf, 0xee, 0x9e, 0xe9, 0xee, 0xf9, 0x76, 0x61, 0xf9, 0x22, 0x70, 0x13, 0x8f,
0x9a, 0x31, 0x8d, 0x2e, 0x68, 0xb4, 0x1b, 0x46, 0x01, 0x0b, 0xd0, 0xa8, 0x20, 0x34, 0xc3, 0x63,
0xfc, 0x14, 0xd0, 0x0b, 0xc2, 0xac, 0xb3, 0x03, 0xea, 0x52, 0x46, 0x0d, 0xfa, 0x36, 0xa1, 0x31,
0x43, 0x77, 0x60, 0xf1, 0xc4, 0x71, 0xa9, 0xe9, 0xd8, 0xf1, 0x58, 0x9b, 0x74, 0xa6, 0x7d, 0x63,
0x81, 0x7f, 0x1f, 0xda, 0x31, 0x7e, 0x05, 0xcb, 0x05, 0x83, 0x38, 0x0c, 0xfc, 0x98, 0xa2, 0xe7,
0xb0, 0x10, 0xd1, 0x38, 0x71, 0x99, 0x34, 0x18, 0xec, 0x6d, 0xef, 0x96, 0x7d, 0xed, 0x66, 0x26,
0x89, 0xcb, 0x8c, 0x54, 0x1d, 0x3b, 0x30, 0xcc, 0x6f, 0xa0, 0x75, 0x58, 0x50, 0xbe, 0xc7, 0xda,
0x44, 0x9b, 0xf6, 0x8d, 0x79, 0xe9, 0x1a, 0xad, 0xc1, 0x7c, 0xcc, 0x08, 0x4b, 0xe2, 0xf1, 0x8d,
0x89, 0x36, 0xed, 0x19, 0xea, 0x0b, 0xad, 0x40, 0x8f, 0x46, 0x51, 0x10, 0x8d, 0x3b, 0x42, 0x5d,
0x7e, 0x20, 0x04, 0xdd, 0xd8, 0xf9, 0x85, 0x8e, 0xbb, 0x13, 0x6d, 0xba, 0x64, 0x88, 0x35, 0x5e,
0x80, 0xde, 0x57, 0x5e, 0xc8, 0x2e, 0xf1, 0xa7, 0x30, 0x7e, 0x43, 0xac, 0x24, 0xf1, 0xde, 0x88,
0x18, 0xf7, 0xcf, 0xa8, 0x75, 0x9e, 0xe6, 0xbe, 0x01, 0x7d, 0x15, 0xb9, 0x8a, 0x60, 0xc9, 0x58,
0x94, 0x82, 0x43, 0x1b, 0x7f, 0x01, 0x77, 0x6a, 0x0c, 0xd5, 0x19, 0xdc, 0x83, 0xa5, 0x53, 0x12,
0x1d, 0x93, 0x53, 0x6a, 0x46, 0x84, 0x39, 0x81, 0xb0, 0xd6, 0x8c, 0xa1, 0x12, 0x1a, 0x5c, 0x86,
0x7f, 0x04, 0xbd, 0x80, 0x10, 0x78, 0x21, 0xb1, 0x58, 0x1b, 0xe7, 0x68, 0x02, 0x83, 0x30, 0xa2,
0xc4, 0x75, 0x03, 0x8b, 0x30, 0x2a, 0x4e, 0xa1, 0x63, 0xe4, 0x45, 0x78, 0x0b, 0x36, 0x6a, 0xc1,
0x65, 0x80, 0xf8, 0x79, 0x29, 0xfa, 0xc0, 0xf3, 0x9c, 0x56, 0xae, 0xf1, 0x66, 0x25, 0x6a, 0x61,
0xa9, 0x70, 0x3f, 0x2b, 0xed, 0xba, 0x94, 0xf8, 0x49, 0xd8, 0x0a, 0xb8, 0x1c, 0x71, 0x6a, 0x9a,
0x21, 0xaf, 0xcb, 0xe2, 0xd8, 0x0f, 0x5c, 0x97, 0x5a, 0xcc, 0x09, 0xfc, 0x14, 0x76, 0x1b, 0xc0,
0xca, 0x84, 0xaa, 0x54, 0x72, 0x12, 0xac, 0xc3, 0xb8, 0x6a, 0xaa, 0x60, 0x7f, 0xd7, 0x60, 0xf5,
0x4b, 0x75, 0x68, 0xd2, 0x71, 0xab, 0x0b, 0x28, 0xba, 0xbc, 0x51, 0x76, 0x59, 0xbe, 0xa0, 0x4e,
0xe5, 0x82, 0xb8, 0x46, 0x44, 0x43, 0xd7, 0xb1, 0x88, 0x80, 0xe8, 0x0a, 0x88, 0xbc, 0x08, 0x8d,
0xa0, 0xc3, 0x98, 0x3b, 0xee, 0x89, 0x1d, 0xbe, 0xc4, 0x63, 0x58, 0x2b, 0xc7, 0xaa, 0xd2, 0xf8,
0x04, 0xd6, 0xa5, 0xe4, 0xe8, 0xd2, 0xb7, 0x8e, 0x44, 0x37, 0xb4, 0x3a, 0xf4, 0xbf, 0x34, 0x18,
0x57, 0x0d, 0x55, 0x15, 0xff, 0xd7, 0x13, 0x78, 0xdf, 0xfc, 0xd0, 0xff, 0x60, 0xc0, 0x88, 0xe3,
0x9a, 0xc1, 0xc9, 0x49, 0x4c, 0xd9, 0x78, 0x7e, 0xa2, 0x4d, 0xbb, 0x06, 0x70, 0xd1, 0x2b, 0x21,
0x41, 0x8f, 0x60, 0x64, 0xc9, 0x4a, 0x36, 0x23, 0x7a, 0xe1, 0xc4, 0x1c, 0x79, 0x41, 0x04, 0x76,
0xcb, 0x4a, 0x2b, 0x5c, 0x8a, 0x11, 0x86, 0x25, 0xc7, 0x7e, 0x67, 0x8a, 0x01, 0x22, 0xda, 0x7f,
0x51, 0xa0, 0x0d, 0x1c, 0xfb, 0xdd, 0xd7, 0x8e, 0x4b, 0x8f, 0xf8, 0x14, 0xf8, 0x16, 0x36, 0x65,
0xf2, 0x87, 0xbe, 0x15, 0x51, 0x8f, 0xfa, 0x8c, 0xb8, 0xfb, 0x41, 0x78, 0xd9, 0xaa, 0x04, 0x56,
0xa0, 0x17, 0x3b, 0xbe, 0x25, 0xbb, 0xaf, 0x6b, 0xc8, 0x0f, 0xfc, 0x02, 0xb6, 0x1a, 0x20, 0xd5,
0xa1, 0xde, 0x85, 0xa1, 0x88, 0xc9, 0x0a, 0x7c, 0x46, 0x7d, 0x26, 0x60, 0x87, 0xc6, 0x80, 0xcb,
0xf6, 0xa5, 0x08, 0x7f, 0x04, 0x48, 0x62, 0xbc, 0x0c, 0x12, 0xbf, 0x5d, 0x57, 0xae, 0xc2, 0x72,
0xc1, 0x44, 0x95, 0xc5, 0x33, 0x58, 0x91, 0xe2, 0xd7, 0xbe, 0xd7, 0x1a, 0x6b, 0x1d, 0x56, 0x4b,
0x46, 0x0a, 0x6d, 0x2f, 0x75, 0x52, 0x7c, 0x22, 0xae, 0x05, 0x5b, 0x4b, 0x23, 0x28, 0xbe, 0x12,
0xf8, 0x0f, 0x0d, 0x6e, 0xa7, 0x13, 0xa4, 0xe5, 0x81, 0xbf, 0x67, 0xc5, 0x75, 0x1a, 0x2b, 0xae,
0x7b, 0x55, 0x71, 0x53, 0x18, 0xc5, 0x41, 0x12, 0x59, 0xd4, 0xb4, 0x09, 0x23, 0xa6, 0x1f, 0xd8,
0x54, 0x15, 0xe4, 0x4d, 0x29, 0x3f, 0x20, 0x8c, 0x7c, 0x13, 0xd8, 0x14, 0xaf, 0xa4, 0x97, 0x92,
0xbf, 0x4d, 0xec, 0xc3, 0x2d, 0xfe, 0xcd, 0x2b, 0xaa, 0x65, 0x0e, 0x03, 0x27, 0x36, 0xd3, 0xc2,
0x14, 0x49, 0x2c, 0x1a, 0x7d, 0x27, 0x3e, 0x94, 0x55, 0xa9, 0xf6, 0x6d, 0xc2, 0xe4, 0x7e, 0x27,
0xdd, 0x3f, 0x20, 0x8c, 0xef, 0xe3, 0x8f, 0x61, 0x74, 0xe5, 0xaf, 0x7d, 0x45, 0x7d, 0x0e, 0x1b,
0x06, 0x25, 0xb6, 0x4c, 0x40, 0x94, 0x7f, 0xfb, 0x11, 0xf1, 0xb7, 0x06, 0x9b, 0xf5, 0xc6, 0x6d,
0xc6, 0xc4, 0x0e, 0xa0, 0xac, 0x0d, 0x99, 0xe3, 0xd1, 0x98, 0x11, 0x2f, 0x54, 0x2d, 0x33, 0x52,
0xbd, 0xf8, 0x5d, 0x2a, 0xaf, 0x36, 0x6d, 0xa7, 0xd2, 0xb4, 0x1c, 0x31, 0x3d, 0x9f, 0x1c, 0x62,
0x57, 0x22, 0xda, 0xf2, 0x9c, 0x0a, 0x88, 0x99, 0xb6, 0x40, 0xec, 0x49, 0x44, 0xa5, 0x28, 0x10,
0xb7, 0x00, 0xd4, 0x01, 0x26, 0x7e, 0x3a, 0x75, 0xfa, 0xf2, 0xf8, 0x12, 0x9f, 0xe1, 0xef, 0x01,
0x0e, 0x9c, 0xf8, 0x5c, 0x66, 0xcd, 0x6b, 0xc8, 0x76, 0x22, 0xf5, 0xca, 0xf0, 0x25, 0x97, 0x10,
0xd7, 0x55, 0x39, 0xf1, 0x25, 0x67, 0x1c, 0x49, 0x4c, 0x6d, 0x15, 0xbd, 0x58, 0x73, 0xd9, 0x49,
0x44, 0xa9, 0x0a, 0x54, 0xac, 0xf1, 0x6f, 0x1a, 0xf4, 0x5f, 0x52, 0x4f, 0x21, 0x6f, 0x03, 0x9c,
0x06, 0x51, 0x90, 0x30, 0xc7, 0xa7, 0xb1, 0x70, 0xd0, 0x33, 0x72, 0x92, 0x7f, 0xef, 0x47, 0x30,
0x20, 0xea, 0x9e, 0xa8, 0xdc, 0xc5, 0x9a, 0xcb, 0xce, 0x28, 0x09, 0x55, 0xba, 0x62, 0x2d, 0x46,
0x1a, 0x23, 0xd6, 0xb9, 0x98, 0xa9, 0x7c, 0xa4, 0xf1, 0x8f, 0xbd, 0x3f, 0x87, 0x30, 0x54, 0x6f,
0x84, 0x20, 0x70, 0xe8, 0x27, 0x18, 0xe4, 0x88, 0x1f, 0xba, 0x5f, 0xe5, 0x77, 0x55, 0x22, 0xa9,
0xff, 0x7f, 0x86, 0x96, 0x6a, 0xa8, 0x39, 0xe4, 0xc3, 0xed, 0x0a, 0xb1, 0x42, 0x8f, 0xab, 0xd6,
0x4d, 0xb4, 0x4d, 0x7f, 0xd2, 0x4a, 0x37, 0xf3, 0xc7, 0x60, 0xb9, 0x86, 0x29, 0xa1, 0x9d, 0x19,
0x28, 0x05, 0xb6, 0xa6, 0x7f, 0xd0, 0x52, 0x3b, 0xf3, 0xfa, 0x16, 0x50, 0x95, 0x46, 0xa1, 0x27,
0x33, 0x61, 0xae, 0x68, 0x9a, 0xbe, 0xd3, 0x4e, 0xb9, 0x31, 0x51, 0x49, 0xb0, 0x66, 0x26, 0x5a,
0xa0, 0x70, 0x33, 0x13, 0x2d, 0xb1, 0xb6, 0x39, 0x74, 0x0e, 0xa3, 0x32, 0xf9, 0x42, 0x8f, 0x9a,
0x7e, 0x11, 0x54, 0xb8, 0x9d, 0xfe, 0xb8, 0x8d, 0x6a, 0xe6, 0x8c, 0xc2, 0xcd, 0x22, 0x41, 0x42,
0x0f, 0xab, 0xf6, 0xb5, 0x74, 0x4f, 0x9f, 0xce, 0x56, 0xcc, 0xe7, 0x54, 0x26, 0x4d, 0x75, 0x39,
0x35, 0x30, 0xb2, 0xba, 0x9c, 0x9a, 0x38, 0x18, 0x9e, 0x43, 0xbf, 0xa6, 0xcf, 0x71, 0x89, 0x51,
0xa0, 0xdd, 0x26, 0x98, 0x7a, 0x36, 0xa3, 0x3f, 0x6d, 0xad, 0x9f, 0xfa, 0xfe, 0x50, 0xe3, 0xbd,
0x9e, 0x23, 0x16, 0x75, 0xbd, 0x5e, 0xa5, 0x2a, 0x75, 0xbd, 0x5e, 0xc7, 0x4e, 0xe6, 0xd0, 0x31,
0x2c, 0x15, 0xa8, 0x06, 0x7a, 0xd0, 0x64, 0x59, 0x24, 0x30, 0xfa, 0xc3, 0x99, 0x7a, 0x99, 0x0f,
0x33, 0x9d, 0x5e, 0x6a, 0x5c, 0x35, 0x06, 0x57, 0x9c, 0x57, 0x0f, 0x66, 0xa9, 0x65, 0x0e, 0x7e,
0x00, 0xb8, 0x62, 0x06, 0xe8, 0x5e, 0x93, 0x5d, 0xfe, 0x2a, 0xee, 0x5f, 0xaf, 0x94, 0x41, 0xff,
0x0c, 0x2b, 0x75, 0x4f, 0x2f, 0xaa, 0xe9, 0xc2, 0x6b, 0xde, 0x77, 0x7d, 0xb7, 0xad, 0x7a, 0xe6,
0xf8, 0x35, 0x2c, 0xa6, 0x3c, 0x03, 0xdd, 0xad, 0x5a, 0x97, 0x38, 0x8f, 0x8e, 0xaf, 0x53, 0xb9,
0xaa, 0xa6, 0xe3, 0x79, 0xf1, 0xe7, 0xc3, 0xb3, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x47, 0x54,
0xf2, 0x7e, 0x93, 0x10, 0x00, 0x00,
}

5
weed/server/volume_grpc_replicate.go → weed/server/volume_grpc_copy.go
View file

@ -11,7 +11,8 @@ import (
"os"
)
func (vs *VolumeServer) ReplicateVolume(ctx context.Context, req *volume_server_pb.ReplicateVolumeRequest) (*volume_server_pb.ReplicateVolumeResponse, error) {
// VolumeCopy copy the .idx .dat files, and mount the volume
func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.VolumeCopyRequest) (*volume_server_pb.VolumeCopyResponse, error) {
v := vs.store.GetVolume(storage.VolumeId(req.VolumeId))
if v != nil {
@ -92,7 +93,7 @@ func (vs *VolumeServer) ReplicateVolume(ctx context.Context, req *volume_server_
return nil, fmt.Errorf("failed to mount volume %d: %v", req.VolumeId, err)
}
return &volume_server_pb.ReplicateVolumeResponse{}, err
return &volume_server_pb.VolumeCopyResponse{}, err
}
/**

6
weed/server/volume_grpc_follow.go → weed/server/volume_grpc_copy_incremental.go
View file

@ -10,7 +10,7 @@ import (
"github.com/chrislusf/seaweedfs/weed/storage"
)
func (vs *VolumeServer) VolumeFollow(req *volume_server_pb.VolumeFollowRequest, stream volume_server_pb.VolumeServer_VolumeFollowServer) error {
func (vs *VolumeServer) VolumeIncrementalCopy(req *volume_server_pb.VolumeIncrementalCopyRequest, stream volume_server_pb.VolumeServer_VolumeIncrementalCopyServer) error {
v := vs.store.GetVolume(storage.VolumeId(req.VolumeId))
if v == nil {
@ -47,12 +47,12 @@ func (vs *VolumeServer) VolumeSyncStatus(ctx context.Context, req *volume_server
}
func sendFileContent(datFile *os.File, buf []byte, startOffset, stopOffset int64, stream volume_server_pb.VolumeServer_VolumeFollowServer) error {
func sendFileContent(datFile *os.File, buf []byte, startOffset, stopOffset int64, stream volume_server_pb.VolumeServer_VolumeIncrementalCopyServer) error {
var blockSizeLimit = int64(len(buf))
for i := int64(0); i < stopOffset-startOffset; i += blockSizeLimit {
n, readErr := datFile.ReadAt(buf, startOffset+i)
if readErr == nil || readErr == io.EOF {
resp := &volume_server_pb.VolumeFollowResponse{}
resp := &volume_server_pb.VolumeIncrementalCopyResponse{}
resp.FileContent = buf[:int64(n)]
sendErr := stream.Send(resp)
if sendErr != nil {

2
weed/shell/command_volume_fix_replication.go
View file

@ -117,7 +117,7 @@ func (c *commandVolumeFixReplication) Do(args []string, commandEnv *commandEnv,
}
err := operation.WithVolumeServerClient(dst.dataNode.Id, commandEnv.option.GrpcDialOption, func(volumeServerClient volume_server_pb.VolumeServerClient) error {
_, replicateErr := volumeServerClient.ReplicateVolume(ctx, &volume_server_pb.ReplicateVolumeRequest{
_, replicateErr := volumeServerClient.VolumeCopy(ctx, &volume_server_pb.VolumeCopyRequest{
VolumeId: volumeInfo.Id,
Collection: volumeInfo.Collection,
SourceDataNode: sourceNode.dataNode.Id,

4
weed/storage/volume_follow.go → weed/storage/volume_backup.go
View file

@ -54,7 +54,7 @@ update needle map when receiving new .dat bytes. But seems not necessary now.)
*/
func (v *Volume) Follow(volumeServer string, grpcDialOption grpc.DialOption) error {
func (v *Volume) IncrementalBackup(volumeServer string, grpcDialOption grpc.DialOption) error {
ctx := context.Background()
@ -66,7 +66,7 @@ func (v *Volume) Follow(volumeServer string, grpcDialOption grpc.DialOption) err
err = operation.WithVolumeServerClient(volumeServer, grpcDialOption, func(client volume_server_pb.VolumeServerClient) error {
stream, err := client.VolumeFollow(ctx, &volume_server_pb.VolumeFollowRequest{
stream, err := client.VolumeIncrementalCopy(ctx, &volume_server_pb.VolumeIncrementalCopyRequest{
VolumeId: uint32(v.Id),
Since: appendAtNs,
})

0
weed/storage/volume_follow_test.go → weed/storage/volume_backup_test.go
View file