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

migrate volume sync status to grpc API on volume server

Browse source
This commit is contained in:
Chris Lu 2018-10-15 01:19:15 -07:00
parent b423bb9e2d
commit fda771c83f
10 changed files with 215 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
weed/command/backup.go
View file

@ -59,7 +59,7 @@ func runBackup(cmd *Command, args []string) bool {
}
volumeServer := lookup.Locations[0].Url
stats, err := operation.GetVolumeSyncStatus(volumeServer, vid.String())
stats, err := operation.GetVolumeSyncStatus(volumeServer, uint32(vid))
if err != nil {
fmt.Printf("Error get volume %d status: %v\n", vid, err)
return true

39
weed/operation/sync_volume.go
View file

@ -1,41 +1,24 @@
package operation
import (
"encoding/json"
"fmt"
"context"
"net/url"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
. "github.com/chrislusf/seaweedfs/weed/storage/types"
"github.com/chrislusf/seaweedfs/weed/util"
)
type SyncVolumeResponse struct {
Replication string `json:"Replication,omitempty"`
Ttl string `json:"Ttl,omitempty"`
TailOffset uint64 `json:"TailOffset,omitempty"`
CompactRevision uint16 `json:"CompactRevision,omitempty"`
IdxFileSize uint64 `json:"IdxFileSize,omitempty"`
Error string `json:"error,omitempty"`
}
func GetVolumeSyncStatus(server string, vid uint32) (resp *volume_server_pb.VolumeSyncStatusResponse, err error) {
func GetVolumeSyncStatus(server string, vid string) (*SyncVolumeResponse, error) {
values := make(url.Values)
values.Add("volume", vid)
jsonBlob, err := util.Post("http://"+server+"/admin/sync/status", values)
glog.V(2).Info("sync volume result :", string(jsonBlob))
if err != nil {
return nil, err
}
var ret SyncVolumeResponse
err = json.Unmarshal(jsonBlob, &ret)
if err != nil {
return nil, err
}
if ret.Error != "" {
return nil, fmt.Errorf("Volume %s get sync status error: %s", vid, ret.Error)
}
return &ret, nil
WithVolumeServerClient(server, func(client volume_server_pb.VolumeServerClient) error {
resp, err = client.VolumeSyncStatus(context.Background(), &volume_server_pb.VolumeSyncStatusRequest{
VolumdId: vid,
})
return nil
})
return
}
func GetVolumeIdxEntries(server string, vid string, eachEntryFn func(key NeedleId, offset Offset, size uint32)) error {

14
weed/pb/volume_server.proto
View file

@ -21,6 +21,8 @@ service VolumeServer {
}
rpc AssignVolume (AssignVolumeRequest) returns (AssignVolumeResponse) {
}
rpc VolumeSyncStatus (VolumeSyncStatusRequest) returns (VolumeSyncStatusResponse) {
}
}
//////////////////////////////////////////////////
@ -83,3 +85,15 @@ message AssignVolumeRequest {
}
message AssignVolumeResponse {
}
message VolumeSyncStatusRequest {
uint32 volumd_id = 1;
}
message VolumeSyncStatusResponse {
uint32 volumd_id = 1;
string replication = 4;
string ttl = 5;
uint64 tail_offset = 6;
uint32 compact_revision = 7;
uint64 idx_file_size = 8;
}

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

@ -25,6 +25,8 @@ It has these top-level messages:
DeleteCollectionResponse
AssignVolumeRequest
AssignVolumeResponse
VolumeSyncStatusRequest
VolumeSyncStatusResponse
*/
package volume_server_pb
@ -320,6 +322,78 @@ func (m *AssignVolumeResponse) String() string { return proto.Compact
func (*AssignVolumeResponse) ProtoMessage() {}
func (*AssignVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
type VolumeSyncStatusRequest struct {
VolumdId uint32 `protobuf:"varint,1,opt,name=volumd_id,json=volumdId" json:"volumd_id,omitempty"`
}
func (m *VolumeSyncStatusRequest) Reset() { *m = VolumeSyncStatusRequest{} }
func (m *VolumeSyncStatusRequest) String() string { return proto.CompactTextString(m) }
func (*VolumeSyncStatusRequest) ProtoMessage() {}
func (*VolumeSyncStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
func (m *VolumeSyncStatusRequest) GetVolumdId() uint32 {
if m != nil {
return m.VolumdId
}
return 0
}
type VolumeSyncStatusResponse struct {
VolumdId uint32 `protobuf:"varint,1,opt,name=volumd_id,json=volumdId" json:"volumd_id,omitempty"`
Replication string `protobuf:"bytes,4,opt,name=replication" json:"replication,omitempty"`
Ttl string `protobuf:"bytes,5,opt,name=ttl" json:"ttl,omitempty"`
TailOffset uint64 `protobuf:"varint,6,opt,name=tail_offset,json=tailOffset" json:"tail_offset,omitempty"`
CompactRevision uint32 `protobuf:"varint,7,opt,name=compact_revision,json=compactRevision" json:"compact_revision,omitempty"`
IdxFileSize uint64 `protobuf:"varint,8,opt,name=idx_file_size,json=idxFileSize" json:"idx_file_size,omitempty"`
}
func (m *VolumeSyncStatusResponse) Reset() { *m = VolumeSyncStatusResponse{} }
func (m *VolumeSyncStatusResponse) String() string { return proto.CompactTextString(m) }
func (*VolumeSyncStatusResponse) ProtoMessage() {}
func (*VolumeSyncStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
func (m *VolumeSyncStatusResponse) GetVolumdId() uint32 {
if m != nil {
return m.VolumdId
}
return 0
}
func (m *VolumeSyncStatusResponse) GetReplication() string {
if m != nil {
return m.Replication
}
return ""
}
func (m *VolumeSyncStatusResponse) GetTtl() string {
if m != nil {
return m.Ttl
}
return ""
}
func (m *VolumeSyncStatusResponse) GetTailOffset() uint64 {
if m != nil {
return m.TailOffset
}
return 0
}
func (m *VolumeSyncStatusResponse) GetCompactRevision() uint32 {
if m != nil {
return m.CompactRevision
}
return 0
}
func (m *VolumeSyncStatusResponse) GetIdxFileSize() uint64 {
if m != nil {
return m.IdxFileSize
}
return 0
}
func init() {
proto.RegisterType((*BatchDeleteRequest)(nil), "volume_server_pb.BatchDeleteRequest")
proto.RegisterType((*BatchDeleteResponse)(nil), "volume_server_pb.BatchDeleteResponse")
@ -337,6 +411,8 @@ func init() {
proto.RegisterType((*DeleteCollectionResponse)(nil), "volume_server_pb.DeleteCollectionResponse")
proto.RegisterType((*AssignVolumeRequest)(nil), "volume_server_pb.AssignVolumeRequest")
proto.RegisterType((*AssignVolumeResponse)(nil), "volume_server_pb.AssignVolumeResponse")
proto.RegisterType((*VolumeSyncStatusRequest)(nil), "volume_server_pb.VolumeSyncStatusRequest")
proto.RegisterType((*VolumeSyncStatusResponse)(nil), "volume_server_pb.VolumeSyncStatusResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
@ -358,6 +434,7 @@ type VolumeServerClient interface {
VacuumVolumeCleanup(ctx context.Context, in *VacuumVolumeCleanupRequest, opts ...grpc.CallOption) (*VacuumVolumeCleanupResponse, error)
DeleteCollection(ctx context.Context, in *DeleteCollectionRequest, opts ...grpc.CallOption) (*DeleteCollectionResponse, error)
AssignVolume(ctx context.Context, in *AssignVolumeRequest, opts ...grpc.CallOption) (*AssignVolumeResponse, error)
VolumeSyncStatus(ctx context.Context, in *VolumeSyncStatusRequest, opts ...grpc.CallOption) (*VolumeSyncStatusResponse, error)
}
type volumeServerClient struct {
@ -431,6 +508,15 @@ func (c *volumeServerClient) AssignVolume(ctx context.Context, in *AssignVolumeR
return out, nil
}
func (c *volumeServerClient) VolumeSyncStatus(ctx context.Context, in *VolumeSyncStatusRequest, opts ...grpc.CallOption) (*VolumeSyncStatusResponse, error) {
out := new(VolumeSyncStatusResponse)
err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VolumeSyncStatus", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for VolumeServer service
type VolumeServerServer interface {
@ -442,6 +528,7 @@ type VolumeServerServer interface {
VacuumVolumeCleanup(context.Context, *VacuumVolumeCleanupRequest) (*VacuumVolumeCleanupResponse, error)
DeleteCollection(context.Context, *DeleteCollectionRequest) (*DeleteCollectionResponse, error)
AssignVolume(context.Context, *AssignVolumeRequest) (*AssignVolumeResponse, error)
VolumeSyncStatus(context.Context, *VolumeSyncStatusRequest) (*VolumeSyncStatusResponse, error)
}
func RegisterVolumeServerServer(s *grpc.Server, srv VolumeServerServer) {
@ -574,6 +661,24 @@ func _VolumeServer_AssignVolume_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
func _VolumeServer_VolumeSyncStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(VolumeSyncStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(VolumeServerServer).VolumeSyncStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/volume_server_pb.VolumeServer/VolumeSyncStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(VolumeServerServer).VolumeSyncStatus(ctx, req.(*VolumeSyncStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
var _VolumeServer_serviceDesc = grpc.ServiceDesc{
ServiceName: "volume_server_pb.VolumeServer",
HandlerType: (*VolumeServerServer)(nil),
@ -606,6 +711,10 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
MethodName: "AssignVolume",
Handler: _VolumeServer_AssignVolume_Handler,
},
{
MethodName: "VolumeSyncStatus",
Handler: _VolumeServer_VolumeSyncStatus_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "volume_server.proto",
@ -614,41 +723,48 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 571 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x55, 0x4b, 0x6f, 0xd3, 0x40,
0x10, 0xae, 0x9b, 0x57, 0x33, 0x49, 0xa4, 0x30, 0xa9, 0x5a, 0xd7, 0x85, 0x2a, 0x5a, 0x1e, 0x0a,
0x6d, 0x09, 0x52, 0x39, 0x50, 0x6e, 0x40, 0xe1, 0xd0, 0x13, 0x92, 0x91, 0x7a, 0x01, 0x29, 0x72,
0x9c, 0x25, 0xb5, 0xba, 0xce, 0xba, 0xbb, 0xeb, 0x4a, 0xf0, 0x0f, 0xf8, 0x27, 0xfc, 0x4c, 0x94,
0xf5, 0xa3, 0x7e, 0x24, 0xb2, 0x6f, 0xf6, 0xec, 0xf7, 0x98, 0x59, 0xcf, 0x97, 0xc0, 0xe8, 0x81,
0xb3, 0xd0, 0xa7, 0x33, 0x49, 0xc5, 0x03, 0x15, 0xd3, 0x40, 0x70, 0xc5, 0x71, 0x98, 0x2b, 0xce,
0x82, 0x39, 0x79, 0x0b, 0xf8, 0xd9, 0x51, 0xee, 0xed, 0x17, 0xca, 0xa8, 0xa2, 0x36, 0xbd, 0x0f,
0xa9, 0x54, 0x78, 0x04, 0x7b, 0xbf, 0x3c, 0x46, 0x67, 0xde, 0x42, 0x9a, 0xc6, 0xb8, 0x31, 0xe9,
0xda, 0x9d, 0xf5, 0xfb, 0xf5, 0x42, 0x92, 0x6f, 0x30, 0xca, 0x11, 0x64, 0xc0, 0x57, 0x92, 0xe2,
0x25, 0x74, 0x04, 0x95, 0x21, 0x53, 0x11, 0xa1, 0x77, 0x71, 0x32, 0x2d, 0x7a, 0x4d, 0x53, 0x4a,
0xc8, 0x94, 0x9d, 0xc0, 0x89, 0x07, 0xfd, 0xec, 0x01, 0x1e, 0x42, 0x27, 0xf6, 0x36, 0x8d, 0xb1,
0x31, 0xe9, 0xda, 0xed, 0xc8, 0x1a, 0x0f, 0xa0, 0x2d, 0x95, 0xa3, 0x42, 0x69, 0xee, 0x8e, 0x8d,
0x49, 0xcb, 0x8e, 0xdf, 0x70, 0x1f, 0x5a, 0x54, 0x08, 0x2e, 0xcc, 0x86, 0x86, 0x47, 0x2f, 0x88,
0xd0, 0x94, 0xde, 0x1f, 0x6a, 0x36, 0xc7, 0xc6, 0x64, 0x60, 0xeb, 0x67, 0xd2, 0x81, 0xd6, 0x57,
0x3f, 0x50, 0xbf, 0xc9, 0x7b, 0x30, 0x6f, 0x1c, 0x37, 0x0c, 0xfd, 0x1b, 0xdd, 0xe3, 0xd5, 0x2d,
0x75, 0xef, 0x92, 0xd9, 0x8f, 0xa1, 0xab, 0x3b, 0x5f, 0x24, 0x1d, 0x0c, 0xec, 0xbd, 0xa8, 0x70,
0xbd, 0x20, 0x1f, 0xe1, 0x68, 0x03, 0x31, 0xbe, 0x83, 0xe7, 0x30, 0x58, 0x3a, 0x62, 0xee, 0x2c,
0xe9, 0x4c, 0x38, 0xca, 0xe3, 0x9a, 0x6d, 0xd8, 0xfd, 0xb8, 0x68, 0xaf, 0x6b, 0xe4, 0x07, 0x58,
0x39, 0x05, 0xee, 0x07, 0x8e, 0xab, 0xea, 0x98, 0xe3, 0x18, 0x7a, 0x81, 0xa0, 0x0e, 0x63, 0xdc,
0x75, 0x14, 0xd5, 0xb7, 0xd0, 0xb0, 0xb3, 0x25, 0xf2, 0x0c, 0x8e, 0x37, 0x8a, 0x47, 0x0d, 0x92,
0xcb, 0x42, 0xf7, 0xdc, 0xf7, 0xbd, 0x5a, 0xd6, 0xe4, 0x69, 0xa9, 0x6b, 0xcd, 0x8c, 0x75, 0x3f,
0x14, 0x4e, 0x19, 0x75, 0x56, 0x61, 0x50, 0x4b, 0xb8, 0xd8, 0x71, 0x42, 0x4d, 0x95, 0x0f, 0xa3,
0xe5, 0xb8, 0xe2, 0x8c, 0x51, 0x57, 0x79, 0x7c, 0x95, 0xc8, 0x9e, 0x00, 0xb8, 0x69, 0x31, 0x5e,
0x95, 0x4c, 0x85, 0x58, 0x60, 0x96, 0xa9, 0xb1, 0xec, 0x3f, 0x03, 0x46, 0x9f, 0xa4, 0xf4, 0x96,
0xab, 0xc8, 0xb6, 0xd6, 0xf5, 0xe7, 0x0d, 0x77, 0x8b, 0x86, 0xc5, 0xcf, 0xd3, 0x28, 0x7d, 0x9e,
0x35, 0x42, 0xd0, 0x80, 0x79, 0xae, 0xa3, 0x25, 0x9a, 0x5a, 0x22, 0x5b, 0xc2, 0x21, 0x34, 0x94,
0x62, 0x66, 0x4b, 0x9f, 0xac, 0x1f, 0xc9, 0x01, 0xec, 0xe7, 0x3b, 0x8d, 0x46, 0xb8, 0xf8, 0xdb,
0x86, 0x7e, 0x54, 0xfa, 0xae, 0x03, 0x86, 0x3f, 0xa1, 0x97, 0x09, 0x26, 0xbe, 0x28, 0xe7, 0xaf,
0x1c, 0x74, 0xeb, 0x65, 0x05, 0x2a, 0xbe, 0xaf, 0x1d, 0x5c, 0xc1, 0x93, 0xd2, 0xe2, 0xe3, 0x69,
0x99, 0xbd, 0x2d, 0x56, 0xd6, 0x59, 0x2d, 0x6c, 0xea, 0xa7, 0x60, 0xb4, 0x61, 0x93, 0xf1, 0xbc,
0x42, 0x25, 0x97, 0x26, 0xeb, 0x4d, 0x4d, 0x74, 0xea, 0x7a, 0x0f, 0x58, 0x5e, 0x73, 0x3c, 0xab,
0x94, 0x79, 0x8c, 0x91, 0x75, 0x5e, 0x0f, 0xbc, 0x75, 0xd0, 0x28, 0x00, 0x95, 0x83, 0xe6, 0x22,
0x56, 0x39, 0x68, 0x21, 0x55, 0x3b, 0x78, 0x07, 0xc3, 0x62, 0x38, 0xf0, 0xf5, 0xb6, 0x5f, 0xec,
0x52, 0xf6, 0xac, 0xd3, 0x3a, 0xd0, 0xd4, 0x6c, 0x06, 0xfd, 0xec, 0x0a, 0xe3, 0x86, 0xa5, 0xdb,
0x10, 0x46, 0xeb, 0x55, 0x15, 0x2c, 0x31, 0x98, 0xb7, 0xf5, 0xbf, 0xdb, 0xbb, 0xff, 0x01, 0x00,
0x00, 0xff, 0xff, 0x8b, 0xec, 0xe8, 0xd9, 0xf4, 0x06, 0x00, 0x00,
// 683 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x56, 0x5b, 0x4f, 0xdb, 0x4c,
0x10, 0xc5, 0xe4, 0x06, 0x93, 0x44, 0x5f, 0xbe, 0x0d, 0x02, 0x63, 0x5a, 0x1a, 0x6d, 0x2f, 0x0a,
0x97, 0x52, 0x89, 0x4a, 0x2d, 0x7d, 0x6b, 0x4b, 0x5b, 0x89, 0x27, 0x24, 0x23, 0xf1, 0xd2, 0x4a,
0x96, 0x71, 0x06, 0x58, 0xb1, 0x89, 0xcd, 0xee, 0x1a, 0x01, 0xbf, 0xa8, 0xff, 0xa9, 0xff, 0xa3,
0xcf, 0x55, 0xd6, 0x4e, 0xea, 0x5b, 0x64, 0xf7, 0xcd, 0x3e, 0x9e, 0x39, 0x67, 0x66, 0x77, 0xe6,
0x24, 0xd0, 0xbf, 0xf3, 0x79, 0x38, 0x46, 0x47, 0xa2, 0xb8, 0x43, 0x71, 0x10, 0x08, 0x5f, 0xf9,
0xa4, 0x97, 0x02, 0x9d, 0xe0, 0x82, 0xbe, 0x01, 0xf2, 0xd9, 0x55, 0xde, 0xf5, 0x17, 0xe4, 0xa8,
0xd0, 0xc6, 0xdb, 0x10, 0xa5, 0x22, 0x9b, 0xb0, 0x72, 0xc9, 0x38, 0x3a, 0x6c, 0x24, 0x4d, 0x63,
0x50, 0x1b, 0xae, 0xda, 0xad, 0xe9, 0xfb, 0xc9, 0x48, 0xd2, 0x53, 0xe8, 0xa7, 0x12, 0x64, 0xe0,
0x4f, 0x24, 0x92, 0x23, 0x68, 0x09, 0x94, 0x21, 0x57, 0x51, 0x42, 0xfb, 0x70, 0xfb, 0x20, 0xab,
0x75, 0x30, 0x4f, 0x09, 0xb9, 0xb2, 0x67, 0xe1, 0x94, 0x41, 0x27, 0xf9, 0x81, 0x6c, 0x40, 0x2b,
0xd6, 0x36, 0x8d, 0x81, 0x31, 0x5c, 0xb5, 0x9b, 0x91, 0x34, 0x59, 0x87, 0xa6, 0x54, 0xae, 0x0a,
0xa5, 0xb9, 0x3c, 0x30, 0x86, 0x0d, 0x3b, 0x7e, 0x23, 0x6b, 0xd0, 0x40, 0x21, 0x7c, 0x61, 0xd6,
0x74, 0x78, 0xf4, 0x42, 0x08, 0xd4, 0x25, 0x7b, 0x44, 0xb3, 0x3e, 0x30, 0x86, 0x5d, 0x5b, 0x3f,
0xd3, 0x16, 0x34, 0xbe, 0x8e, 0x03, 0xf5, 0x40, 0xdf, 0x83, 0x79, 0xee, 0x7a, 0x61, 0x38, 0x3e,
0xd7, 0x35, 0x1e, 0x5f, 0xa3, 0x77, 0x33, 0xeb, 0x7d, 0x0b, 0x56, 0x75, 0xe5, 0xa3, 0x59, 0x05,
0x5d, 0x7b, 0x25, 0x02, 0x4e, 0x46, 0xf4, 0x23, 0x6c, 0x16, 0x24, 0xc6, 0x67, 0xf0, 0x1c, 0xba,
0x57, 0xae, 0xb8, 0x70, 0xaf, 0xd0, 0x11, 0xae, 0x62, 0xbe, 0xce, 0x36, 0xec, 0x4e, 0x0c, 0xda,
0x53, 0x8c, 0x7e, 0x07, 0x2b, 0xc5, 0xe0, 0x8f, 0x03, 0xd7, 0x53, 0x55, 0xc4, 0xc9, 0x00, 0xda,
0x81, 0x40, 0x97, 0x73, 0xdf, 0x73, 0x15, 0xea, 0x53, 0xa8, 0xd9, 0x49, 0x88, 0x3e, 0x85, 0xad,
0x42, 0xf2, 0xa8, 0x40, 0x7a, 0x94, 0xa9, 0xde, 0x1f, 0x8f, 0x59, 0x25, 0x69, 0xfa, 0x24, 0x57,
0xb5, 0xce, 0x8c, 0x79, 0x3f, 0x64, 0xbe, 0x72, 0x74, 0x27, 0x61, 0x50, 0x89, 0x38, 0x5b, 0xf1,
0x2c, 0x75, 0xce, 0xbc, 0x11, 0x0d, 0xc7, 0xb1, 0xcf, 0x39, 0x7a, 0x8a, 0xf9, 0x93, 0x19, 0xed,
0x36, 0x80, 0x37, 0x07, 0xe3, 0x51, 0x49, 0x20, 0xd4, 0x02, 0x33, 0x9f, 0x1a, 0xd3, 0xfe, 0x34,
0xa0, 0xff, 0x49, 0x4a, 0x76, 0x35, 0x89, 0x64, 0x2b, 0x1d, 0x7f, 0x5a, 0x70, 0x39, 0x2b, 0x98,
0xbd, 0x9e, 0x5a, 0xee, 0x7a, 0xa6, 0x11, 0x02, 0x03, 0xce, 0x3c, 0x57, 0x53, 0xd4, 0x35, 0x45,
0x12, 0x22, 0x3d, 0xa8, 0x29, 0xc5, 0xcd, 0x86, 0xfe, 0x32, 0x7d, 0xa4, 0xeb, 0xb0, 0x96, 0xae,
0x34, 0x6e, 0xe1, 0x1d, 0x6c, 0x44, 0xc8, 0xd9, 0xc3, 0xc4, 0x3b, 0xd3, 0x9b, 0x50, 0xe9, 0xc0,
0x7f, 0x19, 0x60, 0xe6, 0x13, 0xe3, 0x09, 0x2e, 0x1b, 0xbf, 0x7f, 0xad, 0x9e, 0x3c, 0x83, 0xb6,
0x72, 0x19, 0x77, 0xfc, 0xcb, 0x4b, 0x89, 0xca, 0x6c, 0x0e, 0x8c, 0x61, 0xdd, 0x86, 0x29, 0x74,
0xaa, 0x11, 0xb2, 0x03, 0x3d, 0x2f, 0x9a, 0x52, 0x47, 0xe0, 0x1d, 0x93, 0x53, 0xe6, 0x96, 0x16,
0xfe, 0xcf, 0x9b, 0x4d, 0x6f, 0x04, 0x13, 0x0a, 0x5d, 0x36, 0xba, 0x77, 0xb4, 0x39, 0xe8, 0xd5,
0x5e, 0xd1, 0x6c, 0x6d, 0x36, 0xba, 0xff, 0xc6, 0x38, 0x9e, 0xb1, 0x47, 0x3c, 0xfc, 0xdd, 0x84,
0x4e, 0xdc, 0x9d, 0xb6, 0x1d, 0xf2, 0x03, 0xda, 0x09, 0xbb, 0x22, 0x2f, 0xf2, 0xae, 0x94, 0xb7,
0x3f, 0xeb, 0x65, 0x49, 0x54, 0x7c, 0x05, 0x4b, 0x64, 0x02, 0xff, 0xe7, 0xec, 0x80, 0xec, 0xe6,
0xb3, 0x17, 0x99, 0x8d, 0xb5, 0x57, 0x29, 0x76, 0xae, 0xa7, 0xa0, 0x5f, 0xb0, 0xdf, 0x64, 0xbf,
0x84, 0x25, 0xe5, 0x31, 0xd6, 0xeb, 0x8a, 0xd1, 0x73, 0xd5, 0x5b, 0x20, 0xf9, 0xe5, 0x27, 0x7b,
0xa5, 0x34, 0x7f, 0xcd, 0xc5, 0xda, 0xaf, 0x16, 0xbc, 0xb0, 0xd1, 0xc8, 0x16, 0x4a, 0x1b, 0x4d,
0x19, 0x4f, 0x69, 0xa3, 0x19, 0xaf, 0x59, 0x22, 0x37, 0xd0, 0xcb, 0x5a, 0x06, 0xd9, 0x59, 0xf4,
0x3b, 0x96, 0x73, 0x24, 0x6b, 0xb7, 0x4a, 0xe8, 0x5c, 0xcc, 0x81, 0x4e, 0x72, 0xb1, 0x49, 0xc1,
0xd0, 0x15, 0x58, 0x94, 0xf5, 0xaa, 0x2c, 0x2c, 0xd9, 0x4d, 0x76, 0xd1, 0x8b, 0xba, 0x59, 0xe0,
0x22, 0x45, 0xdd, 0x2c, 0xf2, 0x0d, 0xba, 0x74, 0xd1, 0xd4, 0x7f, 0x30, 0xde, 0xfe, 0x09, 0x00,
0x00, 0xff, 0xff, 0xf6, 0x2c, 0x4e, 0x35, 0x77, 0x08, 0x00, 0x00,
}

25
weed/server/volume_grpc_sync.go Normal file
View file

@ -0,0 +1,25 @@
package weed_server
import (
"context"
"fmt"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
"github.com/chrislusf/seaweedfs/weed/storage"
)
func (vs *VolumeServer) VolumeSyncStatus(ctx context.Context, req *volume_server_pb.VolumeSyncStatusRequest) (*volume_server_pb.VolumeSyncStatusResponse, error) {
v := vs.store.GetVolume(storage.VolumeId(req.VolumdId))
if v == nil {
return nil, fmt.Errorf("Not Found Volume Id %d", req.VolumdId)
}
resp := v.GetVolumeSyncStatus()
glog.V(2).Infof("volume sync status %d", req.VolumdId)
return resp, nil
}

1
weed/server/volume_server.go
View file

@ -47,7 +47,6 @@ func NewVolumeServer(adminMux, publicMux *http.ServeMux, ip string,
handleStaticResources(adminMux)
adminMux.HandleFunc("/ui/index.html", vs.uiStatusHandler)
adminMux.HandleFunc("/status", vs.guard.WhiteList(vs.statusHandler))
adminMux.HandleFunc("/admin/sync/status", vs.guard.WhiteList(vs.getVolumeSyncStatusHandler))
adminMux.HandleFunc("/admin/sync/index", vs.guard.WhiteList(vs.getVolumeIndexContentHandler))
adminMux.HandleFunc("/admin/sync/data", vs.guard.WhiteList(vs.getVolumeDataContentHandler))
adminMux.HandleFunc("/admin/volume/mount", vs.guard.WhiteList(vs.getVolumeMountHandler))

7
weed/server/volume_server_handlers_admin.go
View file

@ -2,11 +2,11 @@ package weed_server
import (
"fmt"
"net/http"
"path/filepath"
"github.com/chrislusf/seaweedfs/weed/stats"
"github.com/chrislusf/seaweedfs/weed/stats"
"github.com/chrislusf/seaweedfs/weed/storage"
"github.com/chrislusf/seaweedfs/weed/util"
"net/http"
"path/filepath"
)
func (vs *VolumeServer) statusHandler(w http.ResponseWriter, r *http.Request) {
@ -29,6 +29,7 @@ func (vs *VolumeServer) statsDiskHandler(w http.ResponseWriter, r *http.Request)
writeJsonQuiet(w, r, http.StatusOK, m)
}
// TODO delete this when volume sync is all moved to grpc
func (vs *VolumeServer) getVolume(volumeParameterName string, r *http.Request) (*storage.Volume, error) {
vid, err := vs.getVolumeId(volumeParameterName, r)
if err != nil {

16
weed/server/volume_server_handlers_sync.go
View file

@ -4,27 +4,11 @@ import (
"fmt"
"net/http"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/storage"
"github.com/chrislusf/seaweedfs/weed/storage/types"
"github.com/chrislusf/seaweedfs/weed/util"
)
func (vs *VolumeServer) getVolumeSyncStatusHandler(w http.ResponseWriter, r *http.Request) {
v, err := vs.getVolume("volume", r)
if v == nil {
writeJsonError(w, r, http.StatusBadRequest, err)
return
}
syncStat := v.GetVolumeSyncStatus()
if syncStat.Error != "" {
writeJsonError(w, r, http.StatusInternalServerError, fmt.Errorf("Get Volume %d status error: %s", v.Id, syncStat.Error))
glog.V(2).Infoln("getVolumeSyncStatusHandler volume =", r.FormValue("volume"), ", error =", err)
} else {
writeJsonQuiet(w, r, http.StatusOK, syncStat)
}
}
func (vs *VolumeServer) getVolumeIndexContentHandler(w http.ResponseWriter, r *http.Request) {
v, err := vs.getVolume("volume", r)
if v == nil {

11
weed/storage/volume_sync.go
View file

@ -11,6 +11,7 @@ import (
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/operation"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
"github.com/chrislusf/seaweedfs/weed/storage/needle"
. "github.com/chrislusf/seaweedfs/weed/storage/types"
"github.com/chrislusf/seaweedfs/weed/util"
@ -142,7 +143,7 @@ func (v *Volume) trySynchronizing(volumeServer string, masterMap *needle.Compact
func fetchVolumeFileEntries(volumeServer string, vid VolumeId) (m *needle.CompactMap, lastOffset uint64, compactRevision uint16, err error) {
m = needle.NewCompactMap()
syncStatus, err := operation.GetVolumeSyncStatus(volumeServer, vid.String())
syncStatus, err := operation.GetVolumeSyncStatus(volumeServer, uint32(vid))
if err != nil {
return m, 0, 0, err
}
@ -159,17 +160,17 @@ func fetchVolumeFileEntries(volumeServer string, vid VolumeId) (m *needle.Compac
})
glog.V(2).Infof("server %s volume %d, entries %d, last offset %d, revision %d", volumeServer, vid, total, syncStatus.TailOffset, syncStatus.CompactRevision)
return m, syncStatus.TailOffset, syncStatus.CompactRevision, err
return m, syncStatus.TailOffset, uint16(syncStatus.CompactRevision), err
}
func (v *Volume) GetVolumeSyncStatus() operation.SyncVolumeResponse {
var syncStatus = operation.SyncVolumeResponse{}
func (v *Volume) GetVolumeSyncStatus() *volume_server_pb.VolumeSyncStatusResponse {
var syncStatus = &volume_server_pb.VolumeSyncStatusResponse{}
if stat, err := v.dataFile.Stat(); err == nil {
syncStatus.TailOffset = uint64(stat.Size())
}
syncStatus.IdxFileSize = v.nm.IndexFileSize()
syncStatus.CompactRevision = v.SuperBlock.CompactRevision
syncStatus.CompactRevision = uint32(v.SuperBlock.CompactRevision)
syncStatus.Ttl = v.SuperBlock.Ttl.String()
syncStatus.Replication = v.SuperBlock.ReplicaPlacement.String()
return syncStatus

2
weed/topology/allocate_volume.go
View file

@ -3,9 +3,9 @@ package topology
import (
"context"
"github.com/chrislusf/seaweedfs/weed/storage"
"github.com/chrislusf/seaweedfs/weed/operation"
"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
"github.com/chrislusf/seaweedfs/weed/storage"
)
type AllocateVolumeResult struct {