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

volume: atomic copying file, adds version and stopOffset

Browse source
This commit is contained in:
Chris Lu 2019-04-19 12:29:49 -07:00
parent 730a032137
commit 3b3651dea3
9 changed files with 168 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
weed/command/backup.go
View file

@ -90,7 +90,7 @@ func runBackup(cmd *Command, args []string) bool {
return true return true
} }
if v.SuperBlock.CompactRevision < uint16(stats.CompactRevision) { if v.SuperBlock.CompactionRevision < uint16(stats.CompactRevision) {
if err = v.Compact(0); err != nil { if err = v.Compact(0); err != nil {
fmt.Printf("Compact Volume before synchronizing %v\n", err) fmt.Printf("Compact Volume before synchronizing %v\n", err)
return true return true
@ -99,7 +99,7 @@ func runBackup(cmd *Command, args []string) bool {
fmt.Printf("Commit Compact before synchronizing %v\n", err) fmt.Printf("Commit Compact before synchronizing %v\n", err)
return true return true
} }
v.SuperBlock.CompactRevision = uint16(stats.CompactRevision) v.SuperBlock.CompactionRevision = uint16(stats.CompactRevision)
v.DataFile().WriteAt(v.SuperBlock.Bytes(), 0) v.DataFile().WriteAt(v.SuperBlock.Bytes(), 0)
} }

3
weed/pb/volume_server.proto
View file

@ -162,6 +162,8 @@ message CopyFileRequest {
uint32 volume_id = 1; uint32 volume_id = 1;
bool is_idx_file = 2; bool is_idx_file = 2;
bool is_dat_file = 3; bool is_dat_file = 3;
uint32 compaction_revision = 4;
uint64 stop_offset = 5;
} }
message CopyFileResponse { message CopyFileResponse {
bytes file_content = 1; bytes file_content = 1;
@ -188,6 +190,7 @@ message ReadVolumeFileStatusResponse {
uint64 dat_file_timestamp_seconds = 4; uint64 dat_file_timestamp_seconds = 4;
uint64 dat_file_size = 5; uint64 dat_file_size = 5;
uint64 file_count = 6; uint64 file_count = 6;
uint32 compaction_revision = 7;
} }
message DiskStatus { message DiskStatus {

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

@ -597,9 +597,11 @@ func (m *VolumeCopyResponse) GetLastAppendAtNs() uint64 {
} }
type CopyFileRequest struct { type CopyFileRequest 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"`
IsIdxFile bool `protobuf:"varint,2,opt,name=is_idx_file,json=isIdxFile" json:"is_idx_file,omitempty"` IsIdxFile bool `protobuf:"varint,2,opt,name=is_idx_file,json=isIdxFile" json:"is_idx_file,omitempty"`
IsDatFile bool `protobuf:"varint,3,opt,name=is_dat_file,json=isDatFile" json:"is_dat_file,omitempty"` IsDatFile bool `protobuf:"varint,3,opt,name=is_dat_file,json=isDatFile" json:"is_dat_file,omitempty"`
CompactionRevision uint32 `protobuf:"varint,4,opt,name=compaction_revision,json=compactionRevision" json:"compaction_revision,omitempty"`
StopOffset uint64 `protobuf:"varint,5,opt,name=stop_offset,json=stopOffset" json:"stop_offset,omitempty"`
} }
func (m *CopyFileRequest) Reset() { *m = CopyFileRequest{} } func (m *CopyFileRequest) Reset() { *m = CopyFileRequest{} }
@ -628,6 +630,20 @@ func (m *CopyFileRequest) GetIsDatFile() bool {
return false return false
} }
func (m *CopyFileRequest) GetCompactionRevision() uint32 {
if m != nil {
return m.CompactionRevision
}
return 0
}
func (m *CopyFileRequest) GetStopOffset() uint64 {
if m != nil {
return m.StopOffset
}
return 0
}
type CopyFileResponse struct { type CopyFileResponse struct {
FileContent []byte `protobuf:"bytes,1,opt,name=file_content,json=fileContent,proto3" json:"file_content,omitempty"` FileContent []byte `protobuf:"bytes,1,opt,name=file_content,json=fileContent,proto3" json:"file_content,omitempty"`
} }
@ -731,6 +747,7 @@ type ReadVolumeFileStatusResponse struct {
DatFileTimestampSeconds uint64 `protobuf:"varint,4,opt,name=dat_file_timestamp_seconds,json=datFileTimestampSeconds" json:"dat_file_timestamp_seconds,omitempty"` DatFileTimestampSeconds uint64 `protobuf:"varint,4,opt,name=dat_file_timestamp_seconds,json=datFileTimestampSeconds" json:"dat_file_timestamp_seconds,omitempty"`
DatFileSize uint64 `protobuf:"varint,5,opt,name=dat_file_size,json=datFileSize" json:"dat_file_size,omitempty"` DatFileSize uint64 `protobuf:"varint,5,opt,name=dat_file_size,json=datFileSize" json:"dat_file_size,omitempty"`
FileCount uint64 `protobuf:"varint,6,opt,name=file_count,json=fileCount" json:"file_count,omitempty"` FileCount uint64 `protobuf:"varint,6,opt,name=file_count,json=fileCount" json:"file_count,omitempty"`
CompactionRevision uint32 `protobuf:"varint,7,opt,name=compaction_revision,json=compactionRevision" json:"compaction_revision,omitempty"`
} }
func (m *ReadVolumeFileStatusResponse) Reset() { *m = ReadVolumeFileStatusResponse{} } func (m *ReadVolumeFileStatusResponse) Reset() { *m = ReadVolumeFileStatusResponse{} }
@ -780,6 +797,13 @@ func (m *ReadVolumeFileStatusResponse) GetFileCount() uint64 {
return 0 return 0
} }
func (m *ReadVolumeFileStatusResponse) GetCompactionRevision() uint32 {
if m != nil {
return m.CompactionRevision
}
return 0
}
type DiskStatus struct { type DiskStatus struct {
Dir string `protobuf:"bytes,1,opt,name=dir" json:"dir,omitempty"` Dir string `protobuf:"bytes,1,opt,name=dir" json:"dir,omitempty"`
All uint64 `protobuf:"varint,2,opt,name=all" json:"all,omitempty"` All uint64 `protobuf:"varint,2,opt,name=all" json:"all,omitempty"`
@ -1579,89 +1603,92 @@ 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{
// 1339 bytes of a gzipped FileDescriptorProto // 1378 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x58, 0xdd, 0x73, 0x14, 0x45, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x58, 0xdb, 0x6e, 0xd4, 0x46,
0x10, 0xcf, 0x72, 0x97, 0xaf, 0xbe, 0x3b, 0x08, 0x13, 0x20, 0xc7, 0xf2, 0xe1, 0x31, 0x20, 0x1c, 0x18, 0x8e, 0xd9, 0xcd, 0xe9, 0xdf, 0x5d, 0x08, 0x13, 0x20, 0x8b, 0x39, 0x05, 0x43, 0x61, 0x39,
0x1f, 0x06, 0x85, 0x52, 0x51, 0x1f, 0x14, 0x12, 0x2d, 0x53, 0x25, 0x50, 0xb5, 0x01, 0x4a, 0x0b, 0x34, 0xb4, 0xa0, 0xb6, 0xb4, 0xbd, 0x68, 0x21, 0x69, 0xd5, 0x48, 0x05, 0x24, 0x07, 0x50, 0x2b,
0xab, 0xb6, 0x26, 0xbb, 0x93, 0x64, 0x2b, 0x7b, 0xb3, 0xcb, 0xce, 0x6c, 0x24, 0x96, 0xe5, 0x5f, 0x2a, 0x59, 0x13, 0x7b, 0x92, 0x8c, 0xe2, 0xf5, 0x18, 0xcf, 0x98, 0x92, 0xaa, 0xea, 0xcb, 0x54,
0xe2, 0x9b, 0xe5, 0x8b, 0x0f, 0xfe, 0x83, 0xbe, 0x58, 0xf3, 0xb1, 0x97, 0xfd, 0xcc, 0x2d, 0xf2, 0xbd, 0xe9, 0x45, 0x9f, 0xa1, 0x2f, 0xd0, 0x27, 0xea, 0x4d, 0x35, 0x07, 0x7b, 0xd7, 0xa7, 0xac,
0x36, 0xdb, 0xd3, 0xdd, 0xbf, 0xee, 0x9e, 0x9e, 0x9e, 0xdf, 0x1d, 0xac, 0x1e, 0x46, 0x61, 0x3a, 0x29, 0x77, 0xe3, 0x6f, 0xfe, 0xf3, 0xfc, 0xf3, 0xcf, 0xb7, 0x0b, 0xab, 0x6f, 0x58, 0x98, 0x8e,
0xa1, 0x2e, 0xa7, 0xc9, 0x21, 0x4d, 0xd6, 0xe3, 0x24, 0x12, 0x11, 0x5a, 0x29, 0x08, 0xdd, 0x78, 0x89, 0xc7, 0x49, 0xf2, 0x86, 0x24, 0x1b, 0x71, 0xc2, 0x04, 0x43, 0x2b, 0x05, 0xd0, 0x8b, 0x77,
0x07, 0xdf, 0x07, 0xf4, 0x84, 0x08, 0x6f, 0x7f, 0x93, 0x86, 0x54, 0x50, 0x87, 0xbe, 0x49, 0x29, 0x9d, 0x7b, 0x80, 0x1e, 0x63, 0xe1, 0x1f, 0x6c, 0x91, 0x90, 0x08, 0xe2, 0x92, 0xd7, 0x29, 0xe1,
0x17, 0xe8, 0x22, 0x2c, 0xed, 0x06, 0x21, 0x75, 0x03, 0x9f, 0x0f, 0xad, 0x51, 0x67, 0xbc, 0xec, 0x02, 0x9d, 0x87, 0xa5, 0x3d, 0x1a, 0x12, 0x8f, 0x06, 0x7c, 0x68, 0xad, 0x77, 0x46, 0xcb, 0xee,
0x2c, 0xca, 0xef, 0x2d, 0x9f, 0xe3, 0xe7, 0xb0, 0x5a, 0x30, 0xe0, 0x71, 0xc4, 0x38, 0x45, 0x8f, 0xa2, 0xfc, 0xde, 0x0e, 0xb8, 0xf3, 0x0c, 0x56, 0x0b, 0x0a, 0x3c, 0x66, 0x11, 0x27, 0xe8, 0x21,
0x60, 0x31, 0xa1, 0x3c, 0x0d, 0x85, 0x36, 0xe8, 0x3d, 0xb8, 0xba, 0x5e, 0xc6, 0x5a, 0x9f, 0x9a, 0x2c, 0x26, 0x84, 0xa7, 0xa1, 0xd0, 0x0a, 0xbd, 0xfb, 0x97, 0x37, 0xca, 0xbe, 0x36, 0x72, 0x95,
0xa4, 0xa1, 0x70, 0x32, 0x75, 0x1c, 0x40, 0x3f, 0xbf, 0x81, 0xd6, 0x60, 0xd1, 0x60, 0x0f, 0xad, 0x34, 0x14, 0x6e, 0x26, 0xee, 0x50, 0xe8, 0x4f, 0x6f, 0xa0, 0x35, 0x58, 0x34, 0xbe, 0x87, 0xd6,
0x91, 0x35, 0x5e, 0x76, 0x16, 0x34, 0x34, 0xba, 0x00, 0x0b, 0x5c, 0x10, 0x91, 0xf2, 0xe1, 0xa9, 0xba, 0x35, 0x5a, 0x76, 0x17, 0xb4, 0x6b, 0x74, 0x0e, 0x16, 0xb8, 0xc0, 0x22, 0xe5, 0xc3, 0x13,
0x91, 0x35, 0x9e, 0x77, 0xcc, 0x17, 0x3a, 0x07, 0xf3, 0x34, 0x49, 0xa2, 0x64, 0xd8, 0x51, 0xea, 0xeb, 0xd6, 0x68, 0xde, 0x35, 0x5f, 0xe8, 0x0c, 0xcc, 0x93, 0x24, 0x61, 0xc9, 0xb0, 0xa3, 0xc4,
0xfa, 0x03, 0x21, 0xe8, 0xf2, 0xe0, 0x57, 0x3a, 0xec, 0x8e, 0xac, 0xf1, 0xc0, 0x51, 0x6b, 0xbc, 0xf5, 0x07, 0x42, 0xd0, 0xe5, 0xf4, 0x17, 0x32, 0xec, 0xae, 0x5b, 0xa3, 0x81, 0xab, 0xd6, 0xce,
0x08, 0xf3, 0xdf, 0x4e, 0x62, 0x71, 0x84, 0x3f, 0x87, 0xe1, 0x2b, 0xe2, 0xa5, 0xe9, 0xe4, 0x95, 0x22, 0xcc, 0x7f, 0x33, 0x8e, 0xc5, 0x91, 0xf3, 0x19, 0x0c, 0x5f, 0x62, 0x3f, 0x4d, 0xc7, 0x2f,
0x8a, 0x71, 0x63, 0x9f, 0x7a, 0x07, 0x59, 0xee, 0x97, 0x60, 0xd9, 0x44, 0x6e, 0x22, 0x18, 0x38, 0x55, 0x8c, 0x9b, 0x07, 0xc4, 0x3f, 0xcc, 0x72, 0xbf, 0x00, 0xcb, 0x26, 0x72, 0x13, 0xc1, 0xc0,
0x4b, 0x5a, 0xb0, 0xe5, 0xe3, 0x6f, 0xe0, 0x62, 0x8d, 0xa1, 0xa9, 0xc1, 0x75, 0x18, 0xec, 0x91, 0x5d, 0xd2, 0xc0, 0x76, 0xe0, 0x7c, 0x0d, 0xe7, 0x6b, 0x14, 0x4d, 0x0d, 0xae, 0xc1, 0x60, 0x1f,
0x64, 0x87, 0xec, 0x51, 0x37, 0x21, 0x22, 0x88, 0x94, 0xb5, 0xe5, 0xf4, 0x8d, 0xd0, 0x91, 0x32, 0x27, 0xbb, 0x78, 0x9f, 0x78, 0x09, 0x16, 0x94, 0x29, 0x6d, 0xcb, 0xed, 0x1b, 0xd0, 0x95, 0x98,
0xfc, 0x1a, 0xec, 0x82, 0x87, 0x68, 0x12, 0x13, 0x4f, 0xb4, 0x01, 0x47, 0x23, 0xe8, 0xc5, 0x09, 0xf3, 0x0a, 0xec, 0x82, 0x05, 0x36, 0x8e, 0xb1, 0x2f, 0xda, 0x38, 0x47, 0xeb, 0xd0, 0x8b, 0x13,
0x25, 0x61, 0x18, 0x79, 0x44, 0x50, 0x55, 0x85, 0x8e, 0x93, 0x17, 0xe1, 0x2b, 0x70, 0xa9, 0xd6, 0x82, 0xc3, 0x90, 0xf9, 0x58, 0x10, 0x55, 0x85, 0x8e, 0x3b, 0x0d, 0x39, 0x97, 0xe0, 0x42, 0xad,
0xb9, 0x0e, 0x10, 0x3f, 0x2a, 0x45, 0x1f, 0x4d, 0x26, 0x41, 0x2b, 0x68, 0x7c, 0xb9, 0x12, 0xb5, 0x71, 0x1d, 0xa0, 0xf3, 0xb0, 0x14, 0x3d, 0x1b, 0x8f, 0x69, 0x2b, 0xd7, 0xce, 0xc5, 0x4a, 0xd4,
0xb2, 0x34, 0x7e, 0xbf, 0x28, 0xed, 0x86, 0x94, 0xb0, 0x34, 0x6e, 0xe5, 0xb8, 0x1c, 0x71, 0x66, 0x4a, 0xd3, 0xd8, 0xfd, 0xbc, 0xb4, 0x1b, 0x12, 0x1c, 0xa5, 0x71, 0x2b, 0xc3, 0xe5, 0x88, 0x33,
0x3a, 0xf5, 0xbc, 0xa6, 0x9b, 0x63, 0x23, 0x0a, 0x43, 0xea, 0x89, 0x20, 0x62, 0x99, 0xdb, 0xab, 0xd5, 0xdc, 0xf2, 0x9a, 0x6e, 0x8e, 0x4d, 0x16, 0x86, 0xc4, 0x17, 0x94, 0x45, 0x99, 0xd9, 0xcb,
0x00, 0xde, 0x54, 0x68, 0x5a, 0x25, 0x27, 0xc1, 0x36, 0x0c, 0xab, 0xa6, 0xc6, 0xed, 0xdf, 0x16, 0x00, 0x7e, 0x0e, 0x9a, 0x56, 0x99, 0x42, 0x1c, 0x1b, 0x86, 0x55, 0x55, 0x63, 0xf6, 0x4f, 0x0b,
0x9c, 0x7f, 0x6c, 0x8a, 0xa6, 0x81, 0x5b, 0x1d, 0x40, 0x11, 0xf2, 0x54, 0x19, 0xb2, 0x7c, 0x40, 0xce, 0x3e, 0x32, 0x45, 0xd3, 0x8e, 0x5b, 0x1d, 0x40, 0xd1, 0xe5, 0x89, 0xb2, 0xcb, 0xf2, 0x01,
0x9d, 0xca, 0x01, 0x49, 0x8d, 0x84, 0xc6, 0x61, 0xe0, 0x11, 0xe5, 0xa2, 0xab, 0x5c, 0xe4, 0x45, 0x75, 0x2a, 0x07, 0x24, 0x25, 0x12, 0x12, 0x87, 0xd4, 0xc7, 0xca, 0x44, 0x57, 0x99, 0x98, 0x86,
0x68, 0x05, 0x3a, 0x42, 0x84, 0xc3, 0x79, 0xb5, 0x23, 0x97, 0x78, 0x08, 0x17, 0xca, 0xb1, 0x9a, 0xd0, 0x0a, 0x74, 0x84, 0x08, 0x87, 0xf3, 0x6a, 0x47, 0x2e, 0x9d, 0x21, 0x9c, 0x2b, 0xc7, 0x6a,
0x34, 0x3e, 0x83, 0x35, 0x2d, 0xd9, 0x3e, 0x62, 0xde, 0xb6, 0xba, 0x0d, 0xad, 0x8a, 0xfe, 0xaf, 0xd2, 0xf8, 0x14, 0xd6, 0x34, 0xb2, 0x73, 0x14, 0xf9, 0x3b, 0xea, 0x36, 0xb4, 0x2a, 0xfa, 0xbf,
0x05, 0xc3, 0xaa, 0xa1, 0xe9, 0xe2, 0xf7, 0xad, 0xc0, 0xbb, 0xe6, 0x87, 0x3e, 0x80, 0x9e, 0x20, 0x16, 0x0c, 0xab, 0x8a, 0xa6, 0x8b, 0xdf, 0xb7, 0x02, 0xef, 0x9a, 0x1f, 0xba, 0x02, 0x3d, 0x81,
0x41, 0xe8, 0x46, 0xbb, 0xbb, 0x9c, 0x8a, 0xe1, 0xc2, 0xc8, 0x1a, 0x77, 0x1d, 0x90, 0xa2, 0xe7, 0x69, 0xe8, 0xb1, 0xbd, 0x3d, 0x4e, 0xc4, 0x70, 0x61, 0xdd, 0x1a, 0x75, 0x5d, 0x90, 0xd0, 0x33,
0x4a, 0x82, 0x6e, 0xc3, 0x8a, 0xa7, 0x3b, 0xd9, 0x4d, 0xe8, 0x61, 0xc0, 0xa5, 0xe7, 0x45, 0x15, 0x85, 0xa0, 0x5b, 0xb0, 0xe2, 0xeb, 0x4e, 0xf6, 0x12, 0xf2, 0x86, 0x72, 0x69, 0x79, 0x51, 0x05,
0xd8, 0x19, 0x2f, 0xeb, 0x70, 0x2d, 0x46, 0x18, 0x06, 0x81, 0xff, 0xd6, 0x55, 0x03, 0x44, 0x5d, 0x76, 0xca, 0xcf, 0x3a, 0x5c, 0xc3, 0xc8, 0x81, 0x01, 0x0d, 0xde, 0x7a, 0x6a, 0x80, 0xa8, 0xeb,
0xff, 0x25, 0xe5, 0xad, 0x17, 0xf8, 0x6f, 0xbf, 0x0b, 0x42, 0xba, 0x2d, 0xa7, 0xc0, 0x2b, 0xb8, 0xbf, 0xa4, 0xac, 0xf5, 0x68, 0xf0, 0xf6, 0x5b, 0x1a, 0x92, 0x1d, 0x39, 0x05, 0x5e, 0xc2, 0x45,
0xac, 0x93, 0xdf, 0x62, 0x5e, 0x42, 0x27, 0x94, 0x09, 0x12, 0x6e, 0x44, 0xf1, 0x51, 0xab, 0x16, 0x9d, 0xfc, 0x76, 0xe4, 0x27, 0x64, 0x4c, 0x22, 0x81, 0xc3, 0x4d, 0x16, 0x1f, 0xb5, 0x6a, 0x81,
0xb8, 0x08, 0x4b, 0x3c, 0x60, 0x1e, 0x75, 0x99, 0x1e, 0x43, 0x5d, 0x67, 0x51, 0x7d, 0x3f, 0xe3, 0xf3, 0xb0, 0xc4, 0x69, 0xe4, 0x13, 0x2f, 0xd2, 0x63, 0xa8, 0xeb, 0x2e, 0xaa, 0xef, 0xa7, 0xdc,
0xf8, 0x09, 0x5c, 0x69, 0xf0, 0x6b, 0x2a, 0x7b, 0x0d, 0xfa, 0x2a, 0x30, 0x2f, 0x62, 0x82, 0x32, 0x79, 0x0c, 0x97, 0x1a, 0xec, 0x9a, 0xca, 0x5e, 0x85, 0xbe, 0x0a, 0xcc, 0x67, 0x91, 0x20, 0x91,
0xa1, 0x7c, 0xf7, 0x9d, 0x9e, 0x94, 0x6d, 0x68, 0x11, 0xfe, 0x04, 0x90, 0xf6, 0xf1, 0x34, 0x4a, 0x50, 0xb6, 0xfb, 0x6e, 0x4f, 0x62, 0x9b, 0x1a, 0x72, 0x3e, 0x06, 0xa4, 0x6d, 0x3c, 0x61, 0x69,
0x59, 0xbb, 0xab, 0x79, 0x1e, 0x56, 0x0b, 0x26, 0xa6, 0x37, 0x1e, 0xc2, 0x39, 0x2d, 0x7e, 0xc9, 0xd4, 0xee, 0x6a, 0x9e, 0x85, 0xd5, 0x82, 0x8a, 0xe9, 0x8d, 0x07, 0x70, 0x46, 0xc3, 0x2f, 0xa2,
0x26, 0xad, 0x7d, 0xad, 0xc1, 0xf9, 0x92, 0x91, 0xf1, 0xf6, 0x20, 0x03, 0x29, 0xbe, 0x13, 0x27, 0x71, 0x6b, 0x5b, 0x6b, 0x70, 0xb6, 0xa4, 0x64, 0xac, 0xdd, 0xcf, 0x9c, 0x14, 0xdf, 0x89, 0x63,
0x3a, 0xbb, 0x90, 0x45, 0x50, 0x7c, 0x2a, 0xf0, 0x3f, 0x16, 0x9c, 0xcd, 0xc6, 0x48, 0xcb, 0xaa, 0x8d, 0x9d, 0xcb, 0x22, 0x28, 0x3e, 0x15, 0xce, 0x5f, 0x16, 0x9c, 0xce, 0xc6, 0x48, 0xcb, 0xaa,
0xbf, 0x63, 0xdb, 0x75, 0x1a, 0xdb, 0xae, 0x7b, 0xdc, 0x76, 0x63, 0x58, 0xe1, 0x51, 0x9a, 0x78, 0xbf, 0x63, 0xdb, 0x75, 0x1a, 0xdb, 0xae, 0x3b, 0x69, 0xbb, 0x11, 0xac, 0x70, 0x96, 0x26, 0x3e,
0xd4, 0xf5, 0x89, 0x20, 0x2e, 0x8b, 0x7c, 0x6a, 0xba, 0xf2, 0xb4, 0x96, 0x6f, 0x12, 0x41, 0x9e, 0xf1, 0x02, 0x2c, 0xb0, 0x17, 0xb1, 0x80, 0x98, 0xae, 0x3c, 0xa9, 0xf1, 0x2d, 0x2c, 0xf0, 0x53,
0x45, 0x3e, 0xc5, 0x5f, 0x67, 0x87, 0x52, 0x38, 0xcd, 0xdb, 0x70, 0x36, 0x24, 0x5c, 0xb8, 0x24, 0x16, 0x10, 0xe7, 0xab, 0xec, 0x50, 0x0a, 0xa7, 0x79, 0x0b, 0x4e, 0x87, 0x98, 0x0b, 0x0f, 0xc7,
0x8e, 0x29, 0xf3, 0x5d, 0x22, 0x64, 0x4b, 0x58, 0xaa, 0x25, 0x4e, 0xcb, 0x8d, 0xc7, 0x4a, 0xfe, 0x31, 0x89, 0x02, 0x0f, 0x0b, 0xd9, 0x12, 0x96, 0x6a, 0x89, 0x93, 0x72, 0xe3, 0x91, 0xc2, 0x1f,
0x58, 0x3c, 0xe3, 0x98, 0xc1, 0x19, 0x69, 0x2a, 0x3b, 0xb0, 0x65, 0xba, 0xbd, 0x80, 0xbb, 0x59, 0x89, 0xa7, 0xdc, 0xf9, 0xdb, 0x82, 0x53, 0x52, 0x57, 0xb6, 0x60, 0xcb, 0x7c, 0x7b, 0x94, 0x7b,
0x23, 0xab, 0x7c, 0x97, 0x9c, 0xe5, 0x80, 0x6f, 0xe9, 0x2e, 0x36, 0xfb, 0x3e, 0x11, 0x7a, 0xbf, 0x59, 0x27, 0xab, 0x84, 0x97, 0xdc, 0x65, 0xca, 0xb7, 0x75, 0x1b, 0x9b, 0xfd, 0x00, 0x0b, 0xbd,
0x93, 0xed, 0x6f, 0x12, 0x21, 0xf7, 0xf1, 0xa7, 0xb0, 0x72, 0x8c, 0xd7, 0xbe, 0xf9, 0xd2, 0xec, 0xdf, 0xc9, 0xf6, 0xb7, 0xb0, 0x50, 0xfb, 0xf7, 0x60, 0xd5, 0xdc, 0x0c, 0xca, 0xa2, 0xc9, 0xa5,
0x5c, 0x5e, 0x90, 0x20, 0x7c, 0xcf, 0xdb, 0x80, 0xc6, 0x70, 0xc6, 0x4f, 0x48, 0xc0, 0x02, 0xb6, 0xd1, 0x6f, 0x21, 0x9a, 0x6c, 0xe5, 0xf7, 0xe6, 0x0a, 0xf4, 0xb8, 0x60, 0x71, 0x76, 0x07, 0xe7,
0xb7, 0x4d, 0xbd, 0x88, 0xf9, 0x5c, 0xc5, 0x39, 0x70, 0xca, 0x62, 0xfc, 0x7b, 0x56, 0x5e, 0x0d, 0xf5, 0x1d, 0x94, 0x90, 0xbe, 0x83, 0xce, 0x27, 0xb0, 0x32, 0xc9, 0xa0, 0x7d, 0x3f, 0xa7, 0xd9,
0x7b, 0xfc, 0x98, 0x32, 0x4a, 0xfd, 0x90, 0xba, 0xfb, 0x94, 0xf8, 0x34, 0x31, 0x01, 0xf7, 0xb5, 0x51, 0x3f, 0xc7, 0x34, 0x7c, 0xcf, 0x0b, 0x86, 0x46, 0x70, 0x2a, 0x48, 0x30, 0x8d, 0x68, 0xb4,
0xf0, 0x7b, 0x25, 0x93, 0xa3, 0xc3, 0x28, 0xed, 0x44, 0xfe, 0x91, 0x0a, 0xa1, 0xef, 0x80, 0x16, 0xbf, 0x43, 0x7c, 0x16, 0x05, 0x5c, 0x65, 0x3e, 0x70, 0xcb, 0xb0, 0xf3, 0x5b, 0x76, 0x62, 0xda,
0x3d, 0x89, 0xfc, 0x23, 0x35, 0x0f, 0xb8, 0xab, 0xce, 0xc9, 0xdb, 0x4f, 0xd9, 0x81, 0xa9, 0x55, 0xed, 0xe4, 0x7d, 0x8e, 0x08, 0x09, 0x42, 0xe2, 0x1d, 0x10, 0x1c, 0x90, 0xc4, 0x04, 0xdc, 0xd7,
0x2f, 0xe0, 0x3f, 0x10, 0x2e, 0x36, 0xa4, 0x08, 0x7f, 0x09, 0x97, 0x1c, 0x4a, 0x7c, 0x1d, 0x83, 0xe0, 0x77, 0x0a, 0x93, 0x95, 0x30, 0x42, 0xbb, 0x2c, 0x38, 0x52, 0x21, 0xf4, 0x5d, 0xd0, 0xd0,
0x9a, 0x12, 0xed, 0x27, 0xe9, 0x1f, 0xa7, 0xe0, 0x72, 0xbd, 0x71, 0x9b, 0x69, 0xfa, 0x15, 0xd8, 0x63, 0x16, 0x1c, 0xa9, 0x11, 0xc3, 0x3d, 0x75, 0xf4, 0xfe, 0x41, 0x1a, 0x1d, 0x9a, 0xea, 0xf7,
0xd3, 0x69, 0x25, 0x82, 0x09, 0xe5, 0x82, 0x4c, 0x62, 0x97, 0x9b, 0x72, 0xe9, 0x82, 0xae, 0x99, 0x28, 0xff, 0x1e, 0x73, 0xb1, 0x29, 0x21, 0xe7, 0x0b, 0xb8, 0xe0, 0x12, 0x1c, 0xe8, 0x18, 0xd4,
0xd1, 0xf5, 0x22, 0xdb, 0x37, 0x65, 0xab, 0x8e, 0xba, 0x4e, 0x65, 0xd4, 0x49, 0x80, 0xac, 0x4b, 0xe0, 0x69, 0x3f, 0x9c, 0xff, 0x39, 0x01, 0x17, 0xeb, 0x95, 0xdb, 0x0c, 0xe8, 0x2f, 0xc1, 0xce,
0x6a, 0x00, 0xba, 0x1a, 0xc0, 0xd7, 0x5d, 0x53, 0x07, 0x30, 0x35, 0x56, 0x00, 0xf3, 0x1a, 0xc0, 0x07, 0xa0, 0xa0, 0x63, 0xc2, 0x05, 0x1e, 0xc7, 0x1e, 0x37, 0xe5, 0xd2, 0x05, 0x5d, 0x33, 0xd3,
0xe8, 0x2b, 0x80, 0x2b, 0x00, 0xa6, 0xab, 0x52, 0x96, 0x8d, 0xee, 0x65, 0xdd, 0x53, 0x29, 0x13, 0xf0, 0x79, 0xb6, 0x6f, 0xca, 0x56, 0x9d, 0x9e, 0x9d, 0xca, 0xf4, 0x94, 0x0e, 0xb2, 0xbe, 0xab,
0xf8, 0x47, 0x80, 0xcd, 0x80, 0x1f, 0xe8, 0x9a, 0xc8, 0x3b, 0xe8, 0x07, 0x89, 0x79, 0xaa, 0xe5, 0x71, 0xd0, 0xd5, 0x0e, 0x02, 0xdd, 0x87, 0x75, 0x0e, 0x72, 0x65, 0xe5, 0x40, 0x37, 0x5a, 0xcf,
0x52, 0x4a, 0x48, 0x18, 0x9a, 0x4c, 0xe5, 0x52, 0xd2, 0xb6, 0x94, 0x53, 0xdf, 0x24, 0xa3, 0xd6, 0xc8, 0x2b, 0x07, 0x97, 0x00, 0x4c, 0x57, 0xa5, 0x51, 0xf6, 0x1a, 0x2c, 0xeb, 0x9e, 0x4a, 0x23,
0x52, 0xb6, 0x9b, 0x50, 0x6a, 0xe2, 0x55, 0x6b, 0xfc, 0xa7, 0x05, 0xcb, 0x4f, 0xe9, 0xc4, 0x78, 0xd1, 0xd4, 0xda, 0x8b, 0x4d, 0xad, 0xed, 0xfc, 0x00, 0xb0, 0x45, 0xf9, 0xa1, 0x2e, 0xa2, 0x9c,
0xbe, 0x0a, 0xb0, 0x17, 0x25, 0x51, 0x2a, 0x02, 0x46, 0xf5, 0x25, 0x9c, 0x77, 0x72, 0x92, 0xff, 0x03, 0x01, 0x4d, 0x0c, 0x5d, 0x90, 0x4b, 0x89, 0xe0, 0x30, 0x34, 0xa5, 0x91, 0x4b, 0x49, 0x1d,
0x8f, 0xa3, 0x68, 0x24, 0x0d, 0x77, 0x4d, 0xee, 0x6a, 0x2d, 0x65, 0xfb, 0x94, 0xc4, 0x26, 0x5d, 0x53, 0x4e, 0x02, 0x93, 0xbd, 0x5a, 0x4b, 0x6c, 0x2f, 0x21, 0xc4, 0x24, 0xa8, 0xd6, 0xce, 0xef,
0xb5, 0x96, 0x24, 0x94, 0x0b, 0xe2, 0x1d, 0xa8, 0x87, 0xa9, 0xeb, 0xe8, 0x8f, 0x07, 0x7f, 0x0d, 0x16, 0x2c, 0x3f, 0x21, 0x63, 0x63, 0xf9, 0x32, 0xc0, 0x3e, 0x4b, 0x58, 0x2a, 0x68, 0x44, 0xf4,
0xa0, 0x6f, 0x1e, 0x5a, 0xc5, 0x82, 0xd1, 0xcf, 0xd0, 0xcb, 0xb1, 0x67, 0x74, 0xa3, 0x4a, 0x92, 0x20, 0x98, 0x77, 0xa7, 0x90, 0xff, 0xef, 0x47, 0x51, 0x59, 0x12, 0xee, 0x99, 0x62, 0xa9, 0xb5,
0xab, 0x6c, 0xdc, 0xfe, 0x70, 0x86, 0x96, 0x99, 0xab, 0x73, 0x88, 0xc1, 0xd9, 0x0a, 0x3b, 0x45, 0xc4, 0x0e, 0x08, 0x8e, 0x4d, 0x7d, 0xd4, 0x5a, 0x12, 0x61, 0x2e, 0xb0, 0x7f, 0xa8, 0x8a, 0xd1,
0x77, 0xaa, 0xd6, 0x4d, 0xdc, 0xd7, 0xbe, 0xdb, 0x4a, 0x77, 0x8a, 0x27, 0x60, 0xb5, 0x86, 0x6e, 0x75, 0xf5, 0xc7, 0xfd, 0x3f, 0x06, 0xd0, 0x37, 0x8f, 0xbd, 0x62, 0xe2, 0xe8, 0x27, 0xe8, 0x4d,
0xa2, 0x7b, 0x33, 0xbc, 0x14, 0x28, 0xaf, 0xfd, 0x51, 0x4b, 0xed, 0x29, 0xea, 0x1b, 0x40, 0x55, 0x31, 0x78, 0x74, 0xbd, 0x4a, 0xd4, 0xab, 0xbf, 0x08, 0xec, 0x0f, 0x66, 0x48, 0x99, 0xd9, 0x3e,
0x2e, 0x8a, 0xee, 0xce, 0x74, 0x73, 0xcc, 0x75, 0xed, 0x7b, 0xed, 0x94, 0x1b, 0x13, 0xd5, 0x2c, 0x87, 0x22, 0x38, 0x5d, 0x61, 0xc8, 0xe8, 0x76, 0x55, 0xbb, 0x89, 0x7f, 0xdb, 0x77, 0x5a, 0xc9,
0x75, 0x66, 0xa2, 0x05, 0x1e, 0x3c, 0x33, 0xd1, 0x12, 0xf5, 0x9d, 0x43, 0x07, 0xb0, 0x52, 0x66, 0xe6, 0xfe, 0x04, 0xac, 0xd6, 0x50, 0x5e, 0x74, 0x77, 0x86, 0x95, 0x02, 0xed, 0xb6, 0x3f, 0x6c,
0xb0, 0xe8, 0x76, 0xd3, 0xcf, 0xaa, 0x0a, 0x41, 0xb6, 0xef, 0xb4, 0x51, 0x9d, 0x82, 0x51, 0x38, 0x29, 0x9d, 0x7b, 0x7d, 0x0d, 0xa8, 0xca, 0x87, 0xd1, 0x9d, 0x99, 0x66, 0x26, 0x7c, 0xdb, 0xbe,
0x5d, 0x64, 0x99, 0xe8, 0x56, 0xd5, 0xbe, 0x96, 0x33, 0xdb, 0xe3, 0xd9, 0x8a, 0xf9, 0x9c, 0xca, 0xdb, 0x4e, 0xb8, 0x31, 0x51, 0xcd, 0x94, 0x67, 0x26, 0x5a, 0xe0, 0xe2, 0x33, 0x13, 0x2d, 0xd1,
0xcc, 0xb3, 0x2e, 0xa7, 0x06, 0x5a, 0x5b, 0x97, 0x53, 0x13, 0x91, 0xc5, 0x73, 0xe8, 0xb7, 0x8c, 0xef, 0x39, 0x74, 0x08, 0x2b, 0x65, 0x16, 0x8d, 0x6e, 0x35, 0xfd, 0xb4, 0xab, 0x90, 0x74, 0xfb,
0xce, 0x94, 0x18, 0x19, 0x5a, 0x6f, 0x72, 0x53, 0x4f, 0x09, 0xed, 0xfb, 0xad, 0xf5, 0x33, 0xec, 0x76, 0x1b, 0xd1, 0xdc, 0x19, 0x81, 0x93, 0x45, 0xa6, 0x8b, 0x6e, 0x56, 0xf5, 0x6b, 0x79, 0xbb,
0x8f, 0x2d, 0x79, 0xd7, 0x73, 0xc4, 0xac, 0xee, 0xae, 0x57, 0xa9, 0x5e, 0xdd, 0x5d, 0xaf, 0x63, 0x3d, 0x9a, 0x2d, 0x38, 0x9d, 0x53, 0x99, 0xfd, 0xd6, 0xe5, 0xd4, 0x40, 0xad, 0xeb, 0x72, 0x6a,
0x77, 0x73, 0x68, 0x07, 0x06, 0x05, 0xaa, 0x86, 0x6e, 0x36, 0x59, 0x16, 0x09, 0xa0, 0x7d, 0x6b, 0x22, 0xd3, 0xce, 0x1c, 0xfa, 0x35, 0xa3, 0x54, 0x25, 0x56, 0x88, 0x36, 0x9a, 0xcc, 0xd4, 0xd3,
0xa6, 0xde, 0x14, 0xc3, 0xcd, 0xa6, 0x97, 0x19, 0x57, 0x8d, 0xc1, 0x15, 0xe7, 0xd5, 0xcd, 0x59, 0x52, 0xfb, 0x5e, 0x6b, 0xf9, 0xcc, 0xf7, 0x47, 0x96, 0xbc, 0xeb, 0x53, 0xe4, 0xb0, 0xee, 0xae,
0x6a, 0x53, 0x80, 0x9f, 0x00, 0x8e, 0x99, 0x15, 0xba, 0xde, 0x64, 0x97, 0x3f, 0x8a, 0x1b, 0x27, 0x57, 0xe9, 0x66, 0xdd, 0x5d, 0xaf, 0x63, 0x98, 0x73, 0x68, 0x17, 0x06, 0x05, 0xba, 0x88, 0x6e,
0x2b, 0x4d, 0x5d, 0xff, 0x02, 0xe7, 0xea, 0x1e, 0x66, 0x54, 0x73, 0x0b, 0x4f, 0x78, 0xfd, 0xed, 0x34, 0x69, 0x16, 0x49, 0xa8, 0x7d, 0x73, 0xa6, 0x5c, 0xee, 0xc3, 0xcb, 0xa6, 0x97, 0x19, 0x57,
0xf5, 0xb6, 0xea, 0x53, 0xe0, 0x97, 0xb0, 0x94, 0x91, 0x2f, 0x74, 0xad, 0x6a, 0x5d, 0x22, 0x82, 0x8d, 0xc1, 0x15, 0xe7, 0xd5, 0x8d, 0x59, 0x62, 0xb9, 0x83, 0x1f, 0x01, 0x26, 0xec, 0x0e, 0x5d,
0x36, 0x3e, 0x49, 0x25, 0xd7, 0x4d, 0xaf, 0xb3, 0x52, 0x49, 0x96, 0xd4, 0x5c, 0xaa, 0x1c, 0x75, 0x6b, 0xd2, 0x9b, 0x3e, 0x8a, 0xeb, 0xc7, 0x0b, 0xe5, 0xa6, 0x7f, 0x86, 0x33, 0x75, 0x2f, 0x39,
0x6b, 0x2e, 0x55, 0x9e, 0x68, 0x49, 0xe7, 0x3b, 0x0b, 0xea, 0xef, 0xa1, 0x87, 0xff, 0x05, 0x00, 0xaa, 0xb9, 0x85, 0xc7, 0xd0, 0x05, 0x7b, 0xa3, 0xad, 0x78, 0xee, 0xf8, 0x05, 0x2c, 0x65, 0x6c,
0x00, 0xff, 0xff, 0xfc, 0x26, 0x3f, 0x74, 0x35, 0x12, 0x00, 0x00, 0x0d, 0x5d, 0xad, 0x6a, 0x97, 0xb8, 0xa8, 0xed, 0x1c, 0x27, 0x32, 0xd5, 0x4d, 0xaf, 0xb2, 0x52,
0x49, 0x5a, 0xd5, 0x5c, 0xaa, 0x29, 0xae, 0xd7, 0x5c, 0xaa, 0x69, 0x66, 0x26, 0x8d, 0xef, 0x2e,
0xa8, 0xbf, 0xa8, 0x1e, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0x07, 0x6f, 0xca, 0x8a, 0xb9, 0x12,
0x00, 0x00,
} }

41
weed/server/volume_grpc_copy.go
View file

@ -52,9 +52,13 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
return fmt.Errorf("read volume file status failed, %v", err) return fmt.Errorf("read volume file status failed, %v", err)
} }
// println("source:", volFileInfoResp.String())
copyFileClient, err := client.CopyFile(ctx, &volume_server_pb.CopyFileRequest{ copyFileClient, err := client.CopyFile(ctx, &volume_server_pb.CopyFileRequest{
VolumeId: req.VolumeId, VolumeId: req.VolumeId,
IsIdxFile: true, IsIdxFile: true,
CompactionRevision: volFileInfoResp.CompactionRevision,
StopOffset: volFileInfoResp.IdxFileSize,
}) })
if err != nil { if err != nil {
return fmt.Errorf("failed to start copying volume %d idx file: %v", req.VolumeId, err) return fmt.Errorf("failed to start copying volume %d idx file: %v", req.VolumeId, err)
@ -66,8 +70,10 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
} }
copyFileClient, err = client.CopyFile(ctx, &volume_server_pb.CopyFileRequest{ copyFileClient, err = client.CopyFile(ctx, &volume_server_pb.CopyFileRequest{
VolumeId: req.VolumeId, VolumeId: req.VolumeId,
IsDatFile: true, IsDatFile: true,
CompactionRevision: volFileInfoResp.CompactionRevision,
StopOffset: volFileInfoResp.DatFileSize,
}) })
if err != nil { if err != nil {
return fmt.Errorf("failed to start copying volume %d dat file: %v", req.VolumeId, err) return fmt.Errorf("failed to start copying volume %d dat file: %v", req.VolumeId, err)
@ -97,7 +103,7 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
} }
return &volume_server_pb.VolumeCopyResponse{ return &volume_server_pb.VolumeCopyResponse{
LastAppendAtNs:volFileInfoResp.DatFileTimestampSeconds*uint64(time.Second), LastAppendAtNs: volFileInfoResp.DatFileTimestampSeconds * uint64(time.Second),
}, err }, err
} }
@ -161,6 +167,7 @@ func (vs *VolumeServer) ReadVolumeFileStatus(ctx context.Context, req *volume_se
resp.DatFileTimestampSeconds = uint64(modTime.Unix()) resp.DatFileTimestampSeconds = uint64(modTime.Unix())
resp.IdxFileTimestampSeconds = uint64(modTime.Unix()) resp.IdxFileTimestampSeconds = uint64(modTime.Unix())
resp.FileCount = v.FileCount() resp.FileCount = v.FileCount()
resp.CompactionRevision = uint32(v.CompactionRevision)
return resp, nil return resp, nil
} }
@ -171,7 +178,13 @@ func (vs *VolumeServer) CopyFile(req *volume_server_pb.CopyFileRequest, stream v
return fmt.Errorf("not found volume id %d", req.VolumeId) return fmt.Errorf("not found volume id %d", req.VolumeId)
} }
const BufferSize = 1024 * 16 if uint32(v.CompactionRevision) != req.CompactionRevision {
return fmt.Errorf("volume %d is compacted", req.VolumeId)
}
bytesToRead := int64(req.StopOffset)
const BufferSize = 1024 * 1024 * 2
var fileName = v.FileName() var fileName = v.FileName()
if req.IsDatFile { if req.IsDatFile {
fileName += ".dat" fileName += ".dat"
@ -186,19 +199,31 @@ func (vs *VolumeServer) CopyFile(req *volume_server_pb.CopyFileRequest, stream v
buffer := make([]byte, BufferSize) buffer := make([]byte, BufferSize)
for { for bytesToRead > 0 {
bytesread, err := file.Read(buffer) bytesread, err := file.Read(buffer)
// println(fileName, "read", bytesread, "bytes, with target", bytesToRead)
if err != nil { if err != nil {
if err != io.EOF { if err != io.EOF {
return err return err
} }
// println(fileName, "read", bytesread, "bytes, with target", bytesToRead, "err", err.Error())
break break
} }
stream.Send(&volume_server_pb.CopyFileResponse{ if int64(bytesread) > bytesToRead {
bytesread = int(bytesToRead)
}
err = stream.Send(&volume_server_pb.CopyFileResponse{
FileContent: buffer[:bytesread], FileContent: buffer[:bytesread],
}) })
if err != nil {
// println("sending", bytesread, "bytes err", err.Error())
return err
}
bytesToRead -= int64(bytesread)
} }

2
weed/storage/store.go
View file

@ -125,7 +125,7 @@ func (s *Store) Status() []*VolumeInfo {
DeletedByteCount: v.nm.DeletedSize(), DeletedByteCount: v.nm.DeletedSize(),
ReadOnly: v.readOnly, ReadOnly: v.readOnly,
Ttl: v.Ttl, Ttl: v.Ttl,
CompactRevision: uint32(v.CompactRevision), CompactRevision: uint32(v.CompactionRevision),
} }
stats = append(stats, s) stats = append(stats, s)
} }

