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

ec deletion works

Browse source
This commit is contained in:
Chris Lu 2019-06-21 01:14:10 -07:00
parent 613a2e8060
commit f88a8bda7b
8 changed files with 189 additions and 147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
weed/pb/volume_server.proto
View file

@ -264,9 +264,11 @@ message VolumeEcShardReadRequest {
uint32 shard_id = 2; uint32 shard_id = 2;
int64 offset = 3; int64 offset = 3;
int64 size = 4; int64 size = 4;
uint64 file_key = 5;
} }
message VolumeEcShardReadResponse { message VolumeEcShardReadResponse {
bytes data = 1; bytes data = 1;
bool is_deleted = 2;
} }
message VolumeEcBlobDeleteRequest { message VolumeEcBlobDeleteRequest {

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

@ -1051,6 +1051,7 @@ type VolumeEcShardReadRequest struct {
ShardId uint32 `protobuf:"varint,2,opt,name=shard_id,json=shardId" json:"shard_id,omitempty"` ShardId uint32 `protobuf:"varint,2,opt,name=shard_id,json=shardId" json:"shard_id,omitempty"`
Offset int64 `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"` Offset int64 `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"`
Size int64 `protobuf:"varint,4,opt,name=size" json:"size,omitempty"` Size int64 `protobuf:"varint,4,opt,name=size" json:"size,omitempty"`
FileKey uint64 `protobuf:"varint,5,opt,name=file_key,json=fileKey" json:"file_key,omitempty"`
} }
func (m *VolumeEcShardReadRequest) Reset() { *m = VolumeEcShardReadRequest{} } func (m *VolumeEcShardReadRequest) Reset() { *m = VolumeEcShardReadRequest{} }
@ -1086,8 +1087,16 @@ func (m *VolumeEcShardReadRequest) GetSize() int64 {
return 0 return 0
} }
func (m *VolumeEcShardReadRequest) GetFileKey() uint64 {
if m != nil {
return m.FileKey
}
return 0
}
type VolumeEcShardReadResponse struct { type VolumeEcShardReadResponse struct {
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
IsDeleted bool `protobuf:"varint,2,opt,name=is_deleted,json=isDeleted" json:"is_deleted,omitempty"`
} }
func (m *VolumeEcShardReadResponse) Reset() { *m = VolumeEcShardReadResponse{} } func (m *VolumeEcShardReadResponse) Reset() { *m = VolumeEcShardReadResponse{} }
@ -1102,6 +1111,13 @@ func (m *VolumeEcShardReadResponse) GetData() []byte {
return nil return nil
} }
func (m *VolumeEcShardReadResponse) GetIsDeleted() bool {
if m != nil {
return m.IsDeleted
}
return false
}
type VolumeEcBlobDeleteRequest struct { type VolumeEcBlobDeleteRequest struct {
VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"` 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"` Collection string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
@ -2381,122 +2397,124 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) } func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{ var fileDescriptor0 = []byte{
// 1867 bytes of a gzipped FileDescriptorProto // 1890 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x19, 0xcb, 0x72, 0xdb, 0xd6, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x19, 0xcb, 0x72, 0xdb, 0xd6,
0x55, 0x30, 0x49, 0x91, 0x3a, 0xa4, 0x6c, 0xe9, 0xea, 0x45, 0x41, 0x96, 0xac, 0x20, 0x69, 0x22, 0x55, 0x30, 0x29, 0x93, 0x3c, 0xa4, 0x6c, 0xe9, 0xea, 0x45, 0x41, 0x96, 0xac, 0x20, 0x69, 0x22,
0xcb, 0x89, 0xe4, 0x3a, 0xd3, 0x36, 0x6d, 0x17, 0xad, 0x25, 0xab, 0xad, 0x27, 0x8d, 0x33, 0x03, 0xcb, 0x89, 0xe4, 0x3a, 0xd3, 0x36, 0x6d, 0x17, 0xad, 0x25, 0xab, 0xad, 0x27, 0x8d, 0x32, 0x03,
0x39, 0x9e, 0x74, 0x92, 0x19, 0xcc, 0x15, 0x70, 0x65, 0x61, 0x04, 0x02, 0x30, 0xee, 0x85, 0x62, 0x39, 0x9e, 0x74, 0x92, 0x19, 0xcc, 0x15, 0x70, 0x65, 0x61, 0x04, 0x02, 0x30, 0xee, 0x85, 0x62,
0x7a, 0xda, 0x6e, 0xd2, 0x6d, 0xbf, 0xa2, 0xbb, 0x2e, 0xba, 0xed, 0x07, 0xf4, 0x17, 0xfa, 0x11, 0x7a, 0xda, 0x55, 0xba, 0xed, 0x07, 0x74, 0xdd, 0x5d, 0x17, 0xdd, 0xf6, 0x03, 0xfa, 0x0b, 0xfd,
0xdd, 0xf4, 0x0b, 0xba, 0xe9, 0xdc, 0x07, 0x40, 0x3c, 0x49, 0xa8, 0xd2, 0x4c, 0x77, 0xe0, 0xb9, 0x88, 0x6e, 0xfa, 0x05, 0xdd, 0x74, 0xee, 0x03, 0x20, 0x9e, 0x24, 0x54, 0x69, 0xa6, 0x3b, 0xf0,
0xe7, 0x75, 0xcf, 0x3d, 0x6f, 0xc2, 0xca, 0x55, 0xe0, 0xc5, 0x23, 0x62, 0x51, 0x12, 0x5d, 0x91, 0xdc, 0xf3, 0xba, 0xe7, 0x9e, 0x37, 0x61, 0xf9, 0x2a, 0xf0, 0xe2, 0x11, 0xb1, 0x28, 0x89, 0xae,
0xe8, 0x20, 0x8c, 0x02, 0x16, 0xa0, 0xa5, 0x1c, 0xd0, 0x0a, 0xcf, 0x8c, 0x43, 0x40, 0x47, 0x98, 0x48, 0xb4, 0x1f, 0x46, 0x01, 0x0b, 0xd0, 0x62, 0x0e, 0x68, 0x85, 0x67, 0xc6, 0x01, 0xa0, 0x43,
0xd9, 0x17, 0xcf, 0x88, 0x47, 0x18, 0x31, 0xc9, 0x9b, 0x98, 0x50, 0x86, 0x36, 0xa1, 0x77, 0xee, 0xcc, 0xec, 0x8b, 0xe7, 0xc4, 0x23, 0x8c, 0x98, 0xe4, 0x4d, 0x4c, 0x28, 0x43, 0x1b, 0xd0, 0x3d,
0x7a, 0xc4, 0x72, 0x1d, 0x3a, 0xd4, 0x76, 0x5b, 0x7b, 0x0b, 0x66, 0x97, 0xff, 0x7e, 0xee, 0x50, 0x77, 0x3d, 0x62, 0xb9, 0x0e, 0x1d, 0x6a, 0x3b, 0xad, 0xdd, 0x9e, 0xd9, 0xe1, 0xbf, 0x5f, 0x38,
0xe3, 0x4b, 0x58, 0xc9, 0x11, 0xd0, 0x30, 0xf0, 0x29, 0x41, 0x9f, 0x41, 0x37, 0x22, 0x34, 0xf6, 0xd4, 0xf8, 0x12, 0x96, 0x73, 0x04, 0x34, 0x0c, 0x7c, 0x4a, 0xd0, 0x67, 0xd0, 0x89, 0x08, 0x8d,
0x98, 0x24, 0xe8, 0x3f, 0xd9, 0x39, 0x28, 0xca, 0x3a, 0x48, 0x49, 0x62, 0x8f, 0x99, 0x09, 0xba, 0x3d, 0x26, 0x09, 0xfa, 0x4f, 0xb7, 0xf7, 0x8b, 0xb2, 0xf6, 0x53, 0x92, 0xd8, 0x63, 0x66, 0x82,
0xf1, 0xbd, 0x06, 0x83, 0xec, 0x09, 0xda, 0x80, 0xae, 0x12, 0x3e, 0xd4, 0x76, 0xb5, 0xbd, 0x05, 0x6e, 0x7c, 0xaf, 0xc1, 0x20, 0x7b, 0x82, 0xd6, 0xa1, 0xa3, 0x84, 0x0f, 0xb5, 0x1d, 0x6d, 0xb7,
0x73, 0x5e, 0xca, 0x46, 0xeb, 0x30, 0x4f, 0x19, 0x66, 0x31, 0x1d, 0xde, 0xd9, 0xd5, 0xf6, 0x3a, 0x67, 0xde, 0x95, 0xb2, 0xd1, 0x1a, 0xdc, 0xa5, 0x0c, 0xb3, 0x98, 0x0e, 0xef, 0xec, 0x68, 0xbb,
0xa6, 0xfa, 0x85, 0x56, 0xa1, 0x43, 0xa2, 0x28, 0x88, 0x86, 0x2d, 0x81, 0x2e, 0x7f, 0x20, 0x04, 0xf3, 0xa6, 0xfa, 0x85, 0x56, 0x60, 0x9e, 0x44, 0x51, 0x10, 0x0d, 0x5b, 0x02, 0x5d, 0xfe, 0x40,
0x6d, 0xea, 0xbe, 0x23, 0xc3, 0xf6, 0xae, 0xb6, 0xb7, 0x68, 0x8a, 0x6f, 0x34, 0x84, 0xee, 0x15, 0x08, 0xda, 0xd4, 0x7d, 0x47, 0x86, 0xed, 0x1d, 0x6d, 0x77, 0xc1, 0x14, 0xdf, 0x68, 0x08, 0x9d,
0x89, 0xa8, 0x1b, 0xf8, 0xc3, 0x8e, 0x00, 0x27, 0x3f, 0x8d, 0x2e, 0x74, 0x4e, 0x46, 0x21, 0x1b, 0x2b, 0x12, 0x51, 0x37, 0xf0, 0x87, 0xf3, 0x02, 0x9c, 0xfc, 0x34, 0x3a, 0x30, 0x7f, 0x3c, 0x0a,
0x1b, 0x3f, 0x81, 0xe1, 0x2b, 0x6c, 0xc7, 0xf1, 0xe8, 0x95, 0x50, 0xff, 0xf8, 0x82, 0xd8, 0x97, 0xd9, 0xd8, 0xf8, 0x09, 0x0c, 0x5f, 0x61, 0x3b, 0x8e, 0x47, 0xaf, 0x84, 0xfa, 0x47, 0x17, 0xc4,
0x89, 0x59, 0xb6, 0x60, 0x41, 0x5d, 0x4a, 0xe9, 0xb6, 0x68, 0xf6, 0x24, 0xe0, 0xb9, 0x63, 0xfc, 0xbe, 0x4c, 0xcc, 0xb2, 0x09, 0x3d, 0x75, 0x29, 0xa5, 0xdb, 0x82, 0xd9, 0x95, 0x80, 0x17, 0x8e,
0x12, 0x36, 0x2b, 0x08, 0x95, 0x79, 0xde, 0x87, 0xc5, 0xd7, 0x38, 0x3a, 0xc3, 0xaf, 0x89, 0x15, 0xf1, 0x4b, 0xd8, 0xa8, 0x20, 0x54, 0xe6, 0x79, 0x1f, 0x16, 0x5e, 0xe3, 0xe8, 0x0c, 0xbf, 0x26,
0x61, 0xe6, 0x06, 0x82, 0x5a, 0x33, 0x07, 0x0a, 0x68, 0x72, 0x98, 0xf1, 0x0d, 0xe8, 0x39, 0x0e, 0x56, 0x84, 0x99, 0x1b, 0x08, 0x6a, 0xcd, 0x1c, 0x28, 0xa0, 0xc9, 0x61, 0xc6, 0x37, 0xa0, 0xe7,
0xc1, 0x28, 0xc4, 0x36, 0x6b, 0x22, 0x1c, 0xed, 0x42, 0x3f, 0x8c, 0x08, 0xf6, 0xbc, 0xc0, 0xc6, 0x38, 0x04, 0xa3, 0x10, 0xdb, 0xac, 0x89, 0x70, 0xb4, 0x03, 0xfd, 0x30, 0x22, 0xd8, 0xf3, 0x02,
0x8c, 0x08, 0xfb, 0xb4, 0xcc, 0x2c, 0xc8, 0xd8, 0x86, 0xad, 0x4a, 0xe6, 0x52, 0x41, 0xe3, 0xb3, 0x1b, 0x33, 0x22, 0xec, 0xd3, 0x32, 0xb3, 0x20, 0x63, 0x0b, 0x36, 0x2b, 0x99, 0x4b, 0x05, 0x8d,
0x82, 0xf6, 0xc1, 0x68, 0xe4, 0x36, 0x12, 0x6d, 0xdc, 0x2f, 0x69, 0x2d, 0x28, 0x15, 0xdf, 0x9f, 0xcf, 0x0a, 0xda, 0x07, 0xa3, 0x91, 0xdb, 0x48, 0xb4, 0xf1, 0xa0, 0xa4, 0xb5, 0xa0, 0x54, 0x7c,
0x16, 0x4e, 0x3d, 0x82, 0xfd, 0x38, 0x6c, 0xc4, 0xb8, 0xa8, 0x71, 0x42, 0x9a, 0x72, 0xde, 0x90, 0x7f, 0x5a, 0x38, 0xf5, 0x08, 0xf6, 0xe3, 0xb0, 0x11, 0xe3, 0xa2, 0xc6, 0x09, 0x69, 0xca, 0x79,
0x6e, 0x73, 0x1c, 0x78, 0x1e, 0xb1, 0x99, 0x1b, 0xf8, 0x09, 0xdb, 0x1d, 0x00, 0x3b, 0x05, 0x2a, 0x5d, 0xba, 0xcd, 0x51, 0xe0, 0x79, 0xc4, 0x66, 0x6e, 0xe0, 0x27, 0x6c, 0xb7, 0x01, 0xec, 0x14,
0x27, 0xca, 0x40, 0x0c, 0x1d, 0x86, 0x65, 0x52, 0xc5, 0xf6, 0xaf, 0x1a, 0xac, 0x3d, 0x55, 0x46, 0xa8, 0x9c, 0x28, 0x03, 0x31, 0x74, 0x18, 0x96, 0x49, 0x15, 0xdb, 0xbf, 0x6a, 0xb0, 0xfa, 0x4c,
0x93, 0x82, 0x1b, 0x3d, 0x40, 0x5e, 0xe4, 0x9d, 0xa2, 0xc8, 0xe2, 0x03, 0xb5, 0x4a, 0x0f, 0xc4, 0x19, 0x4d, 0x0a, 0x6e, 0xf4, 0x00, 0x79, 0x91, 0x77, 0x8a, 0x22, 0x8b, 0x0f, 0xd4, 0x2a, 0x3d,
0x31, 0x22, 0x12, 0x7a, 0xae, 0x8d, 0x05, 0x8b, 0xb6, 0x60, 0x91, 0x05, 0xa1, 0x25, 0x68, 0x31, 0x10, 0xc7, 0x88, 0x48, 0xe8, 0xb9, 0x36, 0x16, 0x2c, 0xda, 0x82, 0x45, 0x16, 0x84, 0x16, 0xa1,
0xe6, 0x09, 0xcf, 0x5d, 0x30, 0xf9, 0xa7, 0x31, 0x84, 0xf5, 0xa2, 0xae, 0xea, 0x1a, 0x3f, 0x86, 0xc5, 0x98, 0x27, 0x3c, 0xb7, 0x67, 0xf2, 0x4f, 0x63, 0x08, 0x6b, 0x45, 0x5d, 0xd5, 0x35, 0x7e,
0x0d, 0x09, 0x39, 0x1d, 0xfb, 0xf6, 0xa9, 0x88, 0x93, 0x46, 0x46, 0xff, 0x8f, 0x06, 0xc3, 0x32, 0x0c, 0xeb, 0x12, 0x72, 0x3a, 0xf6, 0xed, 0x53, 0x11, 0x27, 0x8d, 0x8c, 0xfe, 0x1f, 0x0d, 0x86,
0xa1, 0xf2, 0xe2, 0x9b, 0x5a, 0xe0, 0xba, 0xf7, 0x43, 0x0f, 0xa0, 0xcf, 0xb0, 0xeb, 0x59, 0xc1, 0x65, 0x42, 0xe5, 0xc5, 0x37, 0xb5, 0xc0, 0x75, 0xef, 0x87, 0x1e, 0x42, 0x9f, 0x61, 0xd7, 0xb3,
0xf9, 0x39, 0x25, 0x6c, 0x38, 0xbf, 0xab, 0xed, 0xb5, 0x4d, 0xe0, 0xa0, 0x2f, 0x05, 0x04, 0x3d, 0x82, 0xf3, 0x73, 0x4a, 0xd8, 0xf0, 0xee, 0x8e, 0xb6, 0xdb, 0x36, 0x81, 0x83, 0xbe, 0x14, 0x10,
0x84, 0x25, 0x5b, 0x7a, 0xb2, 0x15, 0x91, 0x2b, 0x57, 0x44, 0x76, 0x57, 0x28, 0x76, 0xcf, 0x4e, 0xf4, 0x08, 0x16, 0x6d, 0xe9, 0xc9, 0x56, 0x44, 0xae, 0x5c, 0x11, 0xd9, 0x1d, 0xa1, 0xd8, 0x7d,
0x3c, 0x5c, 0x82, 0x91, 0x01, 0x8b, 0xae, 0xf3, 0xd6, 0x12, 0xa9, 0x45, 0x24, 0x86, 0x9e, 0xe0, 0x3b, 0xf1, 0x70, 0x09, 0x46, 0x06, 0x2c, 0xb8, 0xce, 0x5b, 0x4b, 0xa4, 0x16, 0x91, 0x18, 0xba,
0xd6, 0x77, 0x9d, 0xb7, 0xbf, 0x72, 0x3d, 0x72, 0xea, 0xbe, 0x23, 0xc6, 0x2b, 0xb8, 0x2f, 0x2f, 0x82, 0x5b, 0xdf, 0x75, 0xde, 0xfe, 0xca, 0xf5, 0xc8, 0xa9, 0xfb, 0x8e, 0x18, 0xaf, 0xe0, 0x81,
0xff, 0xdc, 0xb7, 0x23, 0x32, 0x22, 0x3e, 0xc3, 0xde, 0x71, 0x10, 0x8e, 0x1b, 0xb9, 0xc0, 0x26, 0xbc, 0xfc, 0x0b, 0xdf, 0x8e, 0xc8, 0x88, 0xf8, 0x0c, 0x7b, 0x47, 0x41, 0x38, 0x6e, 0xe4, 0x02,
0xf4, 0xa8, 0xeb, 0xdb, 0xc4, 0xf2, 0x65, 0x82, 0x6a, 0x9b, 0x5d, 0xf1, 0xfb, 0x05, 0x35, 0x8e, 0x1b, 0xd0, 0xa5, 0xae, 0x6f, 0x13, 0xcb, 0x97, 0x09, 0xaa, 0x6d, 0x76, 0xc4, 0xef, 0x13, 0x6a,
0x60, 0xbb, 0x86, 0xaf, 0xb2, 0xec, 0x7b, 0x30, 0x10, 0x8a, 0xd9, 0x81, 0xcf, 0x88, 0xcf, 0x04, 0x1c, 0xc2, 0x56, 0x0d, 0x5f, 0x65, 0xd9, 0xf7, 0x60, 0x20, 0x14, 0xb3, 0x03, 0x9f, 0x11, 0x9f,
0xef, 0x81, 0xd9, 0xe7, 0xb0, 0x63, 0x09, 0x32, 0x7e, 0x08, 0x48, 0xf2, 0xf8, 0x22, 0x88, 0xfd, 0x09, 0xde, 0x03, 0xb3, 0xcf, 0x61, 0x47, 0x12, 0x64, 0xfc, 0x10, 0x90, 0xe4, 0xf1, 0x45, 0x10,
0x66, 0xa1, 0xb9, 0x06, 0x2b, 0x39, 0x12, 0xe5, 0x1b, 0x9f, 0xc2, 0xaa, 0x04, 0x7f, 0xe5, 0x8f, 0xfb, 0xcd, 0x42, 0x73, 0x15, 0x96, 0x73, 0x24, 0xca, 0x37, 0x3e, 0x85, 0x15, 0x09, 0xfe, 0xca,
0x1a, 0xf3, 0xda, 0x80, 0xb5, 0x02, 0x91, 0xe2, 0xf6, 0x24, 0x11, 0x92, 0x2f, 0x21, 0x53, 0x99, 0x1f, 0x35, 0xe6, 0xb5, 0x0e, 0xab, 0x05, 0x22, 0xc5, 0xed, 0x69, 0x22, 0x24, 0x5f, 0x42, 0xa6,
0xad, 0x27, 0x1a, 0xe4, 0xab, 0x88, 0xf1, 0x37, 0x0d, 0x96, 0x93, 0x34, 0xd2, 0xd0, 0xea, 0xd7, 0x32, 0x5b, 0x4b, 0x34, 0xc8, 0x57, 0x11, 0xe3, 0x6f, 0x1a, 0x2c, 0x25, 0x69, 0xa4, 0xa1, 0xd5,
0x74, 0xbb, 0x56, 0xad, 0xdb, 0xb5, 0x27, 0x6e, 0xb7, 0x07, 0x4b, 0x34, 0x88, 0x23, 0x9b, 0x58, 0xaf, 0xe9, 0x76, 0xad, 0x5a, 0xb7, 0x6b, 0x4f, 0xdc, 0x6e, 0x17, 0x16, 0x69, 0x10, 0x47, 0x36,
0x0e, 0x66, 0xd8, 0xf2, 0x03, 0x87, 0x28, 0xaf, 0xbc, 0x2b, 0xe1, 0xcf, 0x30, 0xc3, 0x2f, 0x02, 0xb1, 0x1c, 0xcc, 0xb0, 0xe5, 0x07, 0x0e, 0x51, 0x5e, 0x79, 0x4f, 0xc2, 0x9f, 0x63, 0x86, 0x4f,
0x87, 0x18, 0xbf, 0x48, 0x1e, 0x25, 0xf7, 0x9a, 0x0f, 0x61, 0xd9, 0xc3, 0x94, 0x59, 0x38, 0x0c, 0x02, 0x87, 0x18, 0xbf, 0x48, 0x1e, 0x25, 0xf7, 0x9a, 0x8f, 0x60, 0xc9, 0xc3, 0x94, 0x59, 0x38,
0x89, 0xef, 0x58, 0x98, 0x71, 0x97, 0xd0, 0x84, 0x4b, 0xdc, 0xe5, 0x07, 0x4f, 0x05, 0xfc, 0x29, 0x0c, 0x89, 0xef, 0x58, 0x98, 0x71, 0x97, 0xd0, 0x84, 0x4b, 0xdc, 0xe3, 0x07, 0xcf, 0x04, 0xfc,
0x7b, 0x41, 0x8d, 0x7f, 0x6a, 0x70, 0x8f, 0xd3, 0x72, 0x17, 0x6c, 0x74, 0xdf, 0x25, 0x68, 0x91, 0x19, 0x3b, 0xa1, 0xc6, 0x3f, 0x35, 0xb8, 0xcf, 0x69, 0xb9, 0x0b, 0x36, 0xba, 0xef, 0x22, 0xb4,
0xb7, 0x4c, 0x5d, 0x94, 0x7f, 0xa2, 0x43, 0x58, 0x51, 0xbe, 0xee, 0x06, 0xfe, 0x24, 0x0c, 0x5a, 0xc8, 0x5b, 0xa6, 0x2e, 0xca, 0x3f, 0xd1, 0x01, 0x2c, 0x2b, 0x5f, 0x77, 0x03, 0x7f, 0x12, 0x06,
0x82, 0x10, 0x4d, 0x8e, 0xd2, 0x48, 0x78, 0x00, 0x7d, 0xca, 0x82, 0x30, 0x89, 0xaa, 0xb6, 0x8c, 0x2d, 0x41, 0x88, 0x26, 0x47, 0x69, 0x24, 0x3c, 0x84, 0x3e, 0x65, 0x41, 0x98, 0x44, 0x55, 0x5b,
0x2a, 0x0e, 0x52, 0x51, 0x95, 0xb7, 0x69, 0xa7, 0xc2, 0xa6, 0x03, 0x97, 0x5a, 0xc4, 0xb6, 0xa4, 0x46, 0x15, 0x07, 0xa9, 0xa8, 0xca, 0xdb, 0x74, 0xbe, 0xc2, 0xa6, 0x03, 0x97, 0x5a, 0xc4, 0xb6,
0x56, 0x22, 0x2e, 0x7b, 0x26, 0xb8, 0xf4, 0xc4, 0x96, 0xd6, 0x30, 0x7e, 0x04, 0x4b, 0x93, 0x5b, 0xa4, 0x56, 0x22, 0x2e, 0xbb, 0x26, 0xb8, 0xf4, 0xd8, 0x96, 0xd6, 0x30, 0x7e, 0x04, 0x8b, 0x93,
0x35, 0xf7, 0xf1, 0xef, 0xb5, 0x24, 0x6d, 0xbd, 0xc4, 0xae, 0x77, 0x4a, 0x7c, 0x87, 0x44, 0x37, 0x5b, 0x35, 0xf7, 0xf1, 0xef, 0xb5, 0x24, 0x6d, 0xbd, 0xc4, 0xae, 0x77, 0x4a, 0x7c, 0x87, 0x44,
0x8c, 0x3d, 0xf4, 0x18, 0x56, 0x5d, 0xc7, 0x23, 0x16, 0x73, 0x47, 0x24, 0x88, 0x99, 0x45, 0x89, 0x37, 0x8c, 0x3d, 0xf4, 0x04, 0x56, 0x5c, 0xc7, 0x23, 0x16, 0x73, 0x47, 0x24, 0x88, 0x99, 0x45,
0x1d, 0xf8, 0x0e, 0x4d, 0xec, 0xc3, 0xcf, 0x5e, 0xca, 0xa3, 0x53, 0x79, 0x62, 0xfc, 0x29, 0xcd, 0x89, 0x1d, 0xf8, 0x0e, 0x4d, 0xec, 0xc3, 0xcf, 0x5e, 0xca, 0xa3, 0x53, 0x79, 0x62, 0xfc, 0x31,
0x81, 0x59, 0x2d, 0x26, 0x95, 0xdc, 0x27, 0x84, 0x33, 0xbc, 0x20, 0xd8, 0x21, 0x91, 0xba, 0xc6, 0xcd, 0x81, 0x59, 0x2d, 0x26, 0x95, 0xdc, 0x27, 0x84, 0x33, 0xbc, 0x20, 0xd8, 0x21, 0x91, 0xba,
0x40, 0x02, 0x7f, 0x23, 0x60, 0xdc, 0xc2, 0x0a, 0xe9, 0x2c, 0x70, 0xc6, 0x42, 0xa3, 0x81, 0x09, 0xc6, 0x40, 0x02, 0x7f, 0x23, 0x60, 0xdc, 0xc2, 0x0a, 0xe9, 0x2c, 0x70, 0xc6, 0x42, 0xa3, 0x81,
0x12, 0x74, 0x14, 0x38, 0x63, 0x91, 0x8c, 0xa8, 0x25, 0x9c, 0xc4, 0xbe, 0x88, 0xfd, 0x4b, 0xa1, 0x09, 0x12, 0x74, 0x18, 0x38, 0x63, 0x91, 0x8c, 0xa8, 0x25, 0x9c, 0xc4, 0xbe, 0x88, 0xfd, 0x4b,
0x4d, 0xcf, 0xec, 0xbb, 0xf4, 0xb7, 0x98, 0xb2, 0x63, 0x0e, 0x32, 0xfe, 0xae, 0xc1, 0xe6, 0x44, 0xa1, 0x4d, 0xd7, 0xec, 0xbb, 0xf4, 0xb7, 0x98, 0xb2, 0x23, 0x0e, 0x32, 0xfe, 0xae, 0xc1, 0xc6,
0x0d, 0x93, 0xd8, 0xc4, 0xbd, 0xfa, 0x3f, 0x98, 0x83, 0x53, 0xa8, 0x68, 0xc8, 0x75, 0x74, 0x2a, 0x44, 0x0d, 0x93, 0xd8, 0xc4, 0xbd, 0xfa, 0x3f, 0x98, 0x83, 0x53, 0xa8, 0x68, 0xc8, 0x75, 0x74,
0x60, 0x90, 0x3c, 0x53, 0x35, 0x43, 0x9c, 0x88, 0x96, 0xa0, 0x42, 0x71, 0x15, 0xe4, 0xdf, 0x26, 0x2a, 0x60, 0x90, 0x3c, 0x53, 0x35, 0x43, 0x9c, 0x88, 0x96, 0xa0, 0x42, 0x71, 0x15, 0xe4, 0xdf,
0xc9, 0xf0, 0xc4, 0x3e, 0xbd, 0xc0, 0x91, 0x43, 0x7f, 0x4d, 0x7c, 0x12, 0x61, 0x76, 0x2b, 0x85, 0x26, 0xc9, 0xf0, 0xd8, 0x3e, 0xbd, 0xc0, 0x91, 0x43, 0x7f, 0x4d, 0x7c, 0x12, 0x61, 0x76, 0x2b,
0xd6, 0xd8, 0x85, 0x9d, 0x3a, 0xee, 0x4a, 0xfe, 0x37, 0x49, 0x92, 0x4f, 0x30, 0x4c, 0x72, 0x16, 0x85, 0xd6, 0xd8, 0x81, 0xed, 0x3a, 0xee, 0x4a, 0xfe, 0x37, 0x49, 0x92, 0x4f, 0x30, 0x4c, 0x72,
0xbb, 0x9e, 0x73, 0x2b, 0xe2, 0x3f, 0x2f, 0x5e, 0x2e, 0x65, 0xae, 0xfc, 0x67, 0x1f, 0x96, 0x23, 0x16, 0xbb, 0x9e, 0x73, 0x2b, 0xe2, 0x3f, 0x2f, 0x5e, 0x2e, 0x65, 0xae, 0xfc, 0x67, 0x0f, 0x96,
0x01, 0x62, 0x16, 0xe5, 0x08, 0x69, 0x8f, 0xbd, 0x68, 0xde, 0x53, 0x07, 0x82, 0x90, 0xf7, 0xda, 0x22, 0x01, 0x62, 0x16, 0xe5, 0x08, 0x69, 0x8f, 0xbd, 0x60, 0xde, 0x57, 0x07, 0x82, 0x90, 0xf7,
0xff, 0x48, 0x3d, 0x20, 0xe1, 0x76, 0x6b, 0x69, 0x71, 0x0b, 0x16, 0x26, 0xe2, 0x5b, 0x42, 0x7c, 0xda, 0xff, 0x48, 0x3d, 0x20, 0xe1, 0x76, 0x6b, 0x69, 0x71, 0x13, 0x7a, 0x13, 0xf1, 0x2d, 0x21,
0x8f, 0x2a, 0xb9, 0xdc, 0x3b, 0xed, 0x20, 0x1c, 0x5b, 0xc4, 0x96, 0xf5, 0x52, 0x3c, 0x75, 0xcf, 0xbe, 0x4b, 0x95, 0x5c, 0xee, 0x9d, 0x76, 0x10, 0x8e, 0x2d, 0x62, 0xcb, 0x7a, 0x29, 0x9e, 0xba,
0xec, 0x73, 0xe0, 0x89, 0x2d, 0xca, 0xe5, 0x35, 0x72, 0x64, 0xea, 0x0d, 0xf9, 0x4b, 0xa8, 0xd7, 0x6b, 0xf6, 0x39, 0xf0, 0xd8, 0x16, 0xe5, 0xf2, 0x1a, 0x39, 0x32, 0xf5, 0x86, 0xfc, 0x25, 0xd4,
0xf8, 0x0e, 0xb6, 0xf2, 0xa7, 0xcd, 0xcb, 0xc8, 0x8d, 0x2e, 0x69, 0xec, 0x14, 0xdd, 0xa0, 0x50, 0x6b, 0x7c, 0x07, 0x9b, 0xf9, 0xd3, 0xe6, 0x65, 0xe4, 0x46, 0x97, 0x34, 0xb6, 0x8b, 0x6e, 0x50,
0x8b, 0xae, 0x8a, 0x6a, 0x37, 0xae, 0xbb, 0x37, 0xd3, 0x6b, 0xbb, 0x68, 0x90, 0x7c, 0xf1, 0xfe, 0xa8, 0x45, 0x57, 0x45, 0xb5, 0x1b, 0xd7, 0xdd, 0x9b, 0xe9, 0xb5, 0x55, 0x34, 0x48, 0xbe, 0x78,
0xba, 0xa8, 0xf6, 0x35, 0x8a, 0xf8, 0x74, 0xc1, 0x0f, 0x8a, 0xae, 0x5b, 0xac, 0xf4, 0x7f, 0x4c, 0x7f, 0x5d, 0x54, 0xfb, 0x1a, 0x45, 0x7c, 0xba, 0xe0, 0x87, 0x45, 0xd7, 0x2d, 0x56, 0xfa, 0x3f,
0xd2, 0xa2, 0x42, 0x30, 0x09, 0x76, 0x1a, 0xa7, 0x23, 0x25, 0x56, 0x58, 0x63, 0xd1, 0xec, 0x2a, 0xa7, 0x79, 0x51, 0x61, 0x98, 0x04, 0x3b, 0x8d, 0xf3, 0x91, 0x92, 0x2b, 0xcc, 0xb1, 0x60, 0x76,
0xa9, 0x7c, 0xa6, 0x53, 0x65, 0x48, 0xb6, 0xc4, 0xea, 0x57, 0x6e, 0x7a, 0x6b, 0xc9, 0xe9, 0xcd, 0x94, 0x58, 0x3e, 0xd4, 0xa9, 0x3a, 0x24, 0x7b, 0x62, 0xf5, 0x2b, 0x37, 0xbe, 0xb5, 0xd4, 0xf8,
0x38, 0x2c, 0x44, 0x83, 0x94, 0xaf, 0xe2, 0x0a, 0x41, 0x9b, 0x3b, 0xa2, 0x4a, 0xc7, 0xe2, 0xdb, 0x96, 0x8c, 0xa5, 0x97, 0x64, 0x2c, 0x7c, 0xad, 0x2d, 0xc7, 0xd2, 0xcf, 0xc9, 0xd8, 0x38, 0x29,
0xf8, 0x73, 0x26, 0x7e, 0x8e, 0xbc, 0xe0, 0xec, 0x16, 0x5d, 0x2b, 0x99, 0x90, 0x2f, 0xc9, 0x58, 0x44, 0x8a, 0x54, 0x4d, 0xc5, 0x1c, 0x82, 0x36, 0x77, 0x52, 0x95, 0xaa, 0xc5, 0x37, 0xda, 0x02,
0x68, 0xde, 0x96, 0x13, 0xf2, 0xe7, 0x64, 0x9c, 0x1d, 0x32, 0xdb, 0xf9, 0x21, 0x33, 0x13, 0x09, 0x70, 0xa9, 0xe5, 0x88, 0x37, 0x97, 0x4a, 0x75, 0xcd, 0x9e, 0xab, 0x9c, 0xc0, 0x31, 0xfe, 0x94,
0x59, 0x75, 0x94, 0x79, 0x7f, 0x06, 0x5b, 0xfc, 0x46, 0x12, 0x43, 0xb4, 0xa4, 0xcd, 0xdb, 0xf6, 0x09, 0xbd, 0x43, 0x2f, 0x38, 0xbb, 0x45, 0xaf, 0xcc, 0xde, 0xa2, 0x95, 0xbb, 0x45, 0x76, 0x3e,
0x7f, 0xdf, 0x81, 0xfb, 0xd5, 0xc4, 0x4d, 0x5a, 0xf7, 0x9f, 0x83, 0x9e, 0xb6, 0xc6, 0xbc, 0x2e, 0x6d, 0xe7, 0xe7, 0xd3, 0x4c, 0x10, 0x65, 0xd5, 0x51, 0x2f, 0xf3, 0x33, 0xd8, 0xe4, 0x17, 0x96,
0x50, 0x86, 0x47, 0x61, 0x5a, 0x19, 0x64, 0x01, 0xd9, 0x50, 0x7d, 0xf2, 0xcb, 0xe4, 0x3c, 0x29, 0x18, 0xa2, 0x9b, 0x6d, 0xde, 0xf1, 0xff, 0xfb, 0x0e, 0x3c, 0xa8, 0x26, 0x6e, 0xd2, 0xf5, 0xff,
0x0f, 0xa5, 0xbe, 0xba, 0x55, 0xea, 0xab, 0xb9, 0x00, 0x07, 0xb3, 0x3a, 0x01, 0xb2, 0x01, 0xd9, 0x1c, 0xf4, 0xb4, 0xab, 0xe6, 0x25, 0x85, 0x32, 0x3c, 0x0a, 0xd3, 0xa2, 0x22, 0x6b, 0xcf, 0xba,
0x70, 0x30, 0xab, 0x13, 0x90, 0x12, 0x0b, 0x01, 0x1d, 0x29, 0x40, 0xe1, 0x0b, 0x01, 0xdb, 0x00, 0x6a, 0xb1, 0x5f, 0x26, 0xe7, 0x49, 0x65, 0x29, 0xb5, 0xe4, 0xad, 0x52, 0x4b, 0xce, 0x05, 0x38,
0xaa, 0xb7, 0x88, 0xfd, 0x64, 0x4e, 0x58, 0x90, 0x9d, 0x45, 0xec, 0xd7, 0xb6, 0x48, 0xdd, 0xda, 0x98, 0xd5, 0x09, 0x90, 0xbd, 0xcb, 0xba, 0x83, 0x59, 0x9d, 0x80, 0x94, 0x58, 0x08, 0x90, 0x5e,
0x16, 0x29, 0xff, 0xfc, 0xbd, 0x52, 0x9a, 0xff, 0x1a, 0xe0, 0x99, 0x4b, 0x2f, 0xa5, 0x91, 0x79, 0xd3, 0x57, 0xf8, 0x42, 0xc0, 0x16, 0x80, 0x6a, 0x4b, 0x62, 0x3f, 0x19, 0x31, 0x7a, 0xb2, 0x29,
0x4f, 0xe6, 0xb8, 0x91, 0x1a, 0x34, 0xf9, 0x27, 0x87, 0x60, 0xcf, 0x53, 0xa6, 0xe3, 0x9f, 0xdc, 0x89, 0xfd, 0xda, 0xee, 0xaa, 0x53, 0xdb, 0x5d, 0xe5, 0x9f, 0xbf, 0x5b, 0xaa, 0x10, 0x5f, 0x03,
0x3f, 0x63, 0x4a, 0x1c, 0x65, 0x1d, 0xf1, 0xcd, 0x61, 0xe7, 0x11, 0x21, 0xca, 0x00, 0xe2, 0xdb, 0x3c, 0x77, 0xe9, 0xa5, 0x34, 0x32, 0x6f, 0xe7, 0x1c, 0x37, 0x52, 0x33, 0x2a, 0xff, 0xe4, 0x10,
0xf8, 0x8b, 0x06, 0x0b, 0x5f, 0x90, 0x91, 0xe2, 0xbc, 0x03, 0xf0, 0x3a, 0x88, 0x82, 0x98, 0xb9, 0xec, 0x79, 0xca, 0x74, 0xfc, 0x93, 0xbb, 0x6f, 0x4c, 0x89, 0xa3, 0xac, 0x23, 0xbe, 0x39, 0xec,
0x3e, 0x91, 0x2d, 0x64, 0xc7, 0xcc, 0x40, 0xfe, 0x77, 0x39, 0x22, 0xc0, 0x88, 0x77, 0xae, 0x8c, 0x3c, 0x22, 0x44, 0x19, 0x40, 0x7c, 0x1b, 0x7f, 0xd1, 0xa0, 0xf7, 0x05, 0x19, 0x29, 0xce, 0xdb,
0x29, 0xbe, 0x39, 0xec, 0x82, 0xe0, 0x50, 0xd9, 0x4f, 0x7c, 0xa3, 0x55, 0xe8, 0x50, 0x86, 0xed, 0x00, 0xaf, 0x83, 0x28, 0x88, 0x99, 0xeb, 0x13, 0xd9, 0x7d, 0xce, 0x9b, 0x19, 0xc8, 0xff, 0x2e,
0x4b, 0x61, 0xac, 0xb6, 0x29, 0x7f, 0x3c, 0xf9, 0xd7, 0x1a, 0x0c, 0xb2, 0x25, 0x1f, 0x7d, 0x0b, 0x47, 0x84, 0x26, 0xf1, 0xce, 0x95, 0x31, 0xc5, 0x37, 0x87, 0x5d, 0x10, 0x1c, 0x2a, 0xfb, 0x89,
0xfd, 0xcc, 0x5a, 0x08, 0x7d, 0x50, 0xde, 0xfe, 0x94, 0xd7, 0x4c, 0xfa, 0x0f, 0x66, 0x60, 0xa9, 0x6f, 0xb4, 0x02, 0xf3, 0x94, 0x61, 0xfb, 0x52, 0x18, 0xab, 0x6d, 0xca, 0x1f, 0x4f, 0xff, 0xb5,
0xc0, 0x98, 0x43, 0x3e, 0x2c, 0x97, 0x76, 0x2b, 0x68, 0xbf, 0x4c, 0x5d, 0xb7, 0xb9, 0xd1, 0x1f, 0x0a, 0x83, 0x6c, 0xb7, 0x80, 0xbe, 0x85, 0x7e, 0x66, 0xa3, 0x84, 0x3e, 0x28, 0x2f, 0x8e, 0xca,
0x35, 0xc2, 0x4d, 0xe5, 0x31, 0x58, 0xa9, 0x58, 0x96, 0xa0, 0x8f, 0x67, 0x70, 0xc9, 0x2d, 0x6c, 0x1b, 0x2a, 0xfd, 0x07, 0x33, 0xb0, 0x54, 0x60, 0xcc, 0x21, 0x1f, 0x96, 0x4a, 0x6b, 0x19, 0xb4,
0xf4, 0x4f, 0x1a, 0x62, 0xa7, 0x52, 0xdf, 0x00, 0x2a, 0x6f, 0x52, 0xd0, 0xa3, 0x99, 0x6c, 0x26, 0x57, 0xa6, 0xae, 0x5b, 0xfa, 0xe8, 0x8f, 0x1b, 0xe1, 0xa6, 0xf2, 0x18, 0x2c, 0x57, 0xec, 0x59,
0x9b, 0x1a, 0xfd, 0xe3, 0x66, 0xc8, 0xb5, 0x17, 0x95, 0x3b, 0x96, 0x99, 0x17, 0xcd, 0x6d, 0x71, 0xd0, 0xc7, 0x33, 0xb8, 0xe4, 0x76, 0x3d, 0xfa, 0x27, 0x0d, 0xb1, 0x53, 0xa9, 0x6f, 0x00, 0x95,
0x66, 0x5e, 0xb4, 0xb0, 0xb8, 0x99, 0x43, 0x97, 0xb0, 0x54, 0xdc, 0xbf, 0xa0, 0x87, 0x75, 0xfb, 0x97, 0x30, 0xe8, 0xf1, 0x4c, 0x36, 0x93, 0x25, 0x8f, 0xfe, 0x71, 0x33, 0xe4, 0xda, 0x8b, 0xca,
0xc2, 0xd2, 0x7a, 0x47, 0xdf, 0x6f, 0x82, 0x9a, 0x0a, 0x23, 0x70, 0x37, 0xbf, 0x23, 0x41, 0x1f, 0xf5, 0xcc, 0xcc, 0x8b, 0xe6, 0x16, 0x40, 0x33, 0x2f, 0x5a, 0xd8, 0xf9, 0xcc, 0xa1, 0x4b, 0x58,
0x95, 0xe9, 0x2b, 0x37, 0x3e, 0xfa, 0xde, 0x6c, 0xc4, 0xec, 0x9d, 0x8a, 0x7b, 0x93, 0xaa, 0x3b, 0x2c, 0xae, 0x6e, 0xd0, 0xa3, 0xba, 0x55, 0x63, 0x69, 0x33, 0xa4, 0xef, 0x35, 0x41, 0x4d, 0x85,
0xd5, 0x2c, 0x65, 0xaa, 0xee, 0x54, 0xb7, 0x86, 0x31, 0xe6, 0xd0, 0xef, 0x93, 0x61, 0xbc, 0xb0, 0x11, 0xb8, 0x97, 0x5f, 0xaf, 0xa0, 0x8f, 0xca, 0xf4, 0x95, 0xcb, 0x22, 0x7d, 0x77, 0x36, 0x62,
0x4f, 0x40, 0x07, 0x75, 0x6c, 0xaa, 0x17, 0x1a, 0xfa, 0x61, 0x63, 0xfc, 0x44, 0xf6, 0x63, 0x8d, 0xf6, 0x4e, 0xc5, 0x95, 0x4b, 0xd5, 0x9d, 0x6a, 0xf6, 0x39, 0x55, 0x77, 0xaa, 0xdb, 0xe0, 0x18,
0xc7, 0x7a, 0x66, 0xad, 0x50, 0x15, 0xeb, 0xe5, 0x45, 0x45, 0x55, 0xac, 0x57, 0xed, 0x26, 0xe6, 0x73, 0xe8, 0xf7, 0xc9, 0x1c, 0x5f, 0x58, 0x45, 0xa0, 0xfd, 0x3a, 0x36, 0xd5, 0xbb, 0x10, 0xfd,
0xd0, 0x19, 0x2c, 0xe6, 0x16, 0x0d, 0xe8, 0xc3, 0x3a, 0xca, 0x7c, 0xe7, 0xa3, 0x7f, 0x34, 0x13, 0xa0, 0x31, 0x7e, 0x22, 0xfb, 0x89, 0xc6, 0x63, 0x3d, 0xb3, 0x91, 0xa8, 0x8a, 0xf5, 0xf2, 0x8e,
0x2f, 0x95, 0x61, 0x25, 0xd9, 0x4b, 0xa5, 0xab, 0x5a, 0xe5, 0xf2, 0xf9, 0xea, 0xc3, 0x59, 0x68, 0xa3, 0x2a, 0xd6, 0xab, 0xd6, 0x1a, 0x73, 0xe8, 0x0c, 0x16, 0x72, 0x3b, 0x0a, 0xf4, 0x61, 0x1d,
0xa9, 0x80, 0xdf, 0x01, 0x4c, 0xf6, 0x02, 0xe8, 0xfd, 0x3a, 0xba, 0xec, 0x53, 0x7c, 0x30, 0x1d, 0x65, 0xbe, 0x69, 0xd2, 0x3f, 0x9a, 0x89, 0x97, 0xca, 0xb0, 0x92, 0xec, 0xa5, 0xd2, 0x55, 0xad,
0x29, 0x65, 0xfd, 0x1d, 0xac, 0x56, 0x55, 0x7a, 0x54, 0x11, 0x85, 0x53, 0xda, 0x09, 0xfd, 0xa0, 0x72, 0xf9, 0x7c, 0xf5, 0xe1, 0x2c, 0xb4, 0x54, 0xc0, 0xef, 0x00, 0x26, 0x2b, 0x05, 0xf4, 0x7e,
0x29, 0x7a, 0x2a, 0xf8, 0x2b, 0xe8, 0x25, 0x33, 0x3d, 0x7a, 0xaf, 0x4c, 0x5d, 0xd8, 0x62, 0xe8, 0x1d, 0x5d, 0xf6, 0x29, 0x3e, 0x98, 0x8e, 0x94, 0xb2, 0xfe, 0x0e, 0x56, 0xaa, 0x2a, 0x3d, 0xaa,
0xc6, 0x34, 0x94, 0x8c, 0x37, 0x8d, 0x92, 0xc0, 0x99, 0x0c, 0xdb, 0xf5, 0x81, 0x53, 0x5a, 0x0b, 0x88, 0xc2, 0x29, 0xed, 0x84, 0xbe, 0xdf, 0x14, 0x3d, 0x15, 0xfc, 0x15, 0x74, 0x93, 0x75, 0x00,
0xd4, 0x07, 0x4e, 0x79, 0x76, 0x17, 0xe2, 0xde, 0x24, 0x1b, 0x9b, 0xec, 0x6c, 0x5a, 0x99, 0x64, 0x7a, 0xaf, 0x4c, 0x5d, 0x58, 0x80, 0xe8, 0xc6, 0x34, 0x94, 0x8c, 0x37, 0x8d, 0x92, 0xc0, 0x99,
0xeb, 0x46, 0xef, 0xca, 0x24, 0x5b, 0x3f, 0xee, 0xce, 0xa1, 0x3f, 0xc0, 0x7a, 0xf5, 0x48, 0x8a, 0xcc, 0xe9, 0xf5, 0x81, 0x53, 0xda, 0x28, 0xd4, 0x07, 0x4e, 0x79, 0xec, 0x17, 0xe2, 0xde, 0x24,
0x6a, 0xc3, 0xaf, 0x66, 0x34, 0xd6, 0x1f, 0x37, 0x27, 0x48, 0xc5, 0xbf, 0x4b, 0x92, 0x45, 0x61, 0xcb, 0x9e, 0xec, 0x58, 0x5b, 0x99, 0x64, 0xeb, 0xa6, 0xf6, 0xca, 0x24, 0x5b, 0x3f, 0x29, 0xcf,
0x24, 0xad, 0x4f, 0x16, 0xd5, 0x83, 0xb1, 0x7e, 0xd8, 0x18, 0x3f, 0x57, 0xd2, 0x4a, 0xb3, 0x5f, 0xa1, 0x3f, 0xc0, 0x5a, 0xf5, 0x34, 0x8b, 0x6a, 0xc3, 0xaf, 0x66, 0xaa, 0xd6, 0x9f, 0x34, 0x27,
0xbd, 0xb5, 0x2b, 0xc6, 0xdc, 0x7a, 0x6b, 0x57, 0x8e, 0x93, 0x22, 0x3e, 0xaa, 0xe6, 0xba, 0xaa, 0x48, 0xc5, 0xbf, 0x4b, 0x92, 0x45, 0x61, 0x9a, 0xad, 0x4f, 0x16, 0xd5, 0x33, 0xb5, 0x7e, 0xd0,
0xf8, 0x98, 0x32, 0x78, 0xea, 0x07, 0x4d, 0xd1, 0x73, 0xb5, 0xb4, 0x3c, 0xb8, 0xa1, 0x99, 0xfa, 0x18, 0x3f, 0x57, 0xd2, 0x4a, 0x63, 0x63, 0xbd, 0xb5, 0x2b, 0x26, 0xe4, 0x7a, 0x6b, 0x57, 0x4e,
0xe7, 0xd2, 0xe4, 0x27, 0x0d, 0xb1, 0xeb, 0x5f, 0x37, 0x49, 0x9b, 0x33, 0x2f, 0x50, 0x48, 0x9f, 0xa2, 0x22, 0x3e, 0xaa, 0x46, 0xc2, 0xaa, 0xf8, 0x98, 0x32, 0xb3, 0xea, 0xfb, 0x4d, 0xd1, 0x73,
0x87, 0x8d, 0xf1, 0x53, 0xd9, 0x61, 0xb2, 0xad, 0xcd, 0x0c, 0x64, 0x68, 0x7f, 0x06, 0x9f, 0xcc, 0xb5, 0xb4, 0x3c, 0xf3, 0xa1, 0x99, 0xfa, 0xe7, 0xd2, 0xe4, 0x27, 0x0d, 0xb1, 0xeb, 0x5f, 0x37,
0xd4, 0xa8, 0x3f, 0x6a, 0x84, 0x5b, 0x15, 0xbd, 0xd9, 0x09, 0x6a, 0x9a, 0x3f, 0x95, 0xc6, 0xbe, 0x49, 0x9b, 0x33, 0x2f, 0x50, 0x48, 0x9f, 0x07, 0x8d, 0xf1, 0x53, 0xd9, 0x61, 0xb2, 0xe8, 0xcd,
0x69, 0xfe, 0x54, 0x31, 0x94, 0xcd, 0x9d, 0xcd, 0x8b, 0xbf, 0x4e, 0x3f, 0xfd, 0x6f, 0x00, 0x00, 0xcc, 0x6b, 0x68, 0x6f, 0x06, 0x9f, 0xcc, 0xbc, 0xa9, 0x3f, 0x6e, 0x84, 0x5b, 0x15, 0xbd, 0xd9,
0x00, 0xff, 0xff, 0x43, 0x50, 0xb8, 0xef, 0x51, 0x1d, 0x00, 0x00, 0x09, 0x6a, 0x9a, 0x3f, 0x95, 0xc6, 0xbe, 0x69, 0xfe, 0x54, 0x31, 0x94, 0xcd, 0x9d, 0xdd, 0x15,
0xff, 0xba, 0x7e, 0xfa, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5e, 0xae, 0x84, 0xe6, 0x8c, 0x1d,
0x00, 0x00,
} }

9
weed/server/volume_grpc_erasure_coding.go
View file

@ -234,6 +234,15 @@ func (vs *VolumeServer) VolumeEcShardRead(req *volume_server_pb.VolumeEcShardRea
return fmt.Errorf("not found ec shard %d.%d", req.VolumeId, req.ShardId) return fmt.Errorf("not found ec shard %d.%d", req.VolumeId, req.ShardId)
} }
if req.FileKey != 0 {
_, size, _ := ecVolume.FindNeedleFromEcx(types.Uint64ToNeedleId(req.FileKey))
if size == types.TombstoneFileSize {
return stream.Send(&volume_server_pb.VolumeEcShardReadResponse{
IsDeleted: true,
})
}
}
bufSize := req.Size bufSize := req.Size
if bufSize > BufferSizeLimit { if bufSize > BufferSizeLimit {
bufSize = BufferSizeLimit bufSize = BufferSizeLimit

6
weed/storage/erasure_coding/ec_volume.go
View file

@ -172,9 +172,9 @@ func (ev *EcVolume) ToVolumeEcShardInformationMessage() (messages []*master_pb.V
func (ev *EcVolume) LocateEcShardNeedle(needleId types.NeedleId, version needle.Version) (offset types.Offset, size uint32, intervals []Interval, err error) { func (ev *EcVolume) LocateEcShardNeedle(needleId types.NeedleId, version needle.Version) (offset types.Offset, size uint32, intervals []Interval, err error) {
// find the needle from ecx file // find the needle from ecx file
offset, size, err = ev.findNeedleFromEcx(needleId) offset, size, err = ev.FindNeedleFromEcx(needleId)
if err != nil { if err != nil {
return types.Offset{}, 0, nil, fmt.Errorf("findNeedleFromEcx: %v", err) return types.Offset{}, 0, nil, fmt.Errorf("FindNeedleFromEcx: %v", err)
} }
shard := ev.Shards[0] shard := ev.Shards[0]
@ -185,7 +185,7 @@ func (ev *EcVolume) LocateEcShardNeedle(needleId types.NeedleId, version needle.
return return
} }
func (ev *EcVolume) findNeedleFromEcx(needleId types.NeedleId) (offset types.Offset, size uint32, err error) { func (ev *EcVolume) FindNeedleFromEcx(needleId types.NeedleId) (offset types.Offset, size uint32, err error) {
return searchNeedleFromEcx(ev.ecxFile, ev.ecxFileSize, needleId, nil) return searchNeedleFromEcx(ev.ecxFile, ev.ecxFileSize, needleId, nil)
} }

2
weed/storage/needle/needle.go
View file

@ -158,7 +158,7 @@ func (n *Needle) ParsePath(fid string) (err error) {
} }
if delta != "" { if delta != "" {
if d, e := strconv.ParseUint(delta, 10, 64); e == nil { if d, e := strconv.ParseUint(delta, 10, 64); e == nil {
n.Id += NeedleId(d) n.Id += Uint64ToNeedleId(d)
} else { } else {
return e return e
} }

2
weed/storage/needle_map_leveldb.go
View file

@ -85,7 +85,7 @@ func (m *LevelDbNeedleMap) Get(key NeedleId) (element *needle_map.NeedleValue, o
} }
offset := BytesToOffset(data[0:OffsetSize]) offset := BytesToOffset(data[0:OffsetSize])
size := util.BytesToUint32(data[OffsetSize : OffsetSize+SizeSize]) size := util.BytesToUint32(data[OffsetSize : OffsetSize+SizeSize])
return &needle_map.NeedleValue{Key: NeedleId(key), Offset: offset, Size: size}, true return &needle_map.NeedleValue{Key: key, Offset: offset, Size: size}, true
} }
func (m *LevelDbNeedleMap) Put(key NeedleId, offset Offset, size uint32) error { func (m *LevelDbNeedleMap) Put(key NeedleId, offset Offset, size uint32) error {

2
weed/storage/needle_map_metric.go
View file

@ -53,7 +53,7 @@ func (mm *mapMetric) DeletedCount() int {
} }
func (mm *mapMetric) MaxFileKey() NeedleId { func (mm *mapMetric) MaxFileKey() NeedleId {
t := uint64(mm.MaximumFileKey) t := uint64(mm.MaximumFileKey)
return NeedleId(t) return Uint64ToNeedleId(t)
} }
func (mm *mapMetric) MaybeSetMaxFileKey(key NeedleId) { func (mm *mapMetric) MaybeSetMaxFileKey(key NeedleId) {
if key > mm.MaxFileKey() { if key > mm.MaxFileKey() {

61
weed/storage/store_ec.go
View file

@ -135,15 +135,18 @@ func (s *Store) ReadEcShardNeedle(ctx context.Context, vid needle.VolumeId, n *n
return 0, fmt.Errorf("entry %s is deleted", n.Id) return 0, fmt.Errorf("entry %s is deleted", n.Id)
} }
glog.V(4).Infof("read ec volume %d offset %d size %d intervals:%+v", vid, offset.ToAcutalOffset(), size, intervals) glog.V(3).Infof("read ec volume %d offset %d size %d intervals:%+v", vid, offset.ToAcutalOffset(), size, intervals)
if len(intervals) > 1 { if len(intervals) > 1 {
glog.V(4).Infof("ReadEcShardNeedle needle id %s intervals:%+v", n.String(), intervals) glog.V(3).Infof("ReadEcShardNeedle needle id %s intervals:%+v", n.String(), intervals)
} }
bytes, err := s.readEcShardIntervals(ctx, vid, localEcVolume, intervals) bytes, isDeleted, err := s.readEcShardIntervals(ctx, vid, n.Id, localEcVolume, intervals)
if err != nil { if err != nil {
return 0, fmt.Errorf("ReadEcShardIntervals: %v", err) return 0, fmt.Errorf("ReadEcShardIntervals: %v", err)
} }
if isDeleted {
return 0, fmt.Errorf("ec entry %s is deleted", n.Id)
}
err = n.ReadBytes(bytes, offset.ToAcutalOffset(), size, version) err = n.ReadBytes(bytes, offset.ToAcutalOffset(), size, version)
if err != nil { if err != nil {
@ -165,23 +168,26 @@ func (s *Store) readEcVolumeVersion(ctx context.Context, vid needle.VolumeId, ec
IsLargeBlock: true, // it could be large block, but ok in this place IsLargeBlock: true, // it could be large block, but ok in this place
LargeBlockRowsCount: 0, LargeBlockRowsCount: 0,
} }
data, err := s.readEcShardIntervals(ctx, vid, ecVolume, []erasure_coding.Interval{interval}) data, _, err := s.readEcShardIntervals(ctx, vid, 0, ecVolume, []erasure_coding.Interval{interval})
if err == nil { if err == nil {
ecVolume.Version = needle.Version(data[0]) ecVolume.Version = needle.Version(data[0])
} }
return return
} }
func (s *Store) readEcShardIntervals(ctx context.Context, vid needle.VolumeId, ecVolume *erasure_coding.EcVolume, intervals []erasure_coding.Interval) (data []byte, err error) { func (s *Store) readEcShardIntervals(ctx context.Context, vid needle.VolumeId, needleId types.NeedleId, ecVolume *erasure_coding.EcVolume, intervals []erasure_coding.Interval) (data []byte, is_deleted bool, err error) {
if err = s.cachedLookupEcShardLocations(ctx, ecVolume); err != nil { if err = s.cachedLookupEcShardLocations(ctx, ecVolume); err != nil {
return nil, fmt.Errorf("failed to locate shard via master grpc %s: %v", s.MasterAddress, err) return nil, false, fmt.Errorf("failed to locate shard via master grpc %s: %v", s.MasterAddress, err)
} }
for i, interval := range intervals { for i, interval := range intervals {
if d, e := s.readOneEcShardInterval(ctx, ecVolume, interval); e != nil { if d, isDeleted, e := s.readOneEcShardInterval(ctx, needleId, ecVolume, interval); e != nil {
return nil, e return nil, isDeleted, e
} else { } else {
if isDeleted {
is_deleted = true
}
if i == 0 { if i == 0 {
data = d data = d
} else { } else {
@ -192,7 +198,7 @@ func (s *Store) readEcShardIntervals(ctx context.Context, vid needle.VolumeId, e
return return
} }
func (s *Store) readOneEcShardInterval(ctx context.Context, ecVolume *erasure_coding.EcVolume, interval erasure_coding.Interval) (data []byte, err error) { func (s *Store) readOneEcShardInterval(ctx context.Context, needleId types.NeedleId, ecVolume *erasure_coding.EcVolume, interval erasure_coding.Interval) (data []byte, is_deleted bool, err error) {
shardId, actualOffset := interval.ToShardIdAndOffset(erasure_coding.ErasureCodingLargeBlockSize, erasure_coding.ErasureCodingSmallBlockSize) shardId, actualOffset := interval.ToShardIdAndOffset(erasure_coding.ErasureCodingLargeBlockSize, erasure_coding.ErasureCodingSmallBlockSize)
data = make([]byte, interval.Size) data = make([]byte, interval.Size)
if shard, found := ecVolume.FindEcVolumeShard(shardId); found { if shard, found := ecVolume.FindEcVolumeShard(shardId); found {
@ -207,7 +213,7 @@ func (s *Store) readOneEcShardInterval(ctx context.Context, ecVolume *erasure_co
// try reading directly // try reading directly
if hasShardIdLocation { if hasShardIdLocation {
_, err = s.readRemoteEcShardInterval(ctx, sourceDataNodes, ecVolume.VolumeId, shardId, data, actualOffset) _, is_deleted, err = s.readRemoteEcShardInterval(ctx, sourceDataNodes, needleId, ecVolume.VolumeId, shardId, data, actualOffset)
if err == nil { if err == nil {
return return
} }
@ -216,7 +222,7 @@ func (s *Store) readOneEcShardInterval(ctx context.Context, ecVolume *erasure_co
} }
// try reading by recovering from other shards // try reading by recovering from other shards
_, err = s.recoverOneRemoteEcShardInterval(ctx, ecVolume, shardId, data, actualOffset) _, is_deleted, err = s.recoverOneRemoteEcShardInterval(ctx, needleId, ecVolume, shardId, data, actualOffset)
if err == nil { if err == nil {
return return
} }
@ -236,11 +242,11 @@ func (s *Store) cachedLookupEcShardLocations(ctx context.Context, ecVolume *eras
shardCount := len(ecVolume.ShardLocations) shardCount := len(ecVolume.ShardLocations)
if shardCount < erasure_coding.DataShardsCount && if shardCount < erasure_coding.DataShardsCount &&
ecVolume.ShardLocationsRefreshTime.Add(11*time.Second).After(time.Now()) || ecVolume.ShardLocationsRefreshTime.Add(11 * time.Second).After(time.Now()) ||
shardCount == erasure_coding.TotalShardsCount && shardCount == erasure_coding.TotalShardsCount &&
ecVolume.ShardLocationsRefreshTime.Add(37*time.Minute).After(time.Now()) || ecVolume.ShardLocationsRefreshTime.Add(37 * time.Minute).After(time.Now()) ||
shardCount >= erasure_coding.DataShardsCount && shardCount >= erasure_coding.DataShardsCount &&
ecVolume.ShardLocationsRefreshTime.Add(7*time.Minute).After(time.Now()) { ecVolume.ShardLocationsRefreshTime.Add(7 * time.Minute).After(time.Now()) {
// still fresh // still fresh
return nil return nil
} }
@ -275,15 +281,15 @@ func (s *Store) cachedLookupEcShardLocations(ctx context.Context, ecVolume *eras
return return
} }
func (s *Store) readRemoteEcShardInterval(ctx context.Context, sourceDataNodes []string, vid needle.VolumeId, shardId erasure_coding.ShardId, buf []byte, offset int64) (n int, err error) { func (s *Store) readRemoteEcShardInterval(ctx context.Context, sourceDataNodes []string, needleId types.NeedleId, vid needle.VolumeId, shardId erasure_coding.ShardId, buf []byte, offset int64) (n int, is_deleted bool, err error) {
if len(sourceDataNodes) == 0 { if len(sourceDataNodes) == 0 {
return 0, fmt.Errorf("failed to find ec shard %d.%d", vid, shardId) return 0, false, fmt.Errorf("failed to find ec shard %d.%d", vid, shardId)
} }
for _, sourceDataNode := range sourceDataNodes { for _, sourceDataNode := range sourceDataNodes {
glog.V(4).Infof("read remote ec shard %d.%d from %s", vid, shardId, sourceDataNode) glog.V(4).Infof("read remote ec shard %d.%d from %s", vid, shardId, sourceDataNode)
n, err = s.doReadRemoteEcShardInterval(ctx, sourceDataNode, vid, shardId, buf, offset) n, is_deleted, err = s.doReadRemoteEcShardInterval(ctx, sourceDataNode, needleId, vid, shardId, buf, offset)
if err == nil { if err == nil {
return return
} }
@ -293,7 +299,7 @@ func (s *Store) readRemoteEcShardInterval(ctx context.Context, sourceDataNodes [
return return
} }
func (s *Store) doReadRemoteEcShardInterval(ctx context.Context, sourceDataNode string, vid needle.VolumeId, shardId erasure_coding.ShardId, buf []byte, offset int64) (n int, err error) { func (s *Store) doReadRemoteEcShardInterval(ctx context.Context, sourceDataNode string, needleId types.NeedleId, vid needle.VolumeId, shardId erasure_coding.ShardId, buf []byte, offset int64) (n int, is_deleted bool, err error) {
err = operation.WithVolumeServerClient(sourceDataNode, s.grpcDialOption, func(client volume_server_pb.VolumeServerClient) error { err = operation.WithVolumeServerClient(sourceDataNode, s.grpcDialOption, func(client volume_server_pb.VolumeServerClient) error {
@ -303,6 +309,7 @@ func (s *Store) doReadRemoteEcShardInterval(ctx context.Context, sourceDataNode
ShardId: uint32(shardId), ShardId: uint32(shardId),
Offset: offset, Offset: offset,
Size: int64(len(buf)), Size: int64(len(buf)),
FileKey: uint64(needleId),
}) })
if err != nil { if err != nil {
return fmt.Errorf("failed to start reading ec shard %d.%d from %s: %v", vid, shardId, sourceDataNode, err) return fmt.Errorf("failed to start reading ec shard %d.%d from %s: %v", vid, shardId, sourceDataNode, err)
@ -316,6 +323,9 @@ func (s *Store) doReadRemoteEcShardInterval(ctx context.Context, sourceDataNode
if receiveErr != nil { if receiveErr != nil {
return fmt.Errorf("receiving ec shard %d.%d from %s: %v", vid, shardId, sourceDataNode, err) return fmt.Errorf("receiving ec shard %d.%d from %s: %v", vid, shardId, sourceDataNode, err)
} }
if resp.IsDeleted {
is_deleted = true
}
copy(buf[n:n+len(resp.Data)], resp.Data) copy(buf[n:n+len(resp.Data)], resp.Data)
n += len(resp.Data) n += len(resp.Data)
} }
@ -323,18 +333,18 @@ func (s *Store) doReadRemoteEcShardInterval(ctx context.Context, sourceDataNode
return nil return nil
}) })
if err != nil { if err != nil {
return 0, fmt.Errorf("read ec shard %d.%d from %s: %v", vid, shardId, sourceDataNode, err) return 0, is_deleted, fmt.Errorf("read ec shard %d.%d from %s: %v", vid, shardId, sourceDataNode, err)
} }
return return
} }
func (s *Store) recoverOneRemoteEcShardInterval(ctx context.Context, ecVolume *erasure_coding.EcVolume, shardIdToRecover erasure_coding.ShardId, buf []byte, offset int64) (n int, err error) { func (s *Store) recoverOneRemoteEcShardInterval(ctx context.Context, needleId types.NeedleId, ecVolume *erasure_coding.EcVolume, shardIdToRecover erasure_coding.ShardId, buf []byte, offset int64) (n int, is_deleted bool, err error) {
glog.V(4).Infof("recover ec shard %d.%d from other locations", ecVolume.VolumeId, shardIdToRecover) glog.V(4).Infof("recover ec shard %d.%d from other locations", ecVolume.VolumeId, shardIdToRecover)
enc, err := reedsolomon.New(erasure_coding.DataShardsCount, erasure_coding.ParityShardsCount) enc, err := reedsolomon.New(erasure_coding.DataShardsCount, erasure_coding.ParityShardsCount)
if err != nil { if err != nil {
return 0, fmt.Errorf("failed to create encoder: %v", err) return 0, false, fmt.Errorf("failed to create encoder: %v", err)
} }
bufs := make([][]byte, erasure_coding.TotalShardsCount) bufs := make([][]byte, erasure_coding.TotalShardsCount)
@ -357,11 +367,14 @@ func (s *Store) recoverOneRemoteEcShardInterval(ctx context.Context, ecVolume *e
go func(shardId erasure_coding.ShardId, locations []string) { go func(shardId erasure_coding.ShardId, locations []string) {
defer wg.Done() defer wg.Done()
data := make([]byte, len(buf)) data := make([]byte, len(buf))
nRead, readErr := s.readRemoteEcShardInterval(ctx, locations, ecVolume.VolumeId, shardId, data, offset) nRead, isDeleted, readErr := s.readRemoteEcShardInterval(ctx, locations, needleId, ecVolume.VolumeId, shardId, data, offset)
if readErr != nil { if readErr != nil {
glog.V(3).Infof("recover: readRemoteEcShardInterval %d.%d %d bytes from %+v: %v", ecVolume.VolumeId, shardId, nRead, locations, readErr) glog.V(3).Infof("recover: readRemoteEcShardInterval %d.%d %d bytes from %+v: %v", ecVolume.VolumeId, shardId, nRead, locations, readErr)
forgetShardId(ecVolume, shardId) forgetShardId(ecVolume, shardId)
} }
if isDeleted {
is_deleted = true
}
if nRead == len(buf) { if nRead == len(buf) {
bufs[shardId] = data bufs[shardId] = data
} }
@ -373,13 +386,13 @@ func (s *Store) recoverOneRemoteEcShardInterval(ctx context.Context, ecVolume *e
if err = enc.ReconstructData(bufs); err != nil { if err = enc.ReconstructData(bufs); err != nil {
glog.V(3).Infof("recovered ec shard %d.%d failed: %v", ecVolume.VolumeId, shardIdToRecover, err) glog.V(3).Infof("recovered ec shard %d.%d failed: %v", ecVolume.VolumeId, shardIdToRecover, err)
return 0, err return 0, false, err
} }
glog.V(4).Infof("recovered ec shard %d.%d from other locations", ecVolume.VolumeId, shardIdToRecover) glog.V(4).Infof("recovered ec shard %d.%d from other locations", ecVolume.VolumeId, shardIdToRecover)
copy(buf, bufs[shardIdToRecover]) copy(buf, bufs[shardIdToRecover])
return len(buf), nil return len(buf), is_deleted, nil
} }
func (s *Store) EcVolumes() (ecVolumes []*erasure_coding.EcVolume) { func (s *Store) EcVolumes() (ecVolumes []*erasure_coding.EcVolume) {