mirrors/seaweedfs
1
0
Fork 0
mirror of https://github.com/chrislusf/seaweedfs synced 2024-07-03 23:56:41 +02:00
Code Issues Projects Releases Wiki Activity

tier storage: support downloading the remote dat files

Browse source
This commit is contained in:
Chris Lu 2019-12-25 09:53:13 -08:00
parent 3ebeae0c0b
commit d960b3474a
11 changed files with 775 additions and 256 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
weed/pb/volume_server.proto
View file

@ -70,7 +70,9 @@ service VolumeServer {
}
// tiered storage
rpc VolumeTierCopyDatToRemote (VolumeTierCopyDatToRemoteRequest) returns (stream VolumeTierCopyDatToRemoteResponse) {
rpc VolumeTierMoveDatToRemote (VolumeTierMoveDatToRemoteRequest) returns (stream VolumeTierMoveDatToRemoteResponse) {
}
rpc VolumeTierMoveDatFromRemote (VolumeTierMoveDatFromRemoteRequest) returns (stream VolumeTierMoveDatFromRemoteResponse) {
}
// query
@ -352,13 +354,23 @@ message VolumeTierInfo {
repeated RemoteFile files = 1;
}
message VolumeTierCopyDatToRemoteRequest {
message VolumeTierMoveDatToRemoteRequest {
uint32 volume_id = 1;
string collection = 2;
string destination_backend_name = 3;
bool keep_local_dat_file = 4;
}
message VolumeTierCopyDatToRemoteResponse {
message VolumeTierMoveDatToRemoteResponse {
int64 processed = 1;
float processedPercentage = 2;
}
message VolumeTierMoveDatFromRemoteRequest {
uint32 volume_id = 1;
string collection = 2;
bool keep_remote_dat_file = 3;
}
message VolumeTierMoveDatFromRemoteResponse {
int64 processed = 1;
float processedPercentage = 2;
}

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

@ -69,8 +69,10 @@ It has these top-level messages:
MemStatus
RemoteFile
VolumeTierInfo
VolumeTierCopyDatToRemoteRequest
VolumeTierCopyDatToRemoteResponse
VolumeTierMoveDatToRemoteRequest
VolumeTierMoveDatToRemoteResponse
VolumeTierMoveDatFromRemoteRequest
VolumeTierMoveDatFromRemoteResponse
QueryRequest
QueriedStripe
*/
@ -1521,68 +1523,128 @@ func (m *VolumeTierInfo) GetFiles() []*RemoteFile {
return nil
}
type VolumeTierCopyDatToRemoteRequest struct {
type VolumeTierMoveDatToRemoteRequest 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"`
DestinationBackendName string `protobuf:"bytes,3,opt,name=destination_backend_name,json=destinationBackendName" json:"destination_backend_name,omitempty"`
KeepLocalDatFile bool `protobuf:"varint,4,opt,name=keep_local_dat_file,json=keepLocalDatFile" json:"keep_local_dat_file,omitempty"`
}
func (m *VolumeTierCopyDatToRemoteRequest) Reset() { *m = VolumeTierCopyDatToRemoteRequest{} }
func (m *VolumeTierCopyDatToRemoteRequest) String() string { return proto.CompactTextString(m) }
func (*VolumeTierCopyDatToRemoteRequest) ProtoMessage() {}
func (*VolumeTierCopyDatToRemoteRequest) Descriptor() ([]byte, []int) {
func (m *VolumeTierMoveDatToRemoteRequest) Reset() { *m = VolumeTierMoveDatToRemoteRequest{} }
func (m *VolumeTierMoveDatToRemoteRequest) String() string { return proto.CompactTextString(m) }
func (*VolumeTierMoveDatToRemoteRequest) ProtoMessage() {}
func (*VolumeTierMoveDatToRemoteRequest) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{60}
}
func (m *VolumeTierCopyDatToRemoteRequest) GetVolumeId() uint32 {
func (m *VolumeTierMoveDatToRemoteRequest) GetVolumeId() uint32 {
if m != nil {
return m.VolumeId
}
return 0
}
func (m *VolumeTierCopyDatToRemoteRequest) GetCollection() string {
func (m *VolumeTierMoveDatToRemoteRequest) GetCollection() string {
if m != nil {
return m.Collection
}
return ""
}
func (m *VolumeTierCopyDatToRemoteRequest) GetDestinationBackendName() string {
func (m *VolumeTierMoveDatToRemoteRequest) GetDestinationBackendName() string {
if m != nil {
return m.DestinationBackendName
}
return ""
}
func (m *VolumeTierCopyDatToRemoteRequest) GetKeepLocalDatFile() bool {
func (m *VolumeTierMoveDatToRemoteRequest) GetKeepLocalDatFile() bool {
if m != nil {
return m.KeepLocalDatFile
}
return false
}
type VolumeTierCopyDatToRemoteResponse struct {
type VolumeTierMoveDatToRemoteResponse struct {
Processed int64 `protobuf:"varint,1,opt,name=processed" json:"processed,omitempty"`
ProcessedPercentage float32 `protobuf:"fixed32,2,opt,name=processedPercentage" json:"processedPercentage,omitempty"`
}
func (m *VolumeTierCopyDatToRemoteResponse) Reset() { *m = VolumeTierCopyDatToRemoteResponse{} }
func (m *VolumeTierCopyDatToRemoteResponse) String() string { return proto.CompactTextString(m) }
func (*VolumeTierCopyDatToRemoteResponse) ProtoMessage() {}
func (*VolumeTierCopyDatToRemoteResponse) Descriptor() ([]byte, []int) {
func (m *VolumeTierMoveDatToRemoteResponse) Reset() { *m = VolumeTierMoveDatToRemoteResponse{} }
func (m *VolumeTierMoveDatToRemoteResponse) String() string { return proto.CompactTextString(m) }
func (*VolumeTierMoveDatToRemoteResponse) ProtoMessage() {}
func (*VolumeTierMoveDatToRemoteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{61}
}
func (m *VolumeTierCopyDatToRemoteResponse) GetProcessed() int64 {
func (m *VolumeTierMoveDatToRemoteResponse) GetProcessed() int64 {
if m != nil {
return m.Processed
}
return 0
}
func (m *VolumeTierCopyDatToRemoteResponse) GetProcessedPercentage() float32 {
func (m *VolumeTierMoveDatToRemoteResponse) GetProcessedPercentage() float32 {
if m != nil {
return m.ProcessedPercentage
}
return 0
}
type VolumeTierMoveDatFromRemoteRequest 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"`
KeepRemoteDatFile bool `protobuf:"varint,3,opt,name=keep_remote_dat_file,json=keepRemoteDatFile" json:"keep_remote_dat_file,omitempty"`
}
func (m *VolumeTierMoveDatFromRemoteRequest) Reset() { *m = VolumeTierMoveDatFromRemoteRequest{} }
func (m *VolumeTierMoveDatFromRemoteRequest) String() string { return proto.CompactTextString(m) }
func (*VolumeTierMoveDatFromRemoteRequest) ProtoMessage() {}
func (*VolumeTierMoveDatFromRemoteRequest) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62}
}
func (m *VolumeTierMoveDatFromRemoteRequest) GetVolumeId() uint32 {
if m != nil {
return m.VolumeId
}
return 0
}
func (m *VolumeTierMoveDatFromRemoteRequest) GetCollection() string {
if m != nil {
return m.Collection
}
return ""
}
func (m *VolumeTierMoveDatFromRemoteRequest) GetKeepRemoteDatFile() bool {
if m != nil {
return m.KeepRemoteDatFile
}
return false
}
type VolumeTierMoveDatFromRemoteResponse struct {
Processed int64 `protobuf:"varint,1,opt,name=processed" json:"processed,omitempty"`
ProcessedPercentage float32 `protobuf:"fixed32,2,opt,name=processedPercentage" json:"processedPercentage,omitempty"`
}
func (m *VolumeTierMoveDatFromRemoteResponse) Reset() { *m = VolumeTierMoveDatFromRemoteResponse{} }
func (m *VolumeTierMoveDatFromRemoteResponse) String() string { return proto.CompactTextString(m) }
func (*VolumeTierMoveDatFromRemoteResponse) ProtoMessage() {}
func (*VolumeTierMoveDatFromRemoteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{63}
}
func (m *VolumeTierMoveDatFromRemoteResponse) GetProcessed() int64 {
if m != nil {
return m.Processed
}
return 0
}
func (m *VolumeTierMoveDatFromRemoteResponse) GetProcessedPercentage() float32 {
if m != nil {
return m.ProcessedPercentage
}
@ -1601,7 +1663,7 @@ type QueryRequest struct {
func (m *QueryRequest) Reset() { *m = QueryRequest{} }
func (m *QueryRequest) String() string { return proto.CompactTextString(m) }
func (*QueryRequest) ProtoMessage() {}
func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{62} }
func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{64} }
func (m *QueryRequest) GetSelections() []string {
if m != nil {
@ -1647,7 +1709,7 @@ type QueryRequest_Filter struct {
func (m *QueryRequest_Filter) Reset() { *m = QueryRequest_Filter{} }
func (m *QueryRequest_Filter) String() string { return proto.CompactTextString(m) }
func (*QueryRequest_Filter) ProtoMessage() {}
func (*QueryRequest_Filter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{62, 0} }
func (*QueryRequest_Filter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{64, 0} }
func (m *QueryRequest_Filter) GetField() string {
if m != nil {
@ -1682,7 +1744,7 @@ func (m *QueryRequest_InputSerialization) Reset() { *m = QueryRequest_In
func (m *QueryRequest_InputSerialization) String() string { return proto.CompactTextString(m) }
func (*QueryRequest_InputSerialization) ProtoMessage() {}
func (*QueryRequest_InputSerialization) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62, 1}
return fileDescriptor0, []int{64, 1}
}
func (m *QueryRequest_InputSerialization) GetCompressionType() string {
@ -1730,7 +1792,7 @@ func (m *QueryRequest_InputSerialization_CSVInput) Reset() {
func (m *QueryRequest_InputSerialization_CSVInput) String() string { return proto.CompactTextString(m) }
func (*QueryRequest_InputSerialization_CSVInput) ProtoMessage() {}
func (*QueryRequest_InputSerialization_CSVInput) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62, 1, 0}
return fileDescriptor0, []int{64, 1, 0}
}
func (m *QueryRequest_InputSerialization_CSVInput) GetFileHeaderInfo() string {
@ -1792,7 +1854,7 @@ func (m *QueryRequest_InputSerialization_JSONInput) Reset() {
func (m *QueryRequest_InputSerialization_JSONInput) String() string { return proto.CompactTextString(m) }
func (*QueryRequest_InputSerialization_JSONInput) ProtoMessage() {}
func (*QueryRequest_InputSerialization_JSONInput) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62, 1, 1}
return fileDescriptor0, []int{64, 1, 1}
}
func (m *QueryRequest_InputSerialization_JSONInput) GetType() string {
@ -1813,7 +1875,7 @@ func (m *QueryRequest_InputSerialization_ParquetInput) String() string {
}
func (*QueryRequest_InputSerialization_ParquetInput) ProtoMessage() {}
func (*QueryRequest_InputSerialization_ParquetInput) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62, 1, 2}
return fileDescriptor0, []int{64, 1, 2}
}
type QueryRequest_OutputSerialization struct {
@ -1825,7 +1887,7 @@ func (m *QueryRequest_OutputSerialization) Reset() { *m = QueryRequest_O
func (m *QueryRequest_OutputSerialization) String() string { return proto.CompactTextString(m) }
func (*QueryRequest_OutputSerialization) ProtoMessage() {}
func (*QueryRequest_OutputSerialization) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62, 2}
return fileDescriptor0, []int{64, 2}
}
func (m *QueryRequest_OutputSerialization) GetCsvOutput() *QueryRequest_OutputSerialization_CSVOutput {
@ -1858,7 +1920,7 @@ func (m *QueryRequest_OutputSerialization_CSVOutput) String() string {
}
func (*QueryRequest_OutputSerialization_CSVOutput) ProtoMessage() {}
func (*QueryRequest_OutputSerialization_CSVOutput) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62, 2, 0}
return fileDescriptor0, []int{64, 2, 0}
}
func (m *QueryRequest_OutputSerialization_CSVOutput) GetQuoteFields() string {
@ -1908,7 +1970,7 @@ func (m *QueryRequest_OutputSerialization_JSONOutput) String() string {
}
func (*QueryRequest_OutputSerialization_JSONOutput) ProtoMessage() {}
func (*QueryRequest_OutputSerialization_JSONOutput) Descriptor() ([]byte, []int) {
return fileDescriptor0, []int{62, 2, 1}
return fileDescriptor0, []int{64, 2, 1}
}
func (m *QueryRequest_OutputSerialization_JSONOutput) GetRecordDelimiter() string {
@ -1925,7 +1987,7 @@ type QueriedStripe struct {
func (m *QueriedStripe) Reset() { *m = QueriedStripe{} }
func (m *QueriedStripe) String() string { return proto.CompactTextString(m) }
func (*QueriedStripe) ProtoMessage() {}
func (*QueriedStripe) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{63} }
func (*QueriedStripe) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{65} }
func (m *QueriedStripe) GetRecords() []byte {
if m != nil {
@ -1995,8 +2057,10 @@ func init() {
proto.RegisterType((*MemStatus)(nil), "volume_server_pb.MemStatus")
proto.RegisterType((*RemoteFile)(nil), "volume_server_pb.RemoteFile")
proto.RegisterType((*VolumeTierInfo)(nil), "volume_server_pb.VolumeTierInfo")
proto.RegisterType((*VolumeTierCopyDatToRemoteRequest)(nil), "volume_server_pb.VolumeTierCopyDatToRemoteRequest")
proto.RegisterType((*VolumeTierCopyDatToRemoteResponse)(nil), "volume_server_pb.VolumeTierCopyDatToRemoteResponse")
proto.RegisterType((*VolumeTierMoveDatToRemoteRequest)(nil), "volume_server_pb.VolumeTierMoveDatToRemoteRequest")
proto.RegisterType((*VolumeTierMoveDatToRemoteResponse)(nil), "volume_server_pb.VolumeTierMoveDatToRemoteResponse")
proto.RegisterType((*VolumeTierMoveDatFromRemoteRequest)(nil), "volume_server_pb.VolumeTierMoveDatFromRemoteRequest")
proto.RegisterType((*VolumeTierMoveDatFromRemoteResponse)(nil), "volume_server_pb.VolumeTierMoveDatFromRemoteResponse")
proto.RegisterType((*QueryRequest)(nil), "volume_server_pb.QueryRequest")
proto.RegisterType((*QueryRequest_Filter)(nil), "volume_server_pb.QueryRequest.Filter")
proto.RegisterType((*QueryRequest_InputSerialization)(nil), "volume_server_pb.QueryRequest.InputSerialization")
@ -2051,7 +2115,8 @@ type VolumeServerClient interface {
VolumeEcBlobDelete(ctx context.Context, in *VolumeEcBlobDeleteRequest, opts ...grpc.CallOption) (*VolumeEcBlobDeleteResponse, error)
VolumeEcShardsToVolume(ctx context.Context, in *VolumeEcShardsToVolumeRequest, opts ...grpc.CallOption) (*VolumeEcShardsToVolumeResponse, error)
// tiered storage
VolumeTierCopyDatToRemote(ctx context.Context, in *VolumeTierCopyDatToRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierCopyDatToRemoteClient, error)
VolumeTierMoveDatToRemote(ctx context.Context, in *VolumeTierMoveDatToRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatToRemoteClient, error)
VolumeTierMoveDatFromRemote(ctx context.Context, in *VolumeTierMoveDatFromRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatFromRemoteClient, error)
// query
Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (VolumeServer_QueryClient, error)
}
@ -2399,12 +2464,12 @@ func (c *volumeServerClient) VolumeEcShardsToVolume(ctx context.Context, in *Vol
return out, nil
}
func (c *volumeServerClient) VolumeTierCopyDatToRemote(ctx context.Context, in *VolumeTierCopyDatToRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierCopyDatToRemoteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[4], c.cc, "/volume_server_pb.VolumeServer/VolumeTierCopyDatToRemote", opts...)
func (c *volumeServerClient) VolumeTierMoveDatToRemote(ctx context.Context, in *VolumeTierMoveDatToRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatToRemoteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[4], c.cc, "/volume_server_pb.VolumeServer/VolumeTierMoveDatToRemote", opts...)
if err != nil {
return nil, err
}
x := &volumeServerVolumeTierCopyDatToRemoteClient{stream}
x := &volumeServerVolumeTierMoveDatToRemoteClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@ -2414,17 +2479,49 @@ func (c *volumeServerClient) VolumeTierCopyDatToRemote(ctx context.Context, in *
return x, nil
}
type VolumeServer_VolumeTierCopyDatToRemoteClient interface {
Recv() (*VolumeTierCopyDatToRemoteResponse, error)
type VolumeServer_VolumeTierMoveDatToRemoteClient interface {
Recv() (*VolumeTierMoveDatToRemoteResponse, error)
grpc.ClientStream
}
type volumeServerVolumeTierCopyDatToRemoteClient struct {
type volumeServerVolumeTierMoveDatToRemoteClient struct {
grpc.ClientStream
}
func (x *volumeServerVolumeTierCopyDatToRemoteClient) Recv() (*VolumeTierCopyDatToRemoteResponse, error) {
m := new(VolumeTierCopyDatToRemoteResponse)
func (x *volumeServerVolumeTierMoveDatToRemoteClient) Recv() (*VolumeTierMoveDatToRemoteResponse, error) {
m := new(VolumeTierMoveDatToRemoteResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *volumeServerClient) VolumeTierMoveDatFromRemote(ctx context.Context, in *VolumeTierMoveDatFromRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatFromRemoteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[5], c.cc, "/volume_server_pb.VolumeServer/VolumeTierMoveDatFromRemote", opts...)
if err != nil {
return nil, err
}
x := &volumeServerVolumeTierMoveDatFromRemoteClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type VolumeServer_VolumeTierMoveDatFromRemoteClient interface {
Recv() (*VolumeTierMoveDatFromRemoteResponse, error)
grpc.ClientStream
}
type volumeServerVolumeTierMoveDatFromRemoteClient struct {
grpc.ClientStream
}
func (x *volumeServerVolumeTierMoveDatFromRemoteClient) Recv() (*VolumeTierMoveDatFromRemoteResponse, error) {
m := new(VolumeTierMoveDatFromRemoteResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
@ -2432,7 +2529,7 @@ func (x *volumeServerVolumeTierCopyDatToRemoteClient) Recv() (*VolumeTierCopyDat
}
func (c *volumeServerClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (VolumeServer_QueryClient, error) {
stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[5], c.cc, "/volume_server_pb.VolumeServer/Query", opts...)
stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[6], c.cc, "/volume_server_pb.VolumeServer/Query", opts...)
if err != nil {
return nil, err
}
@ -2497,7 +2594,8 @@ type VolumeServerServer interface {
VolumeEcBlobDelete(context.Context, *VolumeEcBlobDeleteRequest) (*VolumeEcBlobDeleteResponse, error)
VolumeEcShardsToVolume(context.Context, *VolumeEcShardsToVolumeRequest) (*VolumeEcShardsToVolumeResponse, error)
// tiered storage
VolumeTierCopyDatToRemote(*VolumeTierCopyDatToRemoteRequest, VolumeServer_VolumeTierCopyDatToRemoteServer) error
VolumeTierMoveDatToRemote(*VolumeTierMoveDatToRemoteRequest, VolumeServer_VolumeTierMoveDatToRemoteServer) error
VolumeTierMoveDatFromRemote(*VolumeTierMoveDatFromRemoteRequest, VolumeServer_VolumeTierMoveDatFromRemoteServer) error
// query
Query(*QueryRequest, VolumeServer_QueryServer) error
}
@ -3004,24 +3102,45 @@ func _VolumeServer_VolumeEcShardsToVolume_Handler(srv interface{}, ctx context.C
return interceptor(ctx, in, info, handler)
}
func _VolumeServer_VolumeTierCopyDatToRemote_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(VolumeTierCopyDatToRemoteRequest)
func _VolumeServer_VolumeTierMoveDatToRemote_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(VolumeTierMoveDatToRemoteRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(VolumeServerServer).VolumeTierCopyDatToRemote(m, &volumeServerVolumeTierCopyDatToRemoteServer{stream})
return srv.(VolumeServerServer).VolumeTierMoveDatToRemote(m, &volumeServerVolumeTierMoveDatToRemoteServer{stream})
}
type VolumeServer_VolumeTierCopyDatToRemoteServer interface {
Send(*VolumeTierCopyDatToRemoteResponse) error
type VolumeServer_VolumeTierMoveDatToRemoteServer interface {
Send(*VolumeTierMoveDatToRemoteResponse) error
grpc.ServerStream
}
type volumeServerVolumeTierCopyDatToRemoteServer struct {
type volumeServerVolumeTierMoveDatToRemoteServer struct {
grpc.ServerStream
}
func (x *volumeServerVolumeTierCopyDatToRemoteServer) Send(m *VolumeTierCopyDatToRemoteResponse) error {
func (x *volumeServerVolumeTierMoveDatToRemoteServer) Send(m *VolumeTierMoveDatToRemoteResponse) error {
return x.ServerStream.SendMsg(m)
}
func _VolumeServer_VolumeTierMoveDatFromRemote_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(VolumeTierMoveDatFromRemoteRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(VolumeServerServer).VolumeTierMoveDatFromRemote(m, &volumeServerVolumeTierMoveDatFromRemoteServer{stream})
}
type VolumeServer_VolumeTierMoveDatFromRemoteServer interface {
Send(*VolumeTierMoveDatFromRemoteResponse) error
grpc.ServerStream
}
type volumeServerVolumeTierMoveDatFromRemoteServer struct {
grpc.ServerStream
}
func (x *volumeServerVolumeTierMoveDatFromRemoteServer) Send(m *VolumeTierMoveDatFromRemoteResponse) error {
return x.ServerStream.SendMsg(m)
}
@ -3165,8 +3284,13 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
ServerStreams: true,
},
{
StreamName: "VolumeTierCopyDatToRemote",
Handler: _VolumeServer_VolumeTierCopyDatToRemote_Handler,
StreamName: "VolumeTierMoveDatToRemote",
Handler: _VolumeServer_VolumeTierMoveDatToRemote_Handler,
ServerStreams: true,
},
{
StreamName: "VolumeTierMoveDatFromRemote",
Handler: _VolumeServer_VolumeTierMoveDatFromRemote_Handler,
ServerStreams: true,
},
{
@ -3181,181 +3305,185 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 2811 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x3a, 0x4b, 0x73, 0xdc, 0xc6,
0xd1, 0x5c, 0x2e, 0x1f, 0xbb, 0xbd, 0x4b, 0x91, 0x1a, 0xd2, 0xd4, 0x0a, 0x7a, 0xd1, 0xf0, 0x4b,
0x92, 0x2d, 0x4a, 0xa6, 0xbf, 0x2f, 0x76, 0xec, 0xd8, 0x89, 0x44, 0x4a, 0x89, 0x62, 0x8b, 0xb2,
0x41, 0x59, 0x71, 0x62, 0x57, 0x50, 0x43, 0x60, 0x56, 0x84, 0x09, 0x60, 0x20, 0x60, 0x96, 0xd6,
0xaa, 0x92, 0x93, 0x73, 0xc8, 0x25, 0xb7, 0x5c, 0x72, 0xce, 0x3d, 0x97, 0x1c, 0x52, 0x95, 0x5f,
0xe0, 0x3f, 0x90, 0x6b, 0x2e, 0x39, 0xe4, 0x94, 0x43, 0x6e, 0xa9, 0xca, 0x25, 0x35, 0x2f, 0x2c,
0x9e, 0x5c, 0xd0, 0x52, 0x55, 0x2a, 0xb7, 0x41, 0x4f, 0x3f, 0xa6, 0x7b, 0xba, 0x7b, 0xa6, 0xa7,
0x01, 0xab, 0x47, 0xd4, 0x1f, 0x05, 0xc4, 0x4e, 0x48, 0x7c, 0x44, 0xe2, 0xcd, 0x28, 0xa6, 0x8c,
0xa2, 0x95, 0x1c, 0xd0, 0x8e, 0xf6, 0xcd, 0xeb, 0x80, 0x6e, 0x61, 0xe6, 0x1c, 0xec, 0x10, 0x9f,
0x30, 0x62, 0x91, 0xc7, 0x23, 0x92, 0x30, 0x74, 0x16, 0x3a, 0x43, 0xcf, 0x27, 0xb6, 0xe7, 0x26,
0x83, 0xd6, 0x46, 0xfb, 0x72, 0xd7, 0x5a, 0xe4, 0xdf, 0x77, 0xdd, 0xc4, 0xbc, 0x0f, 0xab, 0x39,
0x82, 0x24, 0xa2, 0x61, 0x42, 0xd0, 0x3b, 0xb0, 0x18, 0x93, 0x64, 0xe4, 0x33, 0x49, 0xd0, 0xdb,
0xba, 0xb8, 0x59, 0x94, 0xb5, 0x99, 0x92, 0x8c, 0x7c, 0x66, 0x69, 0x74, 0xf3, 0xeb, 0x16, 0xf4,
0xb3, 0x33, 0xe8, 0x0c, 0x2c, 0x2a, 0xe1, 0x83, 0xd6, 0x46, 0xeb, 0x72, 0xd7, 0x5a, 0x90, 0xb2,
0xd1, 0x3a, 0x2c, 0x24, 0x0c, 0xb3, 0x51, 0x32, 0x98, 0xdd, 0x68, 0x5d, 0x9e, 0xb7, 0xd4, 0x17,
0x5a, 0x83, 0x79, 0x12, 0xc7, 0x34, 0x1e, 0xb4, 0x05, 0xba, 0xfc, 0x40, 0x08, 0xe6, 0x12, 0xef,
0x29, 0x19, 0xcc, 0x6d, 0xb4, 0x2e, 0x2f, 0x59, 0x62, 0x8c, 0x06, 0xb0, 0x78, 0x44, 0xe2, 0xc4,
0xa3, 0xe1, 0x60, 0x5e, 0x80, 0xf5, 0xa7, 0xb9, 0x08, 0xf3, 0xb7, 0x83, 0x88, 0x8d, 0xcd, 0xb7,
0x61, 0xf0, 0x10, 0x3b, 0xa3, 0x51, 0xf0, 0x50, 0x2c, 0x7f, 0xfb, 0x80, 0x38, 0x87, 0xda, 0x2c,
0xe7, 0xa0, 0xab, 0x94, 0x52, 0x6b, 0x5b, 0xb2, 0x3a, 0x12, 0x70, 0xd7, 0x35, 0x7f, 0x00, 0x67,
0x2b, 0x08, 0x95, 0x79, 0x5e, 0x82, 0xa5, 0x47, 0x38, 0xde, 0xc7, 0x8f, 0x88, 0x1d, 0x63, 0xe6,
0x51, 0x41, 0xdd, 0xb2, 0xfa, 0x0a, 0x68, 0x71, 0x98, 0xf9, 0x39, 0x18, 0x39, 0x0e, 0x34, 0x88,
0xb0, 0xc3, 0x9a, 0x08, 0x47, 0x1b, 0xd0, 0x8b, 0x62, 0x82, 0x7d, 0x9f, 0x3a, 0x98, 0x11, 0x61,
0x9f, 0xb6, 0x95, 0x05, 0x99, 0x17, 0xe0, 0x5c, 0x25, 0x73, 0xb9, 0x40, 0xf3, 0x9d, 0xc2, 0xea,
0x69, 0x10, 0x78, 0x8d, 0x44, 0x9b, 0xe7, 0x4b, 0xab, 0x16, 0x94, 0x8a, 0xef, 0x77, 0x0b, 0xb3,
0x3e, 0xc1, 0xe1, 0x28, 0x6a, 0xc4, 0xb8, 0xb8, 0x62, 0x4d, 0x9a, 0x72, 0x3e, 0x23, 0xdd, 0x66,
0x9b, 0xfa, 0x3e, 0x71, 0x98, 0x47, 0x43, 0xcd, 0xf6, 0x22, 0x80, 0x93, 0x02, 0x95, 0x13, 0x65,
0x20, 0xa6, 0x01, 0x83, 0x32, 0xa9, 0x62, 0xfb, 0xd7, 0x16, 0xbc, 0x70, 0x53, 0x19, 0x4d, 0x0a,
0x6e, 0xb4, 0x01, 0x79, 0x91, 0xb3, 0x45, 0x91, 0xc5, 0x0d, 0x6a, 0x97, 0x36, 0x88, 0x63, 0xc4,
0x24, 0xf2, 0x3d, 0x07, 0x0b, 0x16, 0x73, 0x82, 0x45, 0x16, 0x84, 0x56, 0xa0, 0xcd, 0x98, 0x2f,
0x3c, 0xb7, 0x6b, 0xf1, 0x21, 0xda, 0x82, 0xf5, 0x80, 0x04, 0x34, 0x1e, 0xdb, 0x01, 0x8e, 0xec,
0x00, 0x3f, 0xb1, 0xb9, 0x9b, 0xdb, 0xc1, 0xfe, 0x60, 0x41, 0xac, 0x0f, 0xc9, 0xd9, 0x7b, 0x38,
0xba, 0x87, 0x9f, 0xec, 0x79, 0x4f, 0xc9, 0xbd, 0x7d, 0x73, 0x00, 0xeb, 0x45, 0xfd, 0x94, 0xea,
0xdf, 0x81, 0x33, 0x12, 0xb2, 0x37, 0x0e, 0x9d, 0x3d, 0x11, 0x5b, 0x8d, 0x36, 0xea, 0xdf, 0x2d,
0x18, 0x94, 0x09, 0x95, 0xe7, 0x3f, 0xab, 0xd5, 0x4e, 0x6c, 0x93, 0x4b, 0xd0, 0x63, 0xd8, 0xf3,
0x6d, 0x3a, 0x1c, 0x26, 0x84, 0x09, 0x43, 0xcc, 0x59, 0xc0, 0x41, 0xf7, 0x05, 0x04, 0x5d, 0x81,
0x15, 0x47, 0x7a, 0xbf, 0x1d, 0x93, 0x23, 0x4f, 0x64, 0x83, 0x45, 0xb1, 0xb0, 0x65, 0x47, 0x47,
0x85, 0x04, 0x23, 0x13, 0x96, 0x3c, 0xf7, 0x89, 0x2d, 0xd2, 0x91, 0x48, 0x26, 0x1d, 0xc1, 0xad,
0xe7, 0xb9, 0x4f, 0xee, 0x78, 0x3e, 0xe1, 0x16, 0x35, 0x1f, 0xc2, 0x79, 0xa9, 0xfc, 0xdd, 0xd0,
0x89, 0x49, 0x40, 0x42, 0x86, 0xfd, 0x6d, 0x1a, 0x8d, 0x1b, 0xb9, 0xcd, 0x59, 0xe8, 0x24, 0x5e,
0xe8, 0x10, 0x3b, 0x94, 0x49, 0x6d, 0xce, 0x5a, 0x14, 0xdf, 0xbb, 0x89, 0x79, 0x0b, 0x2e, 0xd4,
0xf0, 0x55, 0x96, 0x7d, 0x11, 0xfa, 0x62, 0x61, 0x0e, 0x0d, 0x19, 0x09, 0x99, 0xe0, 0xdd, 0xb7,
0x7a, 0x1c, 0xb6, 0x2d, 0x41, 0xe6, 0x9b, 0x80, 0x24, 0x8f, 0x7b, 0x74, 0x14, 0x36, 0x0b, 0xe7,
0x17, 0x60, 0x35, 0x47, 0xa2, 0x7c, 0xe3, 0x2d, 0x58, 0x93, 0xe0, 0x4f, 0xc3, 0xa0, 0x31, 0xaf,
0x33, 0xf0, 0x42, 0x81, 0x48, 0x71, 0xdb, 0xd2, 0x42, 0xf2, 0xc7, 0xce, 0xb1, 0xcc, 0xd6, 0xf5,
0x0a, 0xf2, 0x27, 0x8f, 0xc8, 0x5c, 0x72, 0xc1, 0x38, 0x3e, 0xb4, 0x08, 0x76, 0x69, 0xe8, 0x8f,
0x1b, 0x67, 0xae, 0x0a, 0x4a, 0xc5, 0xf7, 0x0f, 0x2d, 0x38, 0xad, 0x53, 0x5a, 0xc3, 0xdd, 0x3c,
0xa1, 0x3b, 0xb7, 0x6b, 0xdd, 0x79, 0x6e, 0xe2, 0xce, 0x97, 0x61, 0x25, 0xa1, 0xa3, 0xd8, 0x21,
0xb6, 0x8b, 0x19, 0xb6, 0x43, 0xea, 0x12, 0xe5, 0xed, 0xa7, 0x24, 0x7c, 0x07, 0x33, 0xbc, 0x4b,
0x5d, 0x62, 0x7e, 0x5f, 0x6f, 0x76, 0xce, 0x4b, 0xae, 0xc0, 0x69, 0x1f, 0x27, 0xcc, 0xc6, 0x51,
0x44, 0x42, 0xd7, 0xc6, 0x8c, 0xbb, 0x5a, 0x4b, 0xb8, 0xda, 0x29, 0x3e, 0x71, 0x53, 0xc0, 0x6f,
0xb2, 0xdd, 0xc4, 0xfc, 0xed, 0x2c, 0x2c, 0x73, 0x5a, 0xee, 0xda, 0x8d, 0xf4, 0x5d, 0x81, 0x36,
0x79, 0xc2, 0x94, 0xa2, 0x7c, 0x88, 0xae, 0xc3, 0xaa, 0x8a, 0x21, 0x8f, 0x86, 0x93, 0xf0, 0x6a,
0xcb, 0x6c, 0x34, 0x99, 0x4a, 0x23, 0xec, 0x12, 0xf4, 0x12, 0x46, 0x23, 0x1d, 0xad, 0x73, 0x32,
0x5a, 0x39, 0x48, 0x45, 0x6b, 0xde, 0xa6, 0xf3, 0x15, 0x36, 0xed, 0x7b, 0x89, 0x4d, 0x1c, 0x5b,
0xae, 0x4a, 0xc4, 0x7b, 0xc7, 0x02, 0x2f, 0xb9, 0xed, 0x48, 0x6b, 0xa0, 0x0f, 0xe0, 0xbc, 0xf7,
0x28, 0xa4, 0x31, 0xb1, 0x95, 0x21, 0x45, 0xd4, 0x84, 0x94, 0xd9, 0x43, 0x3a, 0x0a, 0x5d, 0x11,
0xfb, 0x1d, 0x6b, 0x20, 0x71, 0xf6, 0x04, 0x0a, 0xb7, 0xc0, 0x2e, 0x65, 0x77, 0xf8, 0xbc, 0xf9,
0xff, 0xb0, 0x32, 0xb1, 0x4a, 0xf3, 0xd8, 0xfb, 0xba, 0xa5, 0xd3, 0xe9, 0x03, 0xec, 0xf9, 0x7b,
0x24, 0x74, 0x49, 0xfc, 0x8c, 0x39, 0x01, 0xdd, 0x80, 0x35, 0xcf, 0xf5, 0x89, 0xcd, 0xbc, 0x80,
0xd0, 0x11, 0xb3, 0x13, 0xe2, 0xd0, 0xd0, 0x4d, 0xb4, 0x7d, 0xf9, 0xdc, 0x03, 0x39, 0xb5, 0x27,
0x67, 0xcc, 0x5f, 0xa5, 0xb9, 0x39, 0xbb, 0x8a, 0xc9, 0xad, 0x24, 0x24, 0x84, 0x33, 0x3c, 0x20,
0xd8, 0x25, 0xb1, 0x52, 0xa3, 0x2f, 0x81, 0x3f, 0x12, 0x30, 0xbe, 0x43, 0x0a, 0x69, 0x9f, 0xba,
0x63, 0xb1, 0xa2, 0xbe, 0x05, 0x12, 0x74, 0x8b, 0xba, 0x63, 0x91, 0x24, 0x13, 0x5b, 0x38, 0x99,
0x73, 0x30, 0x0a, 0x0f, 0xc5, 0x6a, 0x3a, 0x56, 0xcf, 0x4b, 0x3e, 0xc2, 0x09, 0xdb, 0xe6, 0x20,
0xf3, 0x4f, 0x2d, 0x1d, 0xa5, 0x7c, 0x19, 0x16, 0x71, 0x88, 0x77, 0xf4, 0x5f, 0x30, 0x07, 0xa7,
0x50, 0x4e, 0x90, 0xbb, 0x9d, 0xaa, 0x80, 0x43, 0x72, 0x4e, 0x9d, 0x65, 0x62, 0x66, 0x92, 0x24,
0xf2, 0x0b, 0x57, 0x49, 0xe2, 0x0b, 0x9d, 0xa4, 0x6f, 0x3b, 0x7b, 0x07, 0x38, 0x76, 0x93, 0x1f,
0x92, 0x90, 0xc4, 0x98, 0x3d, 0x97, 0x4b, 0x83, 0xb9, 0x01, 0x17, 0xeb, 0xb8, 0x2b, 0xf9, 0x9f,
0xeb, 0xc3, 0x47, 0x63, 0x58, 0x64, 0x7f, 0xe4, 0xf9, 0xee, 0x73, 0x11, 0xff, 0x61, 0x51, 0xb9,
0x94, 0xb9, 0xf2, 0x9f, 0xab, 0x70, 0x3a, 0x16, 0x20, 0x66, 0x27, 0x1c, 0x21, 0xad, 0x17, 0x96,
0xac, 0x65, 0x35, 0x21, 0x08, 0x79, 0xdd, 0xf0, 0xf7, 0xd4, 0x03, 0x34, 0xb7, 0xe7, 0x96, 0x56,
0xcf, 0x41, 0x77, 0x22, 0xbe, 0x2d, 0xc4, 0x77, 0x12, 0x25, 0x97, 0x7b, 0xa7, 0x43, 0xa3, 0xb1,
0x4d, 0x1c, 0x79, 0x8e, 0x8b, 0xad, 0xee, 0x58, 0x3d, 0x0e, 0xbc, 0xed, 0x88, 0x63, 0xbc, 0x79,
0x8e, 0xcd, 0x70, 0xfb, 0x52, 0x72, 0x5b, 0xc8, 0x72, 0xfb, 0x92, 0x73, 0x9b, 0x78, 0x4c, 0x5e,
0x51, 0xb5, 0x63, 0x5f, 0xc1, 0xb9, 0xfc, 0x6c, 0xf3, 0x23, 0xf0, 0x99, 0x0c, 0x61, 0x5e, 0x2c,
0xba, 0x4a, 0xe1, 0x1c, 0x3d, 0x2a, 0x2e, 0xbb, 0xf1, 0x9d, 0xe1, 0xd9, 0xd6, 0x75, 0xa1, 0x68,
0x90, 0xfc, 0xc5, 0xe3, 0xb3, 0xe2, 0xb2, 0x4f, 0x70, 0x01, 0x39, 0x5e, 0xf0, 0xa5, 0xa2, 0x7b,
0x17, 0x6f, 0x29, 0xbf, 0x4b, 0x73, 0xa7, 0xc2, 0xe0, 0x77, 0x84, 0xc6, 0x39, 0x4b, 0xc9, 0x15,
0xe6, 0x58, 0xb2, 0x16, 0x95, 0x58, 0x5e, 0xc4, 0xaa, 0xb3, 0x4e, 0xd6, 0x00, 0xea, 0x2b, 0x57,
0xae, 0xb6, 0x55, 0xb9, 0xaa, 0xcb, 0xf0, 0x43, 0x32, 0x16, 0xfe, 0x38, 0x27, 0xcb, 0xf0, 0x0f,
0xc9, 0xd8, 0xdc, 0x2d, 0x44, 0x93, 0x5c, 0x9a, 0x8a, 0x4b, 0x04, 0x73, 0xdc, 0x91, 0x55, 0x3a,
0x17, 0x63, 0x74, 0x01, 0xc0, 0x4b, 0x6c, 0x57, 0xec, 0xb9, 0x5c, 0x54, 0xc7, 0xea, 0x7a, 0xca,
0x09, 0x5c, 0xf3, 0x37, 0x99, 0xf0, 0xbc, 0xe5, 0xd3, 0xfd, 0xe7, 0xe8, 0x95, 0x59, 0x2d, 0xda,
0x39, 0x2d, 0xb2, 0xf5, 0xf8, 0x5c, 0xbe, 0x1e, 0xcf, 0x04, 0x51, 0x76, 0x39, 0x75, 0x69, 0xf7,
0x01, 0x7d, 0x7e, 0xb5, 0x5a, 0x39, 0xed, 0x4e, 0xb8, 0x2b, 0xf9, 0xef, 0xc2, 0x39, 0x6e, 0x70,
0x09, 0x15, 0x95, 0x40, 0xf3, 0x6a, 0xe9, 0x1f, 0xb3, 0x70, 0xbe, 0x9a, 0xb8, 0x49, 0xc5, 0xf4,
0x1e, 0x18, 0x69, 0x45, 0xc2, 0x8f, 0xbd, 0x84, 0xe1, 0x20, 0x4a, 0x0f, 0x3e, 0x79, 0x3e, 0x9e,
0x51, 0xe5, 0xc9, 0x03, 0x3d, 0xaf, 0x4f, 0xbf, 0x52, 0x39, 0xd3, 0x2e, 0x95, 0x33, 0x5c, 0x80,
0x8b, 0x59, 0x9d, 0x00, 0x79, 0x3f, 0x3b, 0xe3, 0x62, 0x56, 0x27, 0x20, 0x25, 0x16, 0x02, 0xa4,
0xd7, 0xf6, 0x14, 0xbe, 0x10, 0x70, 0x01, 0x40, 0x5d, 0x9d, 0x46, 0xa1, 0x2e, 0xcf, 0xba, 0xf2,
0xe2, 0x34, 0x0a, 0x6b, 0x6f, 0x90, 0x8b, 0xb5, 0x37, 0xc8, 0xfc, 0x6e, 0x76, 0x4a, 0xbb, 0xf9,
0x19, 0xc0, 0x8e, 0x97, 0x1c, 0x4a, 0x23, 0xf3, 0x2b, 0xab, 0xeb, 0xc5, 0xea, 0x4d, 0x80, 0x0f,
0x39, 0x04, 0xfb, 0xbe, 0x32, 0x1d, 0x1f, 0xf2, 0xf0, 0x19, 0x25, 0xc4, 0x55, 0xd6, 0x11, 0x63,
0x0e, 0x1b, 0xc6, 0x84, 0x28, 0x03, 0x88, 0xb1, 0xf9, 0xfb, 0x16, 0x74, 0xef, 0x91, 0x40, 0x71,
0xbe, 0x08, 0xf0, 0x88, 0xc6, 0x74, 0xc4, 0xbc, 0x90, 0xc8, 0x1b, 0xf6, 0xbc, 0x95, 0x81, 0x7c,
0x7b, 0x39, 0x22, 0x35, 0x10, 0x7f, 0xa8, 0x8c, 0x29, 0xc6, 0x1c, 0x76, 0x40, 0x70, 0xa4, 0xec,
0x27, 0xc6, 0x68, 0x0d, 0xe6, 0x13, 0x86, 0x9d, 0x43, 0x61, 0xac, 0x39, 0x4b, 0x7e, 0x98, 0x7f,
0x6e, 0x01, 0x58, 0x24, 0xa0, 0x4c, 0xf8, 0x1a, 0xbf, 0xb9, 0xee, 0x63, 0xe7, 0x90, 0xd7, 0x02,
0x6c, 0x1c, 0x11, 0x65, 0x89, 0x9e, 0x82, 0x3d, 0x18, 0x47, 0x62, 0x87, 0x34, 0x8a, 0xca, 0x5f,
0x5d, 0xab, 0xab, 0x20, 0xf2, 0xd6, 0xaf, 0x43, 0xb9, 0x6b, 0xf1, 0x61, 0x26, 0xa7, 0xc9, 0x65,
0xeb, 0x9c, 0x76, 0x0e, 0xba, 0x45, 0x57, 0x10, 0xa9, 0x40, 0xf8, 0xc1, 0x4b, 0xb0, 0x14, 0x50,
0xd7, 0x1b, 0x7a, 0xc4, 0x15, 0x8e, 0xa6, 0x54, 0xe9, 0x6b, 0x20, 0x77, 0x2e, 0x73, 0x07, 0x4e,
0xa9, 0xdb, 0x97, 0x47, 0xe2, 0xbb, 0xe1, 0x90, 0xa2, 0x2d, 0x98, 0xe7, 0x2c, 0xf4, 0x33, 0xe3,
0xf9, 0xf2, 0x33, 0xe3, 0x44, 0x59, 0x4b, 0xa2, 0x9a, 0xdf, 0xb4, 0x60, 0x63, 0xc2, 0x86, 0x1f,
0xc7, 0x3b, 0x98, 0x3d, 0xa0, 0x12, 0xf1, 0xb9, 0xe4, 0xb8, 0x77, 0x60, 0xe0, 0x92, 0x84, 0x79,
0xa1, 0x28, 0xe3, 0x6c, 0x6d, 0xbe, 0x10, 0x07, 0x44, 0x19, 0x6a, 0x3d, 0x33, 0x7f, 0x4b, 0x4e,
0xef, 0xe2, 0x80, 0xa0, 0x6b, 0xb0, 0x7a, 0x48, 0x48, 0x64, 0xfb, 0xd4, 0xc1, 0xbe, 0xad, 0xa3,
0x47, 0xdd, 0x52, 0x56, 0xf8, 0xd4, 0x47, 0x7c, 0x66, 0x47, 0x46, 0x90, 0x99, 0xc0, 0x8b, 0xc7,
0x68, 0xa2, 0x32, 0xc8, 0x79, 0xe8, 0x46, 0x31, 0x75, 0x48, 0xc2, 0xbd, 0xab, 0x25, 0x0e, 0x94,
0x09, 0x00, 0xdd, 0x80, 0xd5, 0xf4, 0xe3, 0x63, 0x12, 0x3b, 0x24, 0x64, 0xf8, 0x91, 0x7c, 0x33,
0x9c, 0xb5, 0xaa, 0xa6, 0xcc, 0x7f, 0xf5, 0xa1, 0xff, 0xc9, 0x88, 0xc4, 0xe3, 0xcc, 0x03, 0x5b,
0x42, 0x94, 0xee, 0xfa, 0x85, 0x38, 0x03, 0xe1, 0x79, 0x60, 0x18, 0xd3, 0xc0, 0x4e, 0x1f, 0x91,
0x67, 0x05, 0x4a, 0x8f, 0x03, 0xef, 0xc8, 0x87, 0x64, 0xf4, 0x3e, 0x2c, 0x0c, 0x3d, 0x9f, 0x11,
0xf9, 0x6c, 0xdb, 0xdb, 0x7a, 0xa5, 0xbc, 0x93, 0x59, 0x99, 0x9b, 0x77, 0x04, 0xb2, 0xa5, 0x88,
0xd0, 0x3e, 0xac, 0x7a, 0x61, 0x24, 0x2e, 0xfd, 0xb1, 0x87, 0x7d, 0xef, 0xe9, 0xe4, 0x89, 0xa8,
0xb7, 0xf5, 0xe6, 0x14, 0x5e, 0x77, 0x39, 0xe5, 0x5e, 0x96, 0xd0, 0x42, 0x5e, 0x09, 0x86, 0x08,
0xac, 0xd1, 0x11, 0x2b, 0x0b, 0x99, 0x17, 0x42, 0xb6, 0xa6, 0x08, 0xb9, 0x2f, 0x48, 0xf3, 0x52,
0x56, 0x69, 0x19, 0x68, 0xec, 0xc2, 0x82, 0x54, 0x8e, 0x47, 0xf0, 0xd0, 0x23, 0xbe, 0x7e, 0xf8,
0x96, 0x1f, 0xfc, 0x94, 0xa4, 0x11, 0x89, 0x71, 0xa8, 0x83, 0x51, 0x7f, 0x72, 0xfc, 0x23, 0xec,
0x8f, 0xb4, 0x8f, 0xc9, 0x0f, 0xe3, 0x2f, 0xf3, 0x80, 0xca, 0x1a, 0xea, 0x77, 0xaf, 0x98, 0x24,
0x3c, 0x6f, 0x66, 0xa3, 0x7f, 0x39, 0x03, 0x17, 0x19, 0xe0, 0x27, 0xd0, 0x75, 0x92, 0x23, 0x5b,
0x98, 0x44, 0xc8, 0xec, 0x6d, 0xbd, 0x7b, 0x62, 0x93, 0x6e, 0x6e, 0xef, 0x3d, 0x14, 0x50, 0xab,
0xe3, 0x24, 0x47, 0x62, 0x84, 0x7e, 0x06, 0xf0, 0x65, 0x42, 0x43, 0xc5, 0x59, 0x6e, 0xfc, 0x7b,
0x27, 0xe7, 0xfc, 0xe3, 0xbd, 0xfb, 0xbb, 0x92, 0x75, 0x97, 0xb3, 0x93, 0xbc, 0x1d, 0x58, 0x8a,
0x70, 0xfc, 0x78, 0x44, 0x98, 0x62, 0x2f, 0x7d, 0xe1, 0x83, 0x93, 0xb3, 0xff, 0x58, 0xb2, 0x91,
0x12, 0xfa, 0x51, 0xe6, 0xcb, 0xf8, 0x66, 0x16, 0x3a, 0x5a, 0x2f, 0x5e, 0x37, 0x08, 0x0f, 0x97,
0xd5, 0xb3, 0xed, 0x85, 0x43, 0xaa, 0x2c, 0x7a, 0x8a, 0xc3, 0x65, 0x01, 0x2d, 0xb2, 0xd6, 0x15,
0x58, 0x89, 0x89, 0x43, 0x63, 0x97, 0xdf, 0xc0, 0xbc, 0xc0, 0xe3, 0x6e, 0x2f, 0xf7, 0x72, 0x59,
0xc2, 0x77, 0x34, 0x18, 0xbd, 0x06, 0xcb, 0x62, 0xdb, 0x33, 0x98, 0x6d, 0xcd, 0x93, 0xf8, 0x19,
0xc4, 0x2b, 0xb0, 0xf2, 0x78, 0x44, 0x19, 0xb1, 0x9d, 0x03, 0x1c, 0x63, 0x87, 0xd1, 0xb4, 0x8e,
0x5d, 0x16, 0xf0, 0xed, 0x14, 0x8c, 0xfe, 0x0f, 0xd6, 0x25, 0x2a, 0x49, 0x1c, 0x1c, 0xa5, 0x14,
0x24, 0x56, 0x65, 0xce, 0x9a, 0x98, 0xbd, 0x2d, 0x26, 0xb7, 0xf5, 0x1c, 0x32, 0xa0, 0xe3, 0xd0,
0x20, 0x20, 0x21, 0x4b, 0x44, 0x72, 0xee, 0x5a, 0xe9, 0x37, 0xba, 0x09, 0x17, 0xb0, 0xef, 0xd3,
0xaf, 0x6c, 0x41, 0xe9, 0xda, 0x25, 0xed, 0xe4, 0xab, 0x8a, 0x21, 0x90, 0x3e, 0x11, 0x38, 0x56,
0x5e, 0x51, 0xe3, 0x12, 0x74, 0xd3, 0x7d, 0xe4, 0xe7, 0x59, 0xc6, 0x21, 0xc5, 0xd8, 0x38, 0x05,
0xfd, 0xec, 0x4e, 0x18, 0xff, 0x6c, 0xc3, 0x6a, 0x45, 0x50, 0xa1, 0xcf, 0x01, 0xb8, 0xb7, 0xca,
0xd0, 0x52, 0xee, 0xfa, 0xbd, 0x93, 0x07, 0x27, 0xf7, 0x57, 0x09, 0xb6, 0xb8, 0xf7, 0xcb, 0x21,
0xfa, 0x39, 0xf4, 0x84, 0xc7, 0x2a, 0xee, 0xd2, 0x65, 0xdf, 0xff, 0x16, 0xdc, 0xb9, 0xae, 0x8a,
0xbd, 0x88, 0x01, 0x39, 0x36, 0xfe, 0xd6, 0x82, 0x6e, 0x2a, 0x98, 0x9f, 0xce, 0x72, 0xa3, 0xc4,
0x5e, 0x27, 0xfa, 0x74, 0x16, 0xb0, 0x3b, 0x02, 0xf4, 0x3f, 0xe9, 0x4a, 0xc6, 0xdb, 0x00, 0x13,
0xfd, 0x2b, 0x55, 0x68, 0x55, 0xaa, 0x60, 0x5e, 0x81, 0x25, 0x6e, 0x59, 0x8f, 0xb8, 0x7b, 0x2c,
0xf6, 0x22, 0xd1, 0xc2, 0x93, 0x38, 0x89, 0x2a, 0x6f, 0xf4, 0xe7, 0xd6, 0x1f, 0xcf, 0x42, 0x3f,
0xfb, 0x74, 0x83, 0xbe, 0x80, 0x5e, 0xa6, 0x55, 0x89, 0x5e, 0x2e, 0x6f, 0x5a, 0xb9, 0xf5, 0x69,
0xbc, 0x32, 0x05, 0x4b, 0x55, 0x00, 0x33, 0x28, 0x84, 0xd3, 0xa5, 0x7e, 0x1f, 0xba, 0x5a, 0xa6,
0xae, 0xeb, 0x26, 0x1a, 0xaf, 0x37, 0xc2, 0x4d, 0xe5, 0x31, 0x58, 0xad, 0x68, 0xe0, 0xa1, 0x37,
0xa6, 0x70, 0xc9, 0x35, 0x11, 0x8d, 0x6b, 0x0d, 0xb1, 0x53, 0xa9, 0x8f, 0x01, 0x95, 0xbb, 0x7b,
0xe8, 0xf5, 0xa9, 0x6c, 0x26, 0xdd, 0x43, 0xe3, 0x8d, 0x66, 0xc8, 0xb5, 0x8a, 0xca, 0xbe, 0xdf,
0x54, 0x45, 0x73, 0x9d, 0xc5, 0xa9, 0x8a, 0x16, 0x9a, 0x89, 0x33, 0xe8, 0x10, 0x56, 0x8a, 0x3d,
0x41, 0x74, 0xa5, 0xae, 0x87, 0x5d, 0x6a, 0x39, 0x1a, 0x57, 0x9b, 0xa0, 0xa6, 0xc2, 0x08, 0x9c,
0xca, 0xf7, 0xe0, 0xd0, 0x6b, 0x65, 0xfa, 0xca, 0x2e, 0xa4, 0x71, 0x79, 0x3a, 0x62, 0x56, 0xa7,
0x62, 0x5f, 0xae, 0x4a, 0xa7, 0x9a, 0xa6, 0x5f, 0x95, 0x4e, 0x75, 0x6d, 0x3e, 0x73, 0x06, 0xfd,
0x42, 0x37, 0x7b, 0x0a, 0xfd, 0x2a, 0xb4, 0x59, 0xc7, 0xa6, 0xba, 0x61, 0x66, 0x5c, 0x6f, 0x8c,
0xaf, 0x65, 0xdf, 0x68, 0xf1, 0x58, 0xcf, 0xb4, 0xad, 0xaa, 0x62, 0xbd, 0xdc, 0x08, 0xab, 0x8a,
0xf5, 0xaa, 0xde, 0xd7, 0x0c, 0xda, 0x87, 0xa5, 0x5c, 0x23, 0x0b, 0xbd, 0x5a, 0x47, 0x99, 0x7f,
0x9d, 0x32, 0x5e, 0x9b, 0x8a, 0x97, 0xca, 0xb0, 0x75, 0xf6, 0x52, 0xe9, 0xaa, 0x76, 0x71, 0xf9,
0x7c, 0xf5, 0xea, 0x34, 0xb4, 0x5c, 0x28, 0x97, 0xda, 0x5d, 0x95, 0xa1, 0x5c, 0xd7, 0x4e, 0xab,
0x0c, 0xe5, 0xfa, 0x0e, 0xda, 0x0c, 0xfa, 0x29, 0xc0, 0xa4, 0x25, 0x85, 0x5e, 0xaa, 0xa3, 0xce,
0xee, 0xfe, 0xcb, 0xc7, 0x23, 0xa5, 0xac, 0xbf, 0x82, 0xb5, 0xaa, 0x57, 0x14, 0x74, 0xad, 0xaa,
0x20, 0xac, 0x7d, 0xaa, 0x31, 0x36, 0x9b, 0xa2, 0xa7, 0x82, 0x3f, 0x85, 0x8e, 0x6e, 0x07, 0xa1,
0x17, 0xcb, 0xd4, 0x85, 0x06, 0x9a, 0x61, 0x1e, 0x87, 0x92, 0x71, 0xe0, 0x40, 0xc7, 0xea, 0xa4,
0x4f, 0x53, 0x1f, 0xab, 0xa5, 0x8e, 0x52, 0x7d, 0xac, 0x96, 0xdb, 0x3e, 0x42, 0x5c, 0xea, 0x0c,
0xd9, 0xb6, 0x46, 0xbd, 0x33, 0x54, 0x74, 0x6d, 0xea, 0x9d, 0xa1, 0xb2, 0x53, 0x32, 0x83, 0x7e,
0x09, 0xeb, 0xd5, 0xdd, 0x0c, 0x54, 0x1b, 0xf1, 0x35, 0x5d, 0x15, 0xe3, 0x46, 0x73, 0x82, 0x54,
0xfc, 0x53, 0x9d, 0x9f, 0x0a, 0xdd, 0x8c, 0xfa, 0xfc, 0x54, 0xdd, 0x53, 0x31, 0xae, 0x37, 0xc6,
0x2f, 0x87, 0x5e, 0xb6, 0x25, 0x50, 0x6f, 0xed, 0x8a, 0x0e, 0x49, 0xbd, 0xb5, 0x2b, 0xbb, 0x0c,
0x22, 0x3e, 0xaa, 0x9e, 0xfb, 0xab, 0xe2, 0xe3, 0x98, 0x7e, 0x84, 0xb1, 0xd9, 0x14, 0x3d, 0x77,
0x7c, 0x97, 0xdf, 0xf3, 0xd1, 0xd4, 0xf5, 0xe7, 0x32, 0xf3, 0xb5, 0x86, 0xd8, 0xf5, 0xbb, 0xab,
0x33, 0xf5, 0x54, 0x05, 0x0a, 0x19, 0xfb, 0x7a, 0x63, 0xfc, 0x54, 0x76, 0xa4, 0x7f, 0x14, 0xc8,
0xbc, 0xc5, 0xa3, 0xab, 0x53, 0xf8, 0x64, 0x7a, 0x09, 0xc6, 0xeb, 0x8d, 0x70, 0xab, 0xa2, 0x37,
0xfb, 0x3a, 0x7e, 0x9c, 0x3f, 0x95, 0x9e, 0xf4, 0x8f, 0xf3, 0xa7, 0x8a, 0x07, 0xf7, 0x8a, 0xe8,
0xd5, 0x8f, 0xe2, 0xd3, 0xa3, 0xb7, 0xf0, 0x38, 0x3f, 0x3d, 0x7a, 0x4b, 0xef, 0xed, 0x33, 0xe8,
0xd7, 0x93, 0x06, 0x72, 0xf9, 0xe1, 0x0b, 0x6d, 0xd5, 0xa6, 0xa2, 0xda, 0xf7, 0x3e, 0xe3, 0xad,
0x13, 0xd1, 0x64, 0x8c, 0xff, 0x11, 0xcc, 0x8b, 0x62, 0x0f, 0x5d, 0x3c, 0xbe, 0x0a, 0x34, 0x2e,
0x55, 0xcf, 0xa7, 0xb5, 0x0c, 0xe7, 0xb6, 0xbf, 0x20, 0xfe, 0xcc, 0x7c, 0xeb, 0x3f, 0x01, 0x00,
0x00, 0xff, 0xff, 0x59, 0x62, 0x68, 0x9d, 0xb0, 0x29, 0x00, 0x00,
// 2870 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x1a, 0x4d, 0x73, 0x1c, 0x47,
0x55, 0xab, 0xd5, 0xc7, 0xee, 0xdb, 0x95, 0x25, 0xb7, 0x14, 0x79, 0x33, 0xfe, 0x52, 0xc6, 0xf9,
0xb0, 0x9d, 0x58, 0x76, 0x94, 0x84, 0x84, 0x84, 0x04, 0x6c, 0xd9, 0x06, 0x93, 0x58, 0x4e, 0x46,
0x8e, 0x09, 0x24, 0xc5, 0x54, 0x6b, 0xa6, 0x65, 0x4d, 0x34, 0x33, 0x3d, 0x9e, 0xe9, 0x95, 0xbd,
0x2e, 0x38, 0x85, 0x03, 0x17, 0x38, 0x50, 0x5c, 0x38, 0x73, 0xe7, 0x4a, 0x15, 0x67, 0x0e, 0xf9,
0x03, 0x5c, 0xb9, 0x70, 0xe0, 0xc4, 0x81, 0x1b, 0x55, 0x5c, 0xa8, 0xfe, 0x9a, 0x9d, 0x4f, 0xed,
0x28, 0x16, 0x45, 0x71, 0xeb, 0x79, 0xfd, 0x3e, 0xfa, 0xbd, 0x7e, 0xef, 0x75, 0xbf, 0x7e, 0x03,
0xcb, 0x07, 0xd4, 0x1f, 0x06, 0xc4, 0x4e, 0x48, 0x7c, 0x40, 0xe2, 0xf5, 0x28, 0xa6, 0x8c, 0xa2,
0xa5, 0x1c, 0xd0, 0x8e, 0x76, 0xcc, 0xab, 0x80, 0x6e, 0x60, 0xe6, 0xec, 0xdd, 0x24, 0x3e, 0x61,
0xc4, 0x22, 0x8f, 0x86, 0x24, 0x61, 0xe8, 0x79, 0xe8, 0xec, 0x7a, 0x3e, 0xb1, 0x3d, 0x37, 0x19,
0xb4, 0xd6, 0xda, 0x17, 0xbb, 0xd6, 0x3c, 0xff, 0xbe, 0xe3, 0x26, 0xe6, 0x3d, 0x58, 0xce, 0x11,
0x24, 0x11, 0x0d, 0x13, 0x82, 0xde, 0x81, 0xf9, 0x98, 0x24, 0x43, 0x9f, 0x49, 0x82, 0xde, 0xc6,
0xb9, 0xf5, 0xa2, 0xac, 0xf5, 0x94, 0x64, 0xe8, 0x33, 0x4b, 0xa3, 0x9b, 0x5f, 0xb5, 0xa0, 0x9f,
0x9d, 0x41, 0xa7, 0x60, 0x5e, 0x09, 0x1f, 0xb4, 0xd6, 0x5a, 0x17, 0xbb, 0xd6, 0x9c, 0x94, 0x8d,
0x56, 0x61, 0x2e, 0x61, 0x98, 0x0d, 0x93, 0xc1, 0xf4, 0x5a, 0xeb, 0xe2, 0xac, 0xa5, 0xbe, 0xd0,
0x0a, 0xcc, 0x92, 0x38, 0xa6, 0xf1, 0xa0, 0x2d, 0xd0, 0xe5, 0x07, 0x42, 0x30, 0x93, 0x78, 0x4f,
0xc9, 0x60, 0x66, 0xad, 0x75, 0x71, 0xc1, 0x12, 0x63, 0x34, 0x80, 0xf9, 0x03, 0x12, 0x27, 0x1e,
0x0d, 0x07, 0xb3, 0x02, 0xac, 0x3f, 0xcd, 0x79, 0x98, 0xbd, 0x15, 0x44, 0x6c, 0x64, 0xbe, 0x0d,
0x83, 0x07, 0xd8, 0x19, 0x0e, 0x83, 0x07, 0x62, 0xf9, 0x9b, 0x7b, 0xc4, 0xd9, 0xd7, 0x66, 0x39,
0x0d, 0x5d, 0xa5, 0x94, 0x5a, 0xdb, 0x82, 0xd5, 0x91, 0x80, 0x3b, 0xae, 0xf9, 0x3d, 0x78, 0xbe,
0x82, 0x50, 0x99, 0xe7, 0x02, 0x2c, 0x3c, 0xc4, 0xf1, 0x0e, 0x7e, 0x48, 0xec, 0x18, 0x33, 0x8f,
0x0a, 0xea, 0x96, 0xd5, 0x57, 0x40, 0x8b, 0xc3, 0xcc, 0xcf, 0xc1, 0xc8, 0x71, 0xa0, 0x41, 0x84,
0x1d, 0xd6, 0x44, 0x38, 0x5a, 0x83, 0x5e, 0x14, 0x13, 0xec, 0xfb, 0xd4, 0xc1, 0x8c, 0x08, 0xfb,
0xb4, 0xad, 0x2c, 0xc8, 0x3c, 0x0b, 0xa7, 0x2b, 0x99, 0xcb, 0x05, 0x9a, 0xef, 0x14, 0x56, 0x4f,
0x83, 0xc0, 0x6b, 0x24, 0xda, 0x3c, 0x53, 0x5a, 0xb5, 0xa0, 0x54, 0x7c, 0xbf, 0x5d, 0x98, 0xf5,
0x09, 0x0e, 0x87, 0x51, 0x23, 0xc6, 0xc5, 0x15, 0x6b, 0xd2, 0x94, 0xf3, 0x29, 0xe9, 0x36, 0x9b,
0xd4, 0xf7, 0x89, 0xc3, 0x3c, 0x1a, 0x6a, 0xb6, 0xe7, 0x00, 0x9c, 0x14, 0xa8, 0x9c, 0x28, 0x03,
0x31, 0x0d, 0x18, 0x94, 0x49, 0x15, 0xdb, 0xbf, 0xb6, 0xe0, 0xb9, 0xeb, 0xca, 0x68, 0x52, 0x70,
0xa3, 0x0d, 0xc8, 0x8b, 0x9c, 0x2e, 0x8a, 0x2c, 0x6e, 0x50, 0xbb, 0xb4, 0x41, 0x1c, 0x23, 0x26,
0x91, 0xef, 0x39, 0x58, 0xb0, 0x98, 0x11, 0x2c, 0xb2, 0x20, 0xb4, 0x04, 0x6d, 0xc6, 0x7c, 0xe1,
0xb9, 0x5d, 0x8b, 0x0f, 0xd1, 0x06, 0xac, 0x06, 0x24, 0xa0, 0xf1, 0xc8, 0x0e, 0x70, 0x64, 0x07,
0xf8, 0x89, 0xcd, 0xdd, 0xdc, 0x0e, 0x76, 0x06, 0x73, 0x62, 0x7d, 0x48, 0xce, 0xde, 0xc5, 0xd1,
0x5d, 0xfc, 0x64, 0xdb, 0x7b, 0x4a, 0xee, 0xee, 0x98, 0x03, 0x58, 0x2d, 0xea, 0xa7, 0x54, 0xff,
0x16, 0x9c, 0x92, 0x90, 0xed, 0x51, 0xe8, 0x6c, 0x8b, 0xd8, 0x6a, 0xb4, 0x51, 0xff, 0x6e, 0xc1,
0xa0, 0x4c, 0xa8, 0x3c, 0xff, 0x59, 0xad, 0x76, 0x64, 0x9b, 0x9c, 0x87, 0x1e, 0xc3, 0x9e, 0x6f,
0xd3, 0xdd, 0xdd, 0x84, 0x30, 0x61, 0x88, 0x19, 0x0b, 0x38, 0xe8, 0x9e, 0x80, 0xa0, 0x4b, 0xb0,
0xe4, 0x48, 0xef, 0xb7, 0x63, 0x72, 0xe0, 0x89, 0x6c, 0x30, 0x2f, 0x16, 0xb6, 0xe8, 0xe8, 0xa8,
0x90, 0x60, 0x64, 0xc2, 0x82, 0xe7, 0x3e, 0xb1, 0x45, 0x3a, 0x12, 0xc9, 0xa4, 0x23, 0xb8, 0xf5,
0x3c, 0xf7, 0xc9, 0x6d, 0xcf, 0x27, 0xdc, 0xa2, 0xe6, 0x03, 0x38, 0x23, 0x95, 0xbf, 0x13, 0x3a,
0x31, 0x09, 0x48, 0xc8, 0xb0, 0xbf, 0x49, 0xa3, 0x51, 0x23, 0xb7, 0x79, 0x1e, 0x3a, 0x89, 0x17,
0x3a, 0xc4, 0x0e, 0x65, 0x52, 0x9b, 0xb1, 0xe6, 0xc5, 0xf7, 0x56, 0x62, 0xde, 0x80, 0xb3, 0x35,
0x7c, 0x95, 0x65, 0x5f, 0x80, 0xbe, 0x58, 0x98, 0x43, 0x43, 0x46, 0x42, 0x26, 0x78, 0xf7, 0xad,
0x1e, 0x87, 0x6d, 0x4a, 0x90, 0xf9, 0x3a, 0x20, 0xc9, 0xe3, 0x2e, 0x1d, 0x86, 0xcd, 0xc2, 0xf9,
0x39, 0x58, 0xce, 0x91, 0x28, 0xdf, 0x78, 0x03, 0x56, 0x24, 0xf8, 0xd3, 0x30, 0x68, 0xcc, 0xeb,
0x14, 0x3c, 0x57, 0x20, 0x52, 0xdc, 0x36, 0xb4, 0x90, 0xfc, 0xb1, 0x73, 0x28, 0xb3, 0x55, 0xbd,
0x82, 0xfc, 0xc9, 0x23, 0x32, 0x97, 0x5c, 0x30, 0x8e, 0xf7, 0x2d, 0x82, 0x5d, 0x1a, 0xfa, 0xa3,
0xc6, 0x99, 0xab, 0x82, 0x52, 0xf1, 0xfd, 0x43, 0x0b, 0x4e, 0xea, 0x94, 0xd6, 0x70, 0x37, 0x8f,
0xe8, 0xce, 0xed, 0x5a, 0x77, 0x9e, 0x19, 0xbb, 0xf3, 0x45, 0x58, 0x4a, 0xe8, 0x30, 0x76, 0x88,
0xed, 0x62, 0x86, 0xed, 0x90, 0xba, 0x44, 0x79, 0xfb, 0x09, 0x09, 0xbf, 0x89, 0x19, 0xde, 0xa2,
0x2e, 0x31, 0xbf, 0xab, 0x37, 0x3b, 0xe7, 0x25, 0x97, 0xe0, 0xa4, 0x8f, 0x13, 0x66, 0xe3, 0x28,
0x22, 0xa1, 0x6b, 0x63, 0xc6, 0x5d, 0xad, 0x25, 0x5c, 0xed, 0x04, 0x9f, 0xb8, 0x2e, 0xe0, 0xd7,
0xd9, 0x56, 0x62, 0xfe, 0x76, 0x1a, 0x16, 0x39, 0x2d, 0x77, 0xed, 0x46, 0xfa, 0x2e, 0x41, 0x9b,
0x3c, 0x61, 0x4a, 0x51, 0x3e, 0x44, 0x57, 0x61, 0x59, 0xc5, 0x90, 0x47, 0xc3, 0x71, 0x78, 0xb5,
0x65, 0x36, 0x1a, 0x4f, 0xa5, 0x11, 0x76, 0x1e, 0x7a, 0x09, 0xa3, 0x91, 0x8e, 0xd6, 0x19, 0x19,
0xad, 0x1c, 0xa4, 0xa2, 0x35, 0x6f, 0xd3, 0xd9, 0x0a, 0x9b, 0xf6, 0xbd, 0xc4, 0x26, 0x8e, 0x2d,
0x57, 0x25, 0xe2, 0xbd, 0x63, 0x81, 0x97, 0xdc, 0x72, 0xa4, 0x35, 0xd0, 0x07, 0x70, 0xc6, 0x7b,
0x18, 0xd2, 0x98, 0xd8, 0xca, 0x90, 0x22, 0x6a, 0x42, 0xca, 0xec, 0x5d, 0x3a, 0x0c, 0x5d, 0x11,
0xfb, 0x1d, 0x6b, 0x20, 0x71, 0xb6, 0x05, 0x0a, 0xb7, 0xc0, 0x16, 0x65, 0xb7, 0xf9, 0xbc, 0xf9,
0x16, 0x2c, 0x8d, 0xad, 0xd2, 0x3c, 0xf6, 0xbe, 0x6a, 0xe9, 0x74, 0x7a, 0x1f, 0x7b, 0xfe, 0x36,
0x09, 0x5d, 0x12, 0x3f, 0x63, 0x4e, 0x40, 0xd7, 0x60, 0xc5, 0x73, 0x7d, 0x62, 0x33, 0x2f, 0x20,
0x74, 0xc8, 0xec, 0x84, 0x38, 0x34, 0x74, 0x13, 0x6d, 0x5f, 0x3e, 0x77, 0x5f, 0x4e, 0x6d, 0xcb,
0x19, 0xf3, 0x17, 0x69, 0x6e, 0xce, 0xae, 0x62, 0x7c, 0x2b, 0x09, 0x09, 0xe1, 0x0c, 0xf7, 0x08,
0x76, 0x49, 0xac, 0xd4, 0xe8, 0x4b, 0xe0, 0x0f, 0x04, 0x8c, 0xef, 0x90, 0x42, 0xda, 0xa1, 0xee,
0x48, 0xac, 0xa8, 0x6f, 0x81, 0x04, 0xdd, 0xa0, 0xee, 0x48, 0x24, 0xc9, 0xc4, 0x16, 0x4e, 0xe6,
0xec, 0x0d, 0xc3, 0x7d, 0xb1, 0x9a, 0x8e, 0xd5, 0xf3, 0x92, 0x8f, 0x70, 0xc2, 0x36, 0x39, 0xc8,
0xfc, 0x63, 0x4b, 0x47, 0x29, 0x5f, 0x86, 0x45, 0x1c, 0xe2, 0x1d, 0xfc, 0x0f, 0xcc, 0xc1, 0x29,
0x94, 0x13, 0xe4, 0x6e, 0xa7, 0x2a, 0xe0, 0x90, 0x9c, 0x53, 0x67, 0x99, 0x98, 0x19, 0x27, 0x89,
0xfc, 0xc2, 0x55, 0x92, 0xf8, 0x42, 0x27, 0xe9, 0x5b, 0xce, 0xf6, 0x1e, 0x8e, 0xdd, 0xe4, 0xfb,
0x24, 0x24, 0x31, 0x66, 0xc7, 0x72, 0x69, 0x30, 0xd7, 0xe0, 0x5c, 0x1d, 0x77, 0x25, 0xff, 0x73,
0x7d, 0xf8, 0x68, 0x0c, 0x8b, 0xec, 0x0c, 0x3d, 0xdf, 0x3d, 0x16, 0xf1, 0x1f, 0x16, 0x95, 0x4b,
0x99, 0x2b, 0xff, 0xb9, 0x0c, 0x27, 0x63, 0x01, 0x62, 0x76, 0xc2, 0x11, 0xd2, 0x7a, 0x61, 0xc1,
0x5a, 0x54, 0x13, 0x82, 0x90, 0xd7, 0x0d, 0x7f, 0x4f, 0x3d, 0x40, 0x73, 0x3b, 0xb6, 0xb4, 0x7a,
0x1a, 0xba, 0x63, 0xf1, 0x6d, 0x21, 0xbe, 0x93, 0x28, 0xb9, 0xdc, 0x3b, 0x1d, 0x1a, 0x8d, 0x6c,
0xe2, 0xc8, 0x73, 0x5c, 0x6c, 0x75, 0xc7, 0xea, 0x71, 0xe0, 0x2d, 0x47, 0x1c, 0xe3, 0xcd, 0x73,
0x6c, 0x86, 0xdb, 0x97, 0x92, 0xdb, 0x5c, 0x96, 0xdb, 0x97, 0x9c, 0xdb, 0xd8, 0x63, 0xf2, 0x8a,
0xaa, 0x1d, 0x7b, 0x0c, 0xa7, 0xf3, 0xb3, 0xcd, 0x8f, 0xc0, 0x67, 0x32, 0x84, 0x79, 0xae, 0xe8,
0x2a, 0x85, 0x73, 0xf4, 0xa0, 0xb8, 0xec, 0xc6, 0x77, 0x86, 0x67, 0x5b, 0xd7, 0xd9, 0xa2, 0x41,
0xf2, 0x17, 0x8f, 0xcf, 0x8a, 0xcb, 0x3e, 0xc2, 0x05, 0xe4, 0x70, 0xc1, 0xe7, 0x8b, 0xee, 0x5d,
0xbc, 0xa5, 0xfc, 0x2e, 0xcd, 0x9d, 0x0a, 0x83, 0xdf, 0x11, 0x1a, 0xe7, 0x2c, 0x25, 0x57, 0x98,
0x63, 0xc1, 0x9a, 0x57, 0x62, 0x79, 0x11, 0xab, 0xce, 0x3a, 0x59, 0x03, 0xa8, 0xaf, 0x5c, 0xb9,
0xda, 0x56, 0xe5, 0xaa, 0x2e, 0xc3, 0xf7, 0xc9, 0x48, 0xf8, 0xe3, 0x8c, 0x2c, 0xc3, 0x3f, 0x24,
0x23, 0x73, 0xab, 0x10, 0x4d, 0x72, 0x69, 0x2a, 0x2e, 0x11, 0xcc, 0x70, 0x47, 0x56, 0xe9, 0x5c,
0x8c, 0xd1, 0x59, 0x00, 0x2f, 0xb1, 0x5d, 0xb1, 0xe7, 0x72, 0x51, 0x1d, 0xab, 0xeb, 0x29, 0x27,
0x70, 0xcd, 0x5f, 0x65, 0xc2, 0xf3, 0x86, 0x4f, 0x77, 0x8e, 0xd1, 0x2b, 0xb3, 0x5a, 0xb4, 0x73,
0x5a, 0x64, 0xeb, 0xf1, 0x99, 0x7c, 0x3d, 0x9e, 0x09, 0xa2, 0xec, 0x72, 0xea, 0xd2, 0xee, 0x7d,
0x7a, 0x7c, 0xb5, 0x5a, 0x39, 0xed, 0x8e, 0xb9, 0x2b, 0xf9, 0xef, 0xc2, 0x69, 0x6e, 0x70, 0x09,
0x15, 0x95, 0x40, 0xf3, 0x6a, 0xe9, 0x1f, 0xd3, 0x70, 0xa6, 0x9a, 0xb8, 0x49, 0xc5, 0xf4, 0x1e,
0x18, 0x69, 0x45, 0xc2, 0x8f, 0xbd, 0x84, 0xe1, 0x20, 0x4a, 0x0f, 0x3e, 0x79, 0x3e, 0x9e, 0x52,
0xe5, 0xc9, 0x7d, 0x3d, 0xaf, 0x4f, 0xbf, 0x52, 0x39, 0xd3, 0x2e, 0x95, 0x33, 0x5c, 0x80, 0x8b,
0x59, 0x9d, 0x00, 0x79, 0x3f, 0x3b, 0xe5, 0x62, 0x56, 0x27, 0x20, 0x25, 0x16, 0x02, 0xa4, 0xd7,
0xf6, 0x14, 0xbe, 0x10, 0x70, 0x16, 0x40, 0x5d, 0x9d, 0x86, 0xa1, 0x2e, 0xcf, 0xba, 0xf2, 0xe2,
0x34, 0x0c, 0x6b, 0x6f, 0x90, 0xf3, 0xb5, 0x37, 0xc8, 0xfc, 0x6e, 0x76, 0x4a, 0xbb, 0xf9, 0x19,
0xc0, 0x4d, 0x2f, 0xd9, 0x97, 0x46, 0xe6, 0x57, 0x56, 0xd7, 0x8b, 0xd5, 0x9b, 0x00, 0x1f, 0x72,
0x08, 0xf6, 0x7d, 0x65, 0x3a, 0x3e, 0xe4, 0xe1, 0x33, 0x4c, 0x88, 0xab, 0xac, 0x23, 0xc6, 0x1c,
0xb6, 0x1b, 0x13, 0xa2, 0x0c, 0x20, 0xc6, 0xe6, 0xef, 0x5b, 0xd0, 0xbd, 0x4b, 0x02, 0xc5, 0xf9,
0x1c, 0xc0, 0x43, 0x1a, 0xd3, 0x21, 0xf3, 0x42, 0x22, 0x6f, 0xd8, 0xb3, 0x56, 0x06, 0xf2, 0xcd,
0xe5, 0x88, 0xd4, 0x40, 0xfc, 0x5d, 0x65, 0x4c, 0x31, 0xe6, 0xb0, 0x3d, 0x82, 0x23, 0x65, 0x3f,
0x31, 0x46, 0x2b, 0x30, 0x9b, 0x30, 0xec, 0xec, 0x0b, 0x63, 0xcd, 0x58, 0xf2, 0xc3, 0xfc, 0x53,
0x0b, 0xc0, 0x22, 0x01, 0x65, 0xc2, 0xd7, 0xf8, 0xcd, 0x75, 0x07, 0x3b, 0xfb, 0xbc, 0x16, 0x60,
0xa3, 0x88, 0x28, 0x4b, 0xf4, 0x14, 0xec, 0xfe, 0x28, 0x12, 0x3b, 0xa4, 0x51, 0x54, 0xfe, 0xea,
0x5a, 0x5d, 0x05, 0x91, 0xb7, 0x7e, 0x1d, 0xca, 0x5d, 0x8b, 0x0f, 0x33, 0x39, 0x4d, 0x2e, 0x5b,
0xe7, 0xb4, 0xd3, 0xd0, 0x2d, 0xba, 0x82, 0x48, 0x05, 0xc2, 0x0f, 0x2e, 0xc0, 0x42, 0x40, 0x5d,
0x6f, 0xd7, 0x23, 0xae, 0x70, 0x34, 0xa5, 0x4a, 0x5f, 0x03, 0xb9, 0x73, 0x99, 0x37, 0xe1, 0x84,
0xba, 0x7d, 0x79, 0x24, 0xbe, 0x13, 0xee, 0x52, 0xb4, 0x01, 0xb3, 0x9c, 0x85, 0x7e, 0x66, 0x3c,
0x53, 0x7e, 0x66, 0x1c, 0x2b, 0x6b, 0x49, 0x54, 0xf3, 0xeb, 0x16, 0xac, 0x8d, 0xd9, 0xdc, 0xa5,
0x07, 0xfc, 0x40, 0xbf, 0x4f, 0x25, 0xe2, 0xb1, 0xe4, 0xb8, 0x77, 0x60, 0xe0, 0x92, 0x84, 0x79,
0xa1, 0x28, 0xe3, 0x6c, 0x6d, 0xbe, 0x10, 0x07, 0x44, 0x19, 0x6a, 0x35, 0x33, 0x7f, 0x43, 0x4e,
0x6f, 0xe1, 0x80, 0xa0, 0x2b, 0xb0, 0xbc, 0x4f, 0x48, 0x64, 0xfb, 0xd4, 0xc1, 0xbe, 0xad, 0xa3,
0x47, 0xdd, 0x52, 0x96, 0xf8, 0xd4, 0x47, 0x7c, 0xe6, 0xa6, 0x8c, 0x20, 0x33, 0x81, 0x17, 0x0e,
0xd1, 0x44, 0x65, 0x90, 0x33, 0xd0, 0x8d, 0x62, 0xea, 0x90, 0x84, 0x7b, 0x57, 0x4b, 0x1c, 0x28,
0x63, 0x00, 0xba, 0x06, 0xcb, 0xe9, 0xc7, 0xc7, 0x24, 0x76, 0x48, 0xc8, 0xf0, 0x43, 0xf9, 0x66,
0x38, 0x6d, 0x55, 0x4d, 0x99, 0xbf, 0x69, 0x81, 0x59, 0x92, 0x7a, 0x3b, 0xa6, 0xc1, 0x31, 0x5a,
0xf0, 0x2a, 0xac, 0x08, 0x3b, 0xc4, 0x82, 0xe5, 0xd8, 0x10, 0xb2, 0x98, 0x38, 0xc9, 0xe7, 0xa4,
0x34, 0x6d, 0x89, 0x21, 0x5c, 0x38, 0x74, 0x4d, 0xff, 0x25, 0x5b, 0xfc, 0xab, 0x0f, 0xfd, 0x4f,
0x86, 0x24, 0x1e, 0x65, 0x1e, 0x1b, 0x13, 0xa2, 0xb4, 0xd0, 0xaf, 0xe5, 0x19, 0x08, 0xcf, 0x89,
0xbb, 0x31, 0x0d, 0xec, 0xf4, 0x41, 0x7d, 0x5a, 0xa0, 0xf4, 0x38, 0xf0, 0xb6, 0x7c, 0x54, 0x47,
0xef, 0xc3, 0xdc, 0xae, 0xe7, 0x33, 0x22, 0x9f, 0xb0, 0x7b, 0x1b, 0x2f, 0x95, 0xbd, 0x3a, 0x2b,
0x73, 0xfd, 0xb6, 0x40, 0xb6, 0x14, 0x11, 0xda, 0x81, 0x65, 0x2f, 0x8c, 0x44, 0x01, 0x14, 0x7b,
0xd8, 0xf7, 0x9e, 0x8e, 0x9f, 0xcb, 0x7a, 0x1b, 0xaf, 0x4f, 0xe0, 0x75, 0x87, 0x53, 0x6e, 0x67,
0x09, 0x2d, 0xe4, 0x95, 0x60, 0x88, 0xc0, 0x0a, 0x1d, 0xb2, 0xb2, 0x90, 0x59, 0x21, 0x64, 0x63,
0x82, 0x90, 0x7b, 0x82, 0x34, 0x2f, 0x65, 0x99, 0x96, 0x81, 0xc6, 0x16, 0xcc, 0x49, 0xe5, 0x78,
0x36, 0xdb, 0xf5, 0x88, 0xaf, 0x9b, 0x00, 0xf2, 0x83, 0xdf, 0x18, 0x68, 0x44, 0x62, 0x1c, 0xea,
0xc4, 0xa4, 0x3f, 0x39, 0xfe, 0x01, 0xf6, 0x87, 0x3a, 0xde, 0xe4, 0x87, 0xf1, 0x97, 0x59, 0x40,
0x65, 0x0d, 0xf5, 0x1b, 0x60, 0x4c, 0x12, 0x7e, 0x86, 0x64, 0x33, 0xe1, 0x62, 0x06, 0x2e, 0xb2,
0xe1, 0x8f, 0xa0, 0xeb, 0x24, 0x07, 0xb6, 0x30, 0x89, 0x90, 0xd9, 0xdb, 0x78, 0xf7, 0xc8, 0x26,
0x5d, 0xdf, 0xdc, 0x7e, 0x20, 0xa0, 0x56, 0xc7, 0x49, 0x0e, 0xc4, 0x08, 0xfd, 0x04, 0xe0, 0xcb,
0x84, 0x86, 0x8a, 0xb3, 0xdc, 0xf8, 0xf7, 0x8e, 0xce, 0xf9, 0x87, 0xdb, 0xf7, 0xb6, 0x24, 0xeb,
0x2e, 0x67, 0x27, 0x79, 0x3b, 0xb0, 0x10, 0xe1, 0xf8, 0xd1, 0x90, 0x30, 0xc5, 0x5e, 0xfa, 0xc2,
0x07, 0x47, 0x67, 0xff, 0xb1, 0x64, 0x23, 0x25, 0xf4, 0xa3, 0xcc, 0x97, 0xf1, 0xf5, 0x34, 0x74,
0xb4, 0x5e, 0xbc, 0x86, 0x12, 0x1e, 0x2e, 0x5f, 0x12, 0x6c, 0x2f, 0xdc, 0xa5, 0xca, 0xa2, 0x27,
0x38, 0x5c, 0x3e, 0x26, 0x88, 0x0c, 0x7e, 0x09, 0x96, 0x62, 0xe2, 0xd0, 0xd8, 0xe5, 0xb7, 0x51,
0x2f, 0xf0, 0xb8, 0xdb, 0xcb, 0xbd, 0x5c, 0x94, 0xf0, 0x9b, 0x1a, 0x8c, 0x5e, 0x81, 0x45, 0xb1,
0xed, 0x19, 0xcc, 0xb6, 0xe6, 0x49, 0xfc, 0x0c, 0xe2, 0x25, 0x58, 0x7a, 0x34, 0xe4, 0x79, 0xc3,
0xd9, 0xc3, 0x31, 0x76, 0x18, 0x4d, 0x6b, 0xfa, 0x45, 0x01, 0xdf, 0x4c, 0xc1, 0xe8, 0x4d, 0x58,
0x95, 0xa8, 0x24, 0x71, 0x70, 0x94, 0x52, 0x90, 0x58, 0x95, 0x7c, 0x2b, 0x62, 0xf6, 0x96, 0x98,
0xdc, 0xd4, 0x73, 0xc8, 0x80, 0x8e, 0x43, 0x83, 0x80, 0x84, 0x2c, 0x11, 0x07, 0x55, 0xd7, 0x4a,
0xbf, 0xd1, 0x75, 0x38, 0x8b, 0x7d, 0x9f, 0x3e, 0xb6, 0x05, 0xa5, 0x6b, 0x97, 0xb4, 0x93, 0x2f,
0x4c, 0x86, 0x40, 0xfa, 0x44, 0xe0, 0x58, 0x79, 0x45, 0x8d, 0xf3, 0xd0, 0x4d, 0xf7, 0x91, 0x9f,
0xed, 0x19, 0x87, 0x14, 0x63, 0xe3, 0x04, 0xf4, 0xb3, 0x3b, 0x61, 0xfc, 0xb3, 0x0d, 0xcb, 0x15,
0x41, 0x85, 0x3e, 0x07, 0xe0, 0xde, 0x2a, 0x43, 0x4b, 0xb9, 0xeb, 0x77, 0x8e, 0x1e, 0x9c, 0xdc,
0x5f, 0x25, 0xd8, 0xe2, 0xde, 0x2f, 0x87, 0xe8, 0xa7, 0xd0, 0x13, 0x1e, 0xab, 0xb8, 0x4b, 0x97,
0x7d, 0xff, 0x1b, 0x70, 0xe7, 0xba, 0x2a, 0xf6, 0x22, 0x06, 0xe4, 0xd8, 0xf8, 0x5b, 0x0b, 0xba,
0xa9, 0x60, 0x7e, 0x53, 0x91, 0x1b, 0x25, 0xf6, 0x3a, 0xd1, 0x37, 0x15, 0x01, 0xbb, 0x2d, 0x40,
0xff, 0x97, 0xae, 0x64, 0xbc, 0x0d, 0x30, 0xd6, 0xbf, 0x52, 0x85, 0x56, 0xa5, 0x0a, 0xe6, 0x25,
0x58, 0xe0, 0x96, 0xf5, 0x88, 0xbb, 0xcd, 0x62, 0x2f, 0x12, 0xed, 0x4c, 0x89, 0x93, 0xa8, 0x52,
0x4f, 0x7f, 0x6e, 0xfc, 0xd9, 0x80, 0x7e, 0xf6, 0x19, 0x0b, 0x7d, 0x01, 0xbd, 0x4c, 0xdb, 0x16,
0xbd, 0x58, 0xde, 0xb4, 0x72, 0x1b, 0xd8, 0x78, 0x69, 0x02, 0x96, 0xaa, 0x86, 0xa6, 0x50, 0x08,
0x27, 0x4b, 0xbd, 0x4f, 0x74, 0xb9, 0x4c, 0x5d, 0xd7, 0x59, 0x35, 0x5e, 0x6d, 0x84, 0x9b, 0xca,
0x63, 0xb0, 0x5c, 0xd1, 0xcc, 0x44, 0xaf, 0x4d, 0xe0, 0x92, 0x6b, 0xa8, 0x1a, 0x57, 0x1a, 0x62,
0xa7, 0x52, 0x1f, 0x01, 0x2a, 0x77, 0x3a, 0xd1, 0xab, 0x13, 0xd9, 0x8c, 0x3b, 0xa9, 0xc6, 0x6b,
0xcd, 0x90, 0x6b, 0x15, 0x95, 0x3d, 0xd0, 0x89, 0x8a, 0xe6, 0xba, 0xac, 0x13, 0x15, 0x2d, 0x34,
0x56, 0xa7, 0xd0, 0x3e, 0x2c, 0x15, 0xfb, 0xa3, 0xe8, 0x52, 0x5d, 0x3f, 0xbf, 0xd4, 0x7e, 0x35,
0x2e, 0x37, 0x41, 0x4d, 0x85, 0x11, 0x38, 0x91, 0xef, 0x47, 0xa2, 0x57, 0xca, 0xf4, 0x95, 0x1d,
0x59, 0xe3, 0xe2, 0x64, 0xc4, 0xac, 0x4e, 0xc5, 0x1e, 0x65, 0x95, 0x4e, 0x35, 0x0d, 0xd0, 0x2a,
0x9d, 0xea, 0x5a, 0x9e, 0xe6, 0x14, 0xfa, 0x99, 0x6e, 0x7c, 0x15, 0x7a, 0x77, 0x68, 0xbd, 0x8e,
0x4d, 0x75, 0xf3, 0xd0, 0xb8, 0xda, 0x18, 0x5f, 0xcb, 0xbe, 0xd6, 0xe2, 0xb1, 0x9e, 0x69, 0xe1,
0x55, 0xc5, 0x7a, 0xb9, 0x29, 0x58, 0x15, 0xeb, 0x55, 0x7d, 0xc0, 0x29, 0xb4, 0x03, 0x0b, 0xb9,
0xa6, 0x1e, 0x7a, 0xb9, 0x8e, 0x32, 0xff, 0x52, 0x67, 0xbc, 0x32, 0x11, 0x2f, 0x95, 0x61, 0xeb,
0xec, 0xa5, 0xd2, 0x55, 0xed, 0xe2, 0xf2, 0xf9, 0xea, 0xe5, 0x49, 0x68, 0xb9, 0x50, 0x2e, 0xb5,
0xfe, 0x2a, 0x43, 0xb9, 0xae, 0xb5, 0x58, 0x19, 0xca, 0xf5, 0xdd, 0xc4, 0x29, 0xf4, 0x63, 0x80,
0x71, 0x7b, 0x0e, 0x5d, 0xa8, 0xa3, 0xce, 0xee, 0xfe, 0x8b, 0x87, 0x23, 0xa5, 0xac, 0x1f, 0xc3,
0x4a, 0xd5, 0x8b, 0x12, 0xba, 0x52, 0x55, 0x1c, 0xd7, 0x3e, 0x5b, 0x19, 0xeb, 0x4d, 0xd1, 0x53,
0xc1, 0x9f, 0x42, 0x47, 0xb7, 0xc6, 0xd0, 0x0b, 0x65, 0xea, 0x42, 0x33, 0xd1, 0x30, 0x0f, 0x43,
0xc9, 0x38, 0x70, 0xa0, 0x63, 0x75, 0xdc, 0xb3, 0xaa, 0x8f, 0xd5, 0x52, 0x77, 0xad, 0x3e, 0x56,
0xcb, 0x2d, 0x30, 0x21, 0x2e, 0x75, 0x86, 0x6c, 0x8b, 0xa7, 0xde, 0x19, 0x2a, 0x3a, 0x58, 0xf5,
0xce, 0x50, 0xd9, 0x35, 0x9a, 0x42, 0x3f, 0x87, 0xd5, 0xea, 0xce, 0x0e, 0xaa, 0x8d, 0xf8, 0x9a,
0x0e, 0x93, 0x71, 0xad, 0x39, 0x41, 0x2a, 0xfe, 0xa9, 0xce, 0x4f, 0x85, 0xce, 0x4e, 0x7d, 0x7e,
0xaa, 0xee, 0x2f, 0x19, 0x57, 0x1b, 0xe3, 0x97, 0x43, 0x2f, 0xdb, 0x1e, 0xa9, 0xb7, 0x76, 0x45,
0xb7, 0xa8, 0xde, 0xda, 0x95, 0x1d, 0x17, 0x11, 0x1f, 0x55, 0xad, 0x8f, 0xaa, 0xf8, 0x38, 0xa4,
0x37, 0x63, 0xac, 0x37, 0x45, 0xcf, 0x1d, 0xdf, 0xe5, 0xde, 0x06, 0x9a, 0xb8, 0xfe, 0x5c, 0x66,
0xbe, 0xd2, 0x10, 0xbb, 0x7e, 0x77, 0x75, 0xa6, 0x9e, 0xa8, 0x40, 0x21, 0x63, 0x5f, 0x6d, 0x8c,
0x9f, 0xca, 0x8e, 0xf4, 0x4f, 0x13, 0x99, 0xbe, 0x04, 0xba, 0x3c, 0x81, 0x4f, 0xa6, 0xaf, 0x62,
0xbc, 0xda, 0x08, 0xb7, 0x2a, 0x7a, 0xb3, 0x9d, 0x82, 0xc3, 0xfc, 0xa9, 0xd4, 0xde, 0x38, 0xcc,
0x9f, 0x2a, 0x9a, 0x0f, 0x15, 0xd1, 0xab, 0x1b, 0x04, 0x93, 0xa3, 0xb7, 0xd0, 0xa8, 0x98, 0x1c,
0xbd, 0xa5, 0xde, 0xc3, 0x14, 0xfa, 0xe5, 0xb8, 0x99, 0x5e, 0x7e, 0x04, 0x44, 0x1b, 0xb5, 0xa9,
0xa8, 0xf6, 0xed, 0xd3, 0x78, 0xe3, 0x48, 0x34, 0x19, 0xe3, 0xff, 0xba, 0xa5, 0xbb, 0x77, 0x95,
0xaf, 0x70, 0xe8, 0xcd, 0x06, 0x8c, 0x4b, 0x0f, 0x89, 0xc6, 0x5b, 0x47, 0xa4, 0xca, 0x2c, 0xe8,
0x23, 0x98, 0x15, 0xd5, 0x27, 0x3a, 0x77, 0x78, 0x59, 0x6a, 0x9c, 0xaf, 0x9e, 0x4f, 0x8b, 0x2b,
0xce, 0x6d, 0x67, 0x4e, 0xfc, 0x36, 0xfb, 0xc6, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xb3, 0xd7,
0xc4, 0x53, 0x4d, 0x2b, 0x00, 0x00,
}

85
weed/server/volume_grpc_tier_download.go Normal file
View file

@ -0,0 +1,85 @@
package weed_server
import (
"fmt"
"time"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
"github.com/chrislusf/seaweedfs/weed/storage/backend"
"github.com/chrislusf/seaweedfs/weed/storage/needle"
)
// VolumeTierMoveDatFromRemote copy dat file from a remote tier to local volume server
func (vs *VolumeServer) VolumeTierMoveDatFromRemote(req *volume_server_pb.VolumeTierMoveDatFromRemoteRequest, stream volume_server_pb.VolumeServer_VolumeTierMoveDatFromRemoteServer) error {
// find existing volume
v := vs.store.GetVolume(needle.VolumeId(req.VolumeId))
if v == nil {
return fmt.Errorf("volume %d not found", req.VolumeId)
}
// verify the collection
if v.Collection != req.Collection {
return fmt.Errorf("existing collection:%v unexpected input: %v", v.Collection, req.Collection)
}
// locate the disk file
storageName, storageKey := v.RemoteStorageNameKey()
if storageName == "" || storageKey == "" {
return fmt.Errorf("volume %d is already on local disk", req.VolumeId)
}
// check whether the local .dat already exists
_, ok := v.DataBackend.(*backend.DiskFile)
if ok {
return fmt.Errorf("volume %d is already on local disk", req.VolumeId)
}
// check valid storage backend type
backendStorage, found := backend.BackendStorages[storageName]
if !found {
var keys []string
for key := range backend.BackendStorages {
keys = append(keys, key)
}
return fmt.Errorf("remote storage %s not found from suppported: %v", storageName, keys)
}
startTime := time.Now()
fn := func(progressed int64, percentage float32) error {
now := time.Now()
if now.Sub(startTime) < time.Second {
return nil
}
startTime = now
return stream.Send(&volume_server_pb.VolumeTierMoveDatFromRemoteResponse{
Processed: progressed,
ProcessedPercentage: percentage,
})
}
// copy the data file
_, err := backendStorage.DownloadFile(v.FileName()+".dat", storageKey, fn)
if err != nil {
return fmt.Errorf("backend %s copy file %s: %v", storageName, v.FileName()+".dat", err)
}
if req.KeepRemoteDatFile {
return nil
}
// remove remote file
if err := backendStorage.DeleteFile(storageKey); err != nil {
return fmt.Errorf("volume %d fail to delete remote file %s: %v", v.Id, storageKey, err)
}
// forget remote file
v.GetVolumeTierInfo().Files = v.GetVolumeTierInfo().Files[1:]
if err := v.SaveVolumeTierInfo(); err != nil {
return fmt.Errorf("volume %d fail to save remote file info: %v", v.Id, err)
}
v.DataBackend.Close()
v.DataBackend = nil
return nil
}

6
weed/server/volume_grpc_tier.go → weed/server/volume_grpc_tier_upload.go
View file

@ -10,8 +10,8 @@ import (
"github.com/chrislusf/seaweedfs/weed/storage/needle"
)
// VolumeTierCopyDatToRemote copy dat file to a remote tier
func (vs *VolumeServer) VolumeTierCopyDatToRemote(req *volume_server_pb.VolumeTierCopyDatToRemoteRequest, stream volume_server_pb.VolumeServer_VolumeTierCopyDatToRemoteServer) error {
// VolumeTierMoveDatToRemote copy dat file to a remote tier
func (vs *VolumeServer) VolumeTierMoveDatToRemote(req *volume_server_pb.VolumeTierMoveDatToRemoteRequest, stream volume_server_pb.VolumeServer_VolumeTierMoveDatToRemoteServer) error {
// find existing volume
v := vs.store.GetVolume(needle.VolumeId(req.VolumeId))
@ -56,7 +56,7 @@ func (vs *VolumeServer) VolumeTierCopyDatToRemote(req *volume_server_pb.VolumeTi
return nil
}
startTime = now
return stream.Send(&volume_server_pb.VolumeTierCopyDatToRemoteResponse{
return stream.Send(&volume_server_pb.VolumeTierMoveDatToRemoteResponse{
Processed: progressed,
ProcessedPercentage: percentage,
})

4
weed/shell/command_ec_decode.go
View file

@ -47,7 +47,7 @@ func (c *commandEcDecode) Do(args []string, commandEnv *CommandEnv, writer io.Wr
vid := needle.VolumeId(*volumeId)
// collect topology information
topologyInfo, err := collectTopologyInfoForEcDecode(ctx, commandEnv)
topologyInfo, err := collectTopologyInfo(ctx, commandEnv)
if err != nil {
return err
}
@ -203,7 +203,7 @@ func collectEcShards(ctx context.Context, commandEnv *CommandEnv, nodeToEcIndexB
}
func collectTopologyInfoForEcDecode(ctx context.Context, commandEnv *CommandEnv) (topoInfo *master_pb.TopologyInfo, err error) {
func collectTopologyInfo(ctx context.Context, commandEnv *CommandEnv) (topoInfo *master_pb.TopologyInfo, err error) {
var resp *master_pb.VolumeListResponse
err = commandEnv.MasterClient.WithClient(ctx, func(client master_pb.SeaweedClient) error {

167
weed/shell/command_volume_tier_download.go Normal file
View file

@ -0,0 +1,167 @@
package shell
import (
"context"
"flag"
"fmt"
"io"
"google.golang.org/grpc"
"github.com/chrislusf/seaweedfs/weed/operation"
"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
"github.com/chrislusf/seaweedfs/weed/storage/needle"
)
func init() {
Commands = append(Commands, &commandVolumeTierDownload{})
}
type commandVolumeTierDownload struct {
}
func (c *commandVolumeTierDownload) Name() string {
return "volume.tier.download"
}
func (c *commandVolumeTierDownload) Help() string {
return `move the dat file of a volume to a remote tier
volume.tier.download [-collection=""]
volume.tier.download [-collection=""] -volumeId=<volume_id>
e.g.:
volume.tier.download -volumeId=7
volume.tier.download -volumeId=7
This command will download the dat file of a volume from a remote tier to a volume server in local cluster.
`
}
func (c *commandVolumeTierDownload) Do(args []string, commandEnv *CommandEnv, writer io.Writer) (err error) {
tierCommand := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
volumeId := tierCommand.Int("volumeId", 0, "the volume id")
collection := tierCommand.String("collection", "", "the collection name")
if err = tierCommand.Parse(args); err != nil {
return nil
}
ctx := context.Background()
vid := needle.VolumeId(*volumeId)
// collect topology information
topologyInfo, err := collectTopologyInfo(ctx, commandEnv)
if err != nil {
return err
}
// volumeId is provided
if vid != 0 {
return doVolumeTierDownload(ctx, commandEnv, writer, *collection, vid)
}
// apply to all volumes in the collection
// reusing collectVolumeIdsForEcEncode for now
volumeIds := collectRemoteVolumes(topologyInfo, *collection)
if err != nil {
return err
}
fmt.Printf("tier download volumes: %v\n", volumeIds)
for _, vid := range volumeIds {
if err = doVolumeTierDownload(ctx, commandEnv, writer, *collection, vid); err != nil {
return err
}
}
return nil
}
func collectRemoteVolumes(topoInfo *master_pb.TopologyInfo, selectedCollection string) (vids []needle.VolumeId) {
vidMap := make(map[uint32]bool)
eachDataNode(topoInfo, func(dc string, rack RackId, dn *master_pb.DataNodeInfo) {
for _, v := range dn.VolumeInfos {
if v.Collection == selectedCollection && v.RemoteStorageKey != "" && v.RemoteStorageName != "" {
vidMap[v.Id] = true
}
}
})
for vid := range vidMap {
vids = append(vids, needle.VolumeId(vid))
}
return
}
func doVolumeTierDownload(ctx context.Context, commandEnv *CommandEnv, writer io.Writer, collection string, vid needle.VolumeId) (err error) {
// find volume location
locations, found := commandEnv.MasterClient.GetLocations(uint32(vid))
if !found {
return fmt.Errorf("volume %d not found", vid)
}
// TODO parallelize this
for _, loc := range locations {
// copy the .dat file from remote tier to local
err = downloadDatFromRemoteTier(ctx, commandEnv.option.GrpcDialOption, writer, needle.VolumeId(vid), collection, loc.Url)
if err != nil {
return fmt.Errorf("download dat file for volume %d to %s: %v", vid, loc.Url, err)
}
}
return nil
}
func downloadDatFromRemoteTier(ctx context.Context, grpcDialOption grpc.DialOption, writer io.Writer, volumeId needle.VolumeId, collection string, targetVolumeServer string) error {
err := operation.WithVolumeServerClient(targetVolumeServer, grpcDialOption, func(volumeServerClient volume_server_pb.VolumeServerClient) error {
stream, downloadErr := volumeServerClient.VolumeTierMoveDatFromRemote(ctx, &volume_server_pb.VolumeTierMoveDatFromRemoteRequest{
VolumeId: uint32(volumeId),
Collection: collection,
})
var lastProcessed int64
for {
resp, recvErr := stream.Recv()
if recvErr != nil {
if recvErr == io.EOF {
break
} else {
return recvErr
}
}
processingSpeed := float64(resp.Processed-lastProcessed) / 1024.0 / 1024.0
fmt.Fprintf(writer, "downloaded %.2f%%, %d bytes, %.2fMB/s\n", resp.ProcessedPercentage, resp.Processed, processingSpeed)
lastProcessed = resp.Processed
}
if downloadErr != nil {
return downloadErr
}
_, unmountErr := volumeServerClient.VolumeUnmount(ctx, &volume_server_pb.VolumeUnmountRequest{
VolumeId: uint32(volumeId),
})
if unmountErr != nil {
return unmountErr
}
_, mountErr := volumeServerClient.VolumeMount(ctx, &volume_server_pb.VolumeMountRequest{
VolumeId: uint32(volumeId),
})
if mountErr != nil {
return mountErr
}
return nil
})
return err
}

38
weed/shell/command_volume_tier.go → weed/shell/command_volume_tier_upload.go
View file

@ -7,24 +7,25 @@ import (
"io"
"time"
"google.golang.org/grpc"
"github.com/chrislusf/seaweedfs/weed/operation"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
"github.com/chrislusf/seaweedfs/weed/storage/needle"
"google.golang.org/grpc"
)
func init() {
Commands = append(Commands, &commandVolumeTier{})
Commands = append(Commands, &commandVolumeTierUpload{})
}
type commandVolumeTier struct {
type commandVolumeTierUpload struct {
}
func (c *commandVolumeTier) Name() string {
func (c *commandVolumeTierUpload) Name() string {
return "volume.tier.upload"
}
func (c *commandVolumeTier) Help() string {
func (c *commandVolumeTierUpload) Help() string {
return `move the dat file of a volume to a remote tier
volume.tier.upload [-collection=""] [-fullPercent=95] [-quietFor=1h]
@ -53,7 +54,7 @@ func (c *commandVolumeTier) Help() string {
`
}
func (c *commandVolumeTier) Do(args []string, commandEnv *CommandEnv, writer io.Writer) (err error) {
func (c *commandVolumeTierUpload) Do(args []string, commandEnv *CommandEnv, writer io.Writer) (err error) {
tierCommand := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
volumeId := tierCommand.Int("volumeId", 0, "the volume id")
@ -71,7 +72,7 @@ func (c *commandVolumeTier) Do(args []string, commandEnv *CommandEnv, writer io.
// volumeId is provided
if vid != 0 {
return doVolumeTier(ctx, commandEnv, writer, *collection, vid, *dest, *keepLocalDatFile)
return doVolumeTierUpload(ctx, commandEnv, writer, *collection, vid, *dest, *keepLocalDatFile)
}
// apply to all volumes in the collection
@ -80,9 +81,9 @@ func (c *commandVolumeTier) Do(args []string, commandEnv *CommandEnv, writer io.
if err != nil {
return err
}
fmt.Printf("tiering volumes: %v\n", volumeIds)
fmt.Printf("tier upload volumes: %v\n", volumeIds)
for _, vid := range volumeIds {
if err = doVolumeTier(ctx, commandEnv, writer, *collection, vid, *dest, *keepLocalDatFile); err != nil {
if err = doVolumeTierUpload(ctx, commandEnv, writer, *collection, vid, *dest, *keepLocalDatFile); err != nil {
return err
}
}
@ -90,23 +91,20 @@ func (c *commandVolumeTier) Do(args []string, commandEnv *CommandEnv, writer io.
return nil
}
func doVolumeTier(ctx context.Context, commandEnv *CommandEnv, writer io.Writer, collection string, vid needle.VolumeId, dest string, keepLocalDatFile bool) (err error) {
func doVolumeTierUpload(ctx context.Context, commandEnv *CommandEnv, writer io.Writer, collection string, vid needle.VolumeId, dest string, keepLocalDatFile bool) (err error) {
// find volume location
locations, found := commandEnv.MasterClient.GetLocations(uint32(vid))
if !found {
return fmt.Errorf("volume %d not found", vid)
}
// mark the volume as readonly
/*
err = markVolumeReadonly(ctx, commandEnv.option.GrpcDialOption, needle.VolumeId(vid), locations)
if err != nil {
return fmt.Errorf("mark volume %d as readonly on %s: %v", vid, locations[0].Url, err)
}
*/
err = markVolumeReadonly(ctx, commandEnv.option.GrpcDialOption, needle.VolumeId(vid), locations)
if err != nil {
return fmt.Errorf("mark volume %d as readonly on %s: %v", vid, locations[0].Url, err)
}
// copy the .dat file to remote tier
err = copyDatToRemoteTier(ctx, commandEnv.option.GrpcDialOption, writer, needle.VolumeId(vid), collection, locations[0].Url, dest, keepLocalDatFile)
err = uploadDatToRemoteTier(ctx, commandEnv.option.GrpcDialOption, writer, needle.VolumeId(vid), collection, locations[0].Url, dest, keepLocalDatFile)
if err != nil {
return fmt.Errorf("copy dat file for volume %d on %s to %s: %v", vid, locations[0].Url, dest, err)
}
@ -114,10 +112,10 @@ func doVolumeTier(ctx context.Context, commandEnv *CommandEnv, writer io.Writer,
return nil
}
func copyDatToRemoteTier(ctx context.Context, grpcDialOption grpc.DialOption, writer io.Writer, volumeId needle.VolumeId, collection string, sourceVolumeServer string, dest string, keepLocalDatFile bool) error {
func uploadDatToRemoteTier(ctx context.Context, grpcDialOption grpc.DialOption, writer io.Writer, volumeId needle.VolumeId, collection string, sourceVolumeServer string, dest string, keepLocalDatFile bool) error {
err := operation.WithVolumeServerClient(sourceVolumeServer, grpcDialOption, func(volumeServerClient volume_server_pb.VolumeServerClient) error {
stream, copyErr := volumeServerClient.VolumeTierCopyDatToRemote(ctx, &volume_server_pb.VolumeTierCopyDatToRemoteRequest{
stream, copyErr := volumeServerClient.VolumeTierMoveDatToRemote(ctx, &volume_server_pb.VolumeTierMoveDatToRemoteRequest{
VolumeId: uint32(volumeId),
Collection: collection,
DestinationBackendName: dest,

4
weed/storage/backend/backend.go
View file

@ -25,6 +25,8 @@ type BackendStorage interface {
ToProperties() map[string]string
NewStorageFile(key string, tierInfo *volume_server_pb.VolumeTierInfo) BackendStorageFile
CopyFile(f *os.File, fn func(progressed int64, percentage float32) error) (key string, size int64, err error)
DownloadFile(fileName string, key string, fn func(progressed int64, percentage float32) error) (size int64, err error)
DeleteFile(key string) (err error)
}
type StringProperties interface {
@ -41,6 +43,7 @@ var (
BackendStorages = make(map[string]BackendStorage)
)
// used by master to load remote storage configurations
func LoadConfiguration(config *viper.Viper) {
StorageBackendPrefix := "storage.backend"
@ -70,6 +73,7 @@ func LoadConfiguration(config *viper.Viper) {
}
// used by volume server to receive remote storage configurations from master
func LoadFromPbStorageBackends(storageBackends []*master_pb.StorageBackend) {
for _, storageBackend := range storageBackends {

21
weed/storage/backend/s3_backend/s3_backend.go
View file

@ -9,10 +9,11 @@ import (
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/service/s3/s3iface"
"github.com/google/uuid"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
"github.com/chrislusf/seaweedfs/weed/storage/backend"
"github.com/google/uuid"
)
func init() {
@ -85,6 +86,24 @@ func (s *S3BackendStorage) CopyFile(f *os.File, fn func(progressed int64, percen
return
}
func (s *S3BackendStorage) DownloadFile(fileName string, key string, fn func(progressed int64, percentage float32) error) (size int64, err error) {
glog.V(1).Infof("download dat file of %s from remote s3.%s as %s", fileName, s.id, key)
size, err = downloadFromS3(s.conn, fileName, s.bucket, key, fn)
return
}
func (s *S3BackendStorage) DeleteFile(key string) (err error) {
glog.V(1).Infof("delete dat file %s from remote", key)
err = deleteFromS3(s.conn, s.bucket, key)
return
}
type S3BackendStorageFile struct {
backendStorage *S3BackendStorage
key string

98
weed/storage/backend/s3_backend/s3_download.go Normal file
View file

@ -0,0 +1,98 @@
package s3_backend
import (
"fmt"
"os"
"sync/atomic"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/service/s3/s3iface"
"github.com/aws/aws-sdk-go/service/s3/s3manager"
"github.com/chrislusf/seaweedfs/weed/glog"
)
func downloadFromS3(sess s3iface.S3API, destFileName string, sourceBucket string, sourceKey string,
fn func(progressed int64, percentage float32) error) (fileSize int64, err error) {
fileSize, err = getFileSize(sess, sourceBucket, sourceKey)
if err != nil {
return
}
//open the file
f, err := os.OpenFile(destFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
return 0, fmt.Errorf("failed to open file %q, %v", destFileName, err)
}
defer f.Close()
// Create a downloader with the session and custom options
downloader := s3manager.NewDownloaderWithClient(sess, func(u *s3manager.Downloader) {
u.PartSize = int64(64 * 1024 * 1024)
u.Concurrency = 5
})
fileWriter := &s3DownloadProgressedWriter{
fp: f,
size: fileSize,
written: 0,
fn: fn,
}
// Download the file from S3.
fileSize, err = downloader.Download(fileWriter,&s3.GetObjectInput{
Bucket: aws.String(sourceBucket),
Key: aws.String(sourceKey),
})
if err != nil {
return fileSize, fmt.Errorf("failed to download file %s: %v", destFileName, err)
}
glog.V(1).Infof("downloaded file %s\n", destFileName)
return
}
// adapted from https://github.com/aws/aws-sdk-go/pull/1868
// and https://petersouter.xyz/s3-download-progress-bar-in-golang/
type s3DownloadProgressedWriter struct {
fp *os.File
size int64
written int64
fn func(progressed int64, percentage float32) error
}
func (w *s3DownloadProgressedWriter) WriteAt(p []byte, off int64) (int, error) {
n, err := w.fp.WriteAt(p, off)
if err != nil {
return n, err
}
// Got the length have read( or means has uploaded), and you can construct your message
atomic.AddInt64(&w.written, int64(n))
if w.fn != nil {
written := w.written
if err := w.fn(written, float32(written*100)/float32(w.size)); err != nil {
return n, err
}
}
return n, err
}
func getFileSize(svc s3iface.S3API, bucket string, key string) (filesize int64, error error) {
params := &s3.HeadObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
}
resp, err := svc.HeadObject(params)
if err != nil {
return 0, err
}
return *resp.ContentLength, nil
}

8
weed/storage/backend/s3_backend/s3_sessions.go
View file

@ -52,3 +52,11 @@ func createSession(awsAccessKeyId, awsSecretAccessKey, region string) (s3iface.S
return t, nil
}
func deleteFromS3(sess s3iface.S3API, sourceBucket string, sourceKey string) (err error) {
_, err = sess.DeleteObject(&s3.DeleteObjectInput{
Bucket: aws.String(sourceBucket),
Key: aws.String(sourceKey),
})
return err
}