2
weed/storage/volume.go
View file

@ -166,6 +166,6 @@ func (v *Volume) ToVolumeInformationMessage() *master_pb.VolumeInformationMessag
ReplicaPlacement: uint32(v.ReplicaPlacement.Byte()), ReplicaPlacement: uint32(v.ReplicaPlacement.Byte()),
Version: uint32(v.Version()), Version: uint32(v.Version()),
Ttl: v.Ttl.ToUint32(), Ttl: v.Ttl.ToUint32(),
CompactRevision: uint32(v.SuperBlock.CompactRevision), CompactRevision: uint32(v.SuperBlock.CompactionRevision),
} }
} }

2
weed/storage/volume_backup.go
View file

@ -20,7 +20,7 @@ func (v *Volume) GetVolumeSyncStatus() *volume_server_pb.VolumeSyncStatusRespons
} }
syncStatus.Collection = v.Collection syncStatus.Collection = v.Collection
syncStatus.IdxFileSize = v.nm.IndexFileSize() syncStatus.IdxFileSize = v.nm.IndexFileSize()
syncStatus.CompactRevision = uint32(v.SuperBlock.CompactRevision) syncStatus.CompactRevision = uint32(v.SuperBlock.CompactionRevision)
syncStatus.Ttl = v.SuperBlock.Ttl.String() syncStatus.Ttl = v.SuperBlock.Ttl.String()
syncStatus.Replication = v.SuperBlock.ReplicaPlacement.String() syncStatus.Replication = v.SuperBlock.ReplicaPlacement.String()
return syncStatus return syncStatus

16
weed/storage/volume_super_block.go
View file

@ -24,12 +24,12 @@ const (
* Rest bytes: Reserved * Rest bytes: Reserved
*/ */
type SuperBlock struct { type SuperBlock struct {
version needle.Version version needle.Version
ReplicaPlacement *ReplicaPlacement ReplicaPlacement *ReplicaPlacement
Ttl *needle.TTL Ttl *needle.TTL
CompactRevision uint16 CompactionRevision uint16
Extra *master_pb.SuperBlockExtra Extra *master_pb.SuperBlockExtra
extraSize uint16 extraSize uint16
} }
func (s *SuperBlock) BlockSize() int { func (s *SuperBlock) BlockSize() int {
@ -48,7 +48,7 @@ func (s *SuperBlock) Bytes() []byte {
header[0] = byte(s.version) header[0] = byte(s.version)
header[1] = s.ReplicaPlacement.Byte() header[1] = s.ReplicaPlacement.Byte()
s.Ttl.ToBytes(header[2:4]) s.Ttl.ToBytes(header[2:4])
util.Uint16toBytes(header[4:6], s.CompactRevision) util.Uint16toBytes(header[4:6], s.CompactionRevision)
if s.Extra != nil { if s.Extra != nil {
extraData, err := proto.Marshal(s.Extra) extraData, err := proto.Marshal(s.Extra)
@ -112,7 +112,7 @@ func ReadSuperBlock(dataFile *os.File) (superBlock SuperBlock, err error) {
return return
} }
superBlock.Ttl = needle.LoadTTLFromBytes(header[2:4]) superBlock.Ttl = needle.LoadTTLFromBytes(header[2:4])
superBlock.CompactRevision = util.BytesToUint16(header[4:6]) superBlock.CompactionRevision = util.BytesToUint16(header[4:6])
superBlock.extraSize = util.BytesToUint16(header[6:8]) superBlock.extraSize = util.BytesToUint16(header[6:8])
if superBlock.extraSize > 0 { if superBlock.extraSize > 0 {

8
weed/storage/volume_vacuum.go
View file

@ -27,7 +27,7 @@ func (v *Volume) Compact(preallocate int64) error {
filePath := v.FileName() filePath := v.FileName()
v.lastCompactIndexOffset = v.nm.IndexFileSize() v.lastCompactIndexOffset = v.nm.IndexFileSize()
v.lastCompactRevision = v.SuperBlock.CompactRevision v.lastCompactRevision = v.SuperBlock.CompactionRevision
glog.V(3).Infof("creating copies for volume %d ,last offset %d...", v.Id, v.lastCompactIndexOffset) glog.V(3).Infof("creating copies for volume %d ,last offset %d...", v.Id, v.lastCompactIndexOffset)
return v.copyDataAndGenerateIndexFile(filePath+".cpd", filePath+".cpx", preallocate) return v.copyDataAndGenerateIndexFile(filePath+".cpd", filePath+".cpx", preallocate)
} }
@ -105,7 +105,7 @@ func fetchCompactRevisionFromDatFile(file *os.File) (compactRevision uint16, err
if err != nil { if err != nil {
return 0, err return 0, err
} }
return superBlock.CompactRevision, nil return superBlock.CompactionRevision, nil
} }
func (v *Volume) makeupDiff(newDatFileName, newIdxFileName, oldDatFileName, oldIdxFileName string) (err error) { func (v *Volume) makeupDiff(newDatFileName, newIdxFileName, oldDatFileName, oldIdxFileName string) (err error) {
@ -246,7 +246,7 @@ type VolumeFileScanner4Vacuum struct {
func (scanner *VolumeFileScanner4Vacuum) VisitSuperBlock(superBlock SuperBlock) error { func (scanner *VolumeFileScanner4Vacuum) VisitSuperBlock(superBlock SuperBlock) error {
scanner.version = superBlock.Version() scanner.version = superBlock.Version()
superBlock.CompactRevision++ superBlock.CompactionRevision++
_, err := scanner.dst.Write(superBlock.Bytes()) _, err := scanner.dst.Write(superBlock.Bytes())
scanner.newOffset = int64(superBlock.BlockSize()) scanner.newOffset = int64(superBlock.BlockSize())
return err return err
@ -321,7 +321,7 @@ func (v *Volume) copyDataBasedOnIndexFile(dstName, idxName string) (err error) {
nm := NewBtreeNeedleMap(idx) nm := NewBtreeNeedleMap(idx)
now := uint64(time.Now().Unix()) now := uint64(time.Now().Unix())
v.SuperBlock.CompactRevision++ v.SuperBlock.CompactionRevision++
dst.Write(v.SuperBlock.Bytes()) dst.Write(v.SuperBlock.Bytes())
newOffset := int64(v.SuperBlock.BlockSize()) newOffset := int64(v.SuperBlock.BlockSize())