Mirror
/
seaweedfs
mirror of https://github.com/seaweedfs/seaweedfs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

add fs.FSStatfser for SeaweedFS weed mount

pull/778/head
Chris Lu 6 years ago
parent
2e32b44061
commit
444dfded84
10 changed files with 584 additions and 139 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 43
      weed/filesys/wfs.go
  2. 24
      weed/operation/stats.go
  3. 17
      weed/pb/filer.proto
  4. 275
      weed/pb/filer_pb/filer.pb.go
  5. 16
      weed/pb/master.proto
  6. 254
      weed/pb/master_pb/master.pb.go
  7. 25
      weed/server/filer_grpc_server.go
  8. 26
      weed/server/master_grpc_server_volume.go
  9. 29
      weed/topology/volume_layout.go
  10. 14
      weed/topology/volume_location_list.go

43
weed/filesys/wfs.go
View File

@ -43,6 +43,12 @@ type WFS struct {
// cache grpc connections // cache grpc connections
grpcClients map[string]*grpc.ClientConn grpcClients map[string]*grpc.ClientConn
grpcClientsLock sync.Mutex grpcClientsLock sync.Mutex
stats statsCache
}
type statsCache struct {
filer_pb.StatisticsResponse
lastChecked int64 // unix time in seconds
} }
func NewSeaweedFileSystem(option *Option) *WFS { func NewSeaweedFileSystem(option *Option) *WFS {
@ -139,9 +145,40 @@ func (wfs *WFS) Statfs(ctx context.Context, req *fuse.StatfsRequest, resp *fuse.
glog.V(4).Infof("reading fs stats: %+v", req) glog.V(4).Infof("reading fs stats: %+v", req)
totalDiskSize := uint64(0)
usedDiskSize := uint64(0)
actualFileCount := uint64(0)
if wfs.stats.lastChecked < time.Now().Unix()-20 {
err := wfs.withFilerClient(func(client filer_pb.SeaweedFilerClient) error {
request := &filer_pb.StatisticsRequest{
Collection: wfs.option.Collection,
Replication: wfs.option.Replication,
Ttl: fmt.Sprintf("%ds", wfs.option.TtlSec),
}
glog.V(4).Infof("reading filer stats: %+v", request)
resp, err := client.Statistics(ctx, request)
if err != nil {
glog.V(0).Infof("reading filer stats %v: %v", request, err)
return err
}
glog.V(4).Infof("read filer stats: %+v", resp)
wfs.stats.TotalSize = resp.TotalSize
wfs.stats.UsedSize = resp.UsedSize
wfs.stats.FileCount = resp.FileCount
wfs.stats.lastChecked = time.Now().Unix()
return nil
})
if err != nil {
glog.V(0).Infof("filer Statistics: %v", err)
return err
}
}
totalDiskSize := wfs.stats.TotalSize
usedDiskSize := wfs.stats.UsedSize
actualFileCount := wfs.stats.FileCount
// Compute the total number of available blocks // Compute the total number of available blocks
resp.Blocks = totalDiskSize / blockSize resp.Blocks = totalDiskSize / blockSize

24
weed/operation/stats.go
View File

@ -0,0 +1,24 @@
package operation
import (
"context"
"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
)
func Statistics(server string, req *master_pb.StatisticsRequest) (resp *master_pb.StatisticsResponse, err error) {
err = withMasterServerClient(server, func(masterClient master_pb.SeaweedClient) error {
grpcResponse, grpcErr := masterClient.Statistics(context.Background(), req)
if grpcErr != nil {
return grpcErr
}
resp = grpcResponse
return nil
})
return
}

17
weed/pb/filer.proto
View File

@ -30,6 +30,9 @@ service SeaweedFiler {
rpc DeleteCollection (DeleteCollectionRequest) returns (DeleteCollectionResponse) { rpc DeleteCollection (DeleteCollectionRequest) returns (DeleteCollectionResponse) {
} }
rpc Statistics (StatisticsRequest) returns (StatisticsResponse) {
}
} }
////////////////////////////////////////////////// //////////////////////////////////////////////////
@ -154,3 +157,17 @@ message DeleteCollectionRequest {
message DeleteCollectionResponse { message DeleteCollectionResponse {
} }
message StatisticsRequest {
string replication = 1;
string collection = 2;
string ttl = 3;
}
message StatisticsResponse {
string replication = 1;
string collection = 2;
string ttl = 3;
uint64 total_size = 4;
uint64 used_size = 5;
uint64 file_count = 6;
}

275
weed/pb/filer_pb/filer.pb.go
View File

@ -31,6 +31,8 @@ It has these top-level messages:
LookupVolumeResponse LookupVolumeResponse
DeleteCollectionRequest DeleteCollectionRequest
DeleteCollectionResponse DeleteCollectionResponse
StatisticsRequest
StatisticsResponse
*/ */
package filer_pb package filer_pb
@ -686,6 +688,94 @@ func (m *DeleteCollectionResponse) String() string { return proto.Com
func (*DeleteCollectionResponse) ProtoMessage() {} func (*DeleteCollectionResponse) ProtoMessage() {}
func (*DeleteCollectionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } func (*DeleteCollectionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
type StatisticsRequest struct {
Replication string `protobuf:"bytes,1,opt,name=replication" json:"replication,omitempty"`
Collection string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
Ttl string `protobuf:"bytes,3,opt,name=ttl" json:"ttl,omitempty"`
}
func (m *StatisticsRequest) Reset() { *m = StatisticsRequest{} }
func (m *StatisticsRequest) String() string { return proto.CompactTextString(m) }
func (*StatisticsRequest) ProtoMessage() {}
func (*StatisticsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
func (m *StatisticsRequest) GetReplication() string {
if m != nil {
return m.Replication
}
return ""
}
func (m *StatisticsRequest) GetCollection() string {
if m != nil {
return m.Collection
}
return ""
}
func (m *StatisticsRequest) GetTtl() string {
if m != nil {
return m.Ttl
}
return ""
}
type StatisticsResponse struct {
Replication string `protobuf:"bytes,1,opt,name=replication" json:"replication,omitempty"`
Collection string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
Ttl string `protobuf:"bytes,3,opt,name=ttl" json:"ttl,omitempty"`
TotalSize uint64 `protobuf:"varint,4,opt,name=total_size,json=totalSize" json:"total_size,omitempty"`
UsedSize uint64 `protobuf:"varint,5,opt,name=used_size,json=usedSize" json:"used_size,omitempty"`
FileCount uint64 `protobuf:"varint,6,opt,name=file_count,json=fileCount" json:"file_count,omitempty"`
}
func (m *StatisticsResponse) Reset() { *m = StatisticsResponse{} }
func (m *StatisticsResponse) String() string { return proto.CompactTextString(m) }
func (*StatisticsResponse) ProtoMessage() {}
func (*StatisticsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
func (m *StatisticsResponse) GetReplication() string {
if m != nil {
return m.Replication
}
return ""
}
func (m *StatisticsResponse) GetCollection() string {
if m != nil {
return m.Collection
}
return ""
}
func (m *StatisticsResponse) GetTtl() string {
if m != nil {
return m.Ttl
}
return ""
}
func (m *StatisticsResponse) GetTotalSize() uint64 {
if m != nil {
return m.TotalSize
}
return 0
}
func (m *StatisticsResponse) GetUsedSize() uint64 {
if m != nil {
return m.UsedSize
}
return 0
}
func (m *StatisticsResponse) GetFileCount() uint64 {
if m != nil {
return m.FileCount
}
return 0
}
func init() { func init() {
proto.RegisterType((*LookupDirectoryEntryRequest)(nil), "filer_pb.LookupDirectoryEntryRequest") proto.RegisterType((*LookupDirectoryEntryRequest)(nil), "filer_pb.LookupDirectoryEntryRequest")
proto.RegisterType((*LookupDirectoryEntryResponse)(nil), "filer_pb.LookupDirectoryEntryResponse") proto.RegisterType((*LookupDirectoryEntryResponse)(nil), "filer_pb.LookupDirectoryEntryResponse")
@ -709,6 +799,8 @@ func init() {
proto.RegisterType((*LookupVolumeResponse)(nil), "filer_pb.LookupVolumeResponse") proto.RegisterType((*LookupVolumeResponse)(nil), "filer_pb.LookupVolumeResponse")
proto.RegisterType((*DeleteCollectionRequest)(nil), "filer_pb.DeleteCollectionRequest") proto.RegisterType((*DeleteCollectionRequest)(nil), "filer_pb.DeleteCollectionRequest")
proto.RegisterType((*DeleteCollectionResponse)(nil), "filer_pb.DeleteCollectionResponse") proto.RegisterType((*DeleteCollectionResponse)(nil), "filer_pb.DeleteCollectionResponse")
proto.RegisterType((*StatisticsRequest)(nil), "filer_pb.StatisticsRequest")
proto.RegisterType((*StatisticsResponse)(nil), "filer_pb.StatisticsResponse")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -730,6 +822,7 @@ type SeaweedFilerClient interface {
AssignVolume(ctx context.Context, in *AssignVolumeRequest, opts ...grpc.CallOption) (*AssignVolumeResponse, error) AssignVolume(ctx context.Context, in *AssignVolumeRequest, opts ...grpc.CallOption) (*AssignVolumeResponse, error)
LookupVolume(ctx context.Context, in *LookupVolumeRequest, opts ...grpc.CallOption) (*LookupVolumeResponse, error) LookupVolume(ctx context.Context, in *LookupVolumeRequest, opts ...grpc.CallOption) (*LookupVolumeResponse, error)
DeleteCollection(ctx context.Context, in *DeleteCollectionRequest, opts ...grpc.CallOption) (*DeleteCollectionResponse, error) DeleteCollection(ctx context.Context, in *DeleteCollectionRequest, opts ...grpc.CallOption) (*DeleteCollectionResponse, error)
Statistics(ctx context.Context, in *StatisticsRequest, opts ...grpc.CallOption) (*StatisticsResponse, error)
} }
type seaweedFilerClient struct { type seaweedFilerClient struct {
@ -812,6 +905,15 @@ func (c *seaweedFilerClient) DeleteCollection(ctx context.Context, in *DeleteCol
return out, nil return out, nil
} }
func (c *seaweedFilerClient) Statistics(ctx context.Context, in *StatisticsRequest, opts ...grpc.CallOption) (*StatisticsResponse, error) {
out := new(StatisticsResponse)
err := grpc.Invoke(ctx, "/filer_pb.SeaweedFiler/Statistics", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for SeaweedFiler service // Server API for SeaweedFiler service
type SeaweedFilerServer interface { type SeaweedFilerServer interface {
@ -823,6 +925,7 @@ type SeaweedFilerServer interface {
AssignVolume(context.Context, *AssignVolumeRequest) (*AssignVolumeResponse, error) AssignVolume(context.Context, *AssignVolumeRequest) (*AssignVolumeResponse, error)
LookupVolume(context.Context, *LookupVolumeRequest) (*LookupVolumeResponse, error) LookupVolume(context.Context, *LookupVolumeRequest) (*LookupVolumeResponse, error)
DeleteCollection(context.Context, *DeleteCollectionRequest) (*DeleteCollectionResponse, error) DeleteCollection(context.Context, *DeleteCollectionRequest) (*DeleteCollectionResponse, error)
Statistics(context.Context, *StatisticsRequest) (*StatisticsResponse, error)
} }
func RegisterSeaweedFilerServer(s *grpc.Server, srv SeaweedFilerServer) { func RegisterSeaweedFilerServer(s *grpc.Server, srv SeaweedFilerServer) {
@ -973,6 +1076,24 @@ func _SeaweedFiler_DeleteCollection_Handler(srv interface{}, ctx context.Context
return interceptor(ctx, in, info, handler) return interceptor(ctx, in, info, handler)
} }
func _SeaweedFiler_Statistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StatisticsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SeaweedFilerServer).Statistics(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/filer_pb.SeaweedFiler/Statistics",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SeaweedFilerServer).Statistics(ctx, req.(*StatisticsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _SeaweedFiler_serviceDesc = grpc.ServiceDesc{ var _SeaweedFiler_serviceDesc = grpc.ServiceDesc{
ServiceName: "filer_pb.SeaweedFiler", ServiceName: "filer_pb.SeaweedFiler",
HandlerType: (*SeaweedFilerServer)(nil), HandlerType: (*SeaweedFilerServer)(nil),
@ -1009,6 +1130,10 @@ var _SeaweedFiler_serviceDesc = grpc.ServiceDesc{
MethodName: "DeleteCollection", MethodName: "DeleteCollection",
Handler: _SeaweedFiler_DeleteCollection_Handler, Handler: _SeaweedFiler_DeleteCollection_Handler,
}, },
{
MethodName: "Statistics",
Handler: _SeaweedFiler_Statistics_Handler,
},
}, },
Streams: []grpc.StreamDesc{}, Streams: []grpc.StreamDesc{},
Metadata: "filer.proto", Metadata: "filer.proto",
@ -1017,76 +1142,82 @@ var _SeaweedFiler_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("filer.proto", fileDescriptor0) } func init() { proto.RegisterFile("filer.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{ var fileDescriptor0 = []byte{
// 1129 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x57, 0x4d, 0x6f, 0xdc, 0xc4,
0x1b, 0x8f, 0xf7, 0x2d, 0xeb, 0x67, 0x77, 0xf3, 0x6f, 0x66, 0xf3, 0xa7, 0xd6, 0x36, 0x29, 0x5b,
0xd3, 0xa2, 0x54, 0x44, 0x51, 0x15, 0x38, 0xb4, 0x54, 0x48, 0x54, 0x79, 0x91, 0x2a, 0xa5, 0xad,
0xe4, 0x34, 0x48, 0x88, 0x83, 0xe5, 0xd8, 0x4f, 0xc2, 0x28, 0x5e, 0x7b, 0xf1, 0x8c, 0x93, 0x96,
0xaf, 0xc0, 0x95, 0x2b, 0x07, 0x4e, 0xdc, 0x38, 0xf0, 0x01, 0xb8, 0xf0, 0xc5, 0xd0, 0xbc, 0xd8,
0x3b, 0x5e, 0x3b, 0x01, 0x84, 0xb8, 0xcd, 0xf3, 0x32, 0xcf, 0xdb, 0xfc, 0xe6, 0x37, 0x36, 0x0c,
0xce, 0x69, 0x8c, 0xd9, 0xee, 0x3c, 0x4b, 0x79, 0x4a, 0xfa, 0x52, 0xf0, 0xe7, 0x67, 0xee, 0x1b,
0xb8, 0x77, 0x9c, 0xa6, 0x97, 0xf9, 0xfc, 0x80, 0x66, 0x18, 0xf2, 0x34, 0x7b, 0x7f, 0x98, 0xf0,
0xec, 0xbd, 0x87, 0xdf, 0xe5, 0xc8, 0x38, 0xd9, 0x04, 0x3b, 0x2a, 0x0c, 0x8e, 0x35, 0xb5, 0xb6,
0x6d, 0x6f, 0xa1, 0x20, 0x04, 0x3a, 0x49, 0x30, 0x43, 0xa7, 0x25, 0x0d, 0x72, 0xed, 0x1e, 0xc2,
0x66, 0x73, 0x40, 0x36, 0x4f, 0x13, 0x86, 0xe4, 0x11, 0x74, 0x51, 0x28, 0x64, 0xb4, 0xc1, 0xde,
0xff, 0x76, 0x8b, 0x52, 0x76, 0x95, 0x9f, 0xb2, 0xba, 0xbf, 0x5b, 0x40, 0x8e, 0x29, 0xe3, 0x42,
0x49, 0x91, 0xfd, 0xbd, 0x7a, 0x3e, 0x80, 0xde, 0x3c, 0xc3, 0x73, 0xfa, 0x4e, 0x57, 0xa4, 0x25,
0xb2, 0x03, 0xeb, 0x8c, 0x07, 0x19, 0x3f, 0xca, 0xd2, 0xd9, 0x11, 0x8d, 0xf1, 0xb5, 0x28, 0xba,
0x2d, 0x5d, 0xea, 0x06, 0xb2, 0x0b, 0x84, 0x26, 0x61, 0x9c, 0x33, 0x7a, 0x85, 0x27, 0x85, 0xd5,
0xe9, 0x4c, 0xad, 0xed, 0xbe, 0xd7, 0x60, 0x21, 0x1b, 0xd0, 0x8d, 0xe9, 0x8c, 0x72, 0xa7, 0x3b,
0xb5, 0xb6, 0x47, 0x9e, 0x12, 0xdc, 0x2f, 0x61, 0x5c, 0xa9, 0x5f, 0xb7, 0xff, 0x18, 0x56, 0x51,
0xa9, 0x1c, 0x6b, 0xda, 0x6e, 0x1a, 0x40, 0x61, 0x77, 0x7f, 0x6a, 0x41, 0x57, 0xaa, 0xca, 0x39,
0x5b, 0x8b, 0x39, 0x93, 0x07, 0x30, 0xa4, 0xcc, 0x5f, 0x0c, 0xa3, 0x25, 0xeb, 0x1b, 0x50, 0x56,
0xce, 0x9d, 0x7c, 0x02, 0xbd, 0xf0, 0xdb, 0x3c, 0xb9, 0x64, 0x4e, 0x5b, 0xa6, 0x1a, 0x2f, 0x52,
0x89, 0x66, 0xf7, 0x85, 0xcd, 0xd3, 0x2e, 0xe4, 0x29, 0x40, 0xc0, 0x79, 0x46, 0xcf, 0x72, 0x8e,
0x4c, 0x76, 0x3b, 0xd8, 0x73, 0x8c, 0x0d, 0x39, 0xc3, 0x17, 0xa5, 0xdd, 0x33, 0x7c, 0xc9, 0x33,
0xe8, 0xe3, 0x3b, 0x8e, 0x49, 0x84, 0x91, 0xd3, 0x95, 0x89, 0xb6, 0x96, 0x7a, 0xda, 0x3d, 0xd4,
0x76, 0xd5, 0x61, 0xe9, 0x3e, 0x79, 0x0e, 0xa3, 0x8a, 0x89, 0xdc, 0x81, 0xf6, 0x25, 0x16, 0x27,
0x2b, 0x96, 0x62, 0xba, 0x57, 0x41, 0x9c, 0x2b, 0x90, 0x0d, 0x3d, 0x25, 0x7c, 0xde, 0x7a, 0x6a,
0xb9, 0x3f, 0x5a, 0xb0, 0x7e, 0x78, 0x85, 0x09, 0x7f, 0x9d, 0x72, 0x7a, 0x4e, 0xc3, 0x80, 0xd3,
0x34, 0x21, 0x3b, 0x60, 0xa7, 0x71, 0xe4, 0xdf, 0x8a, 0xb1, 0x7e, 0x1a, 0xeb, 0x7c, 0x3b, 0x60,
0x27, 0x78, 0xad, 0xbd, 0x5b, 0x37, 0x78, 0x27, 0x78, 0xad, 0xbc, 0x3f, 0x82, 0x51, 0x84, 0x31,
0x72, 0xf4, 0xcb, 0xb9, 0x8a, 0xa1, 0x0f, 0x95, 0x52, 0xce, 0x93, 0xb9, 0x3f, 0x5b, 0x60, 0x97,
0xe3, 0x25, 0x77, 0x61, 0x55, 0x84, 0xf3, 0x69, 0xa4, 0x9b, 0xea, 0x09, 0xf1, 0x65, 0x24, 0xb0,
0x9a, 0x9e, 0x9f, 0x33, 0xe4, 0x32, 0x6d, 0xdb, 0xd3, 0x92, 0x38, 0x6b, 0x46, 0xbf, 0x57, 0xf0,
0xec, 0x78, 0x72, 0x2d, 0x66, 0x30, 0xe3, 0x74, 0x86, 0xf2, 0x58, 0xda, 0x9e, 0x12, 0xc8, 0x18,
0xba, 0xe8, 0xf3, 0xe0, 0x42, 0xe2, 0xce, 0xf6, 0x3a, 0xf8, 0x36, 0xb8, 0x20, 0x0f, 0x61, 0x8d,
0xa5, 0x79, 0x16, 0xa2, 0x5f, 0xa4, 0xed, 0x49, 0xeb, 0x50, 0x69, 0x8f, 0x64, 0x72, 0xf7, 0x87,
0x16, 0xac, 0x55, 0x4f, 0x94, 0xdc, 0x03, 0x5b, 0xee, 0x90, 0xc9, 0x2d, 0x99, 0x5c, 0xb2, 0xc4,
0x49, 0xa5, 0x80, 0x96, 0x59, 0x40, 0xb1, 0x65, 0x96, 0x46, 0xaa, 0xde, 0x91, 0xda, 0xf2, 0x2a,
0x8d, 0x50, 0x9c, 0x64, 0x4e, 0x23, 0x59, 0xf1, 0xc8, 0x13, 0x4b, 0xa1, 0xb9, 0xa0, 0x91, 0xbe,
0x25, 0x62, 0x29, 0x66, 0x10, 0x66, 0x32, 0x6e, 0x4f, 0xcd, 0x40, 0x49, 0x62, 0x06, 0x33, 0xa1,
0x5d, 0x55, 0x8d, 0x89, 0x35, 0x99, 0xc2, 0x20, 0xc3, 0x79, 0xac, 0x8f, 0xd9, 0xe9, 0x4b, 0x93,
0xa9, 0x22, 0xf7, 0x01, 0xc2, 0x34, 0x8e, 0x31, 0x94, 0x0e, 0xb6, 0x74, 0x30, 0x34, 0xe2, 0x28,
0x38, 0x8f, 0x7d, 0x86, 0xa1, 0x03, 0x53, 0x6b, 0xbb, 0xeb, 0xf5, 0x38, 0x8f, 0x4f, 0x30, 0x74,
0xbf, 0x06, 0xb2, 0x9f, 0x61, 0xc0, 0xf1, 0x1f, 0x50, 0x5f, 0x49, 0x63, 0xad, 0x5b, 0x69, 0xec,
0xff, 0x30, 0xae, 0x84, 0x56, 0x2c, 0x20, 0x32, 0x9e, 0xce, 0xa3, 0xff, 0x2a, 0x63, 0x25, 0xb4,
0xce, 0xf8, 0x9b, 0x05, 0xe4, 0x40, 0xc2, 0xf4, 0xdf, 0xf1, 0x7b, 0x8d, 0x77, 0xda, 0x75, 0xde,
0x79, 0x08, 0x6b, 0xc2, 0x45, 0xdd, 0x94, 0x28, 0xe0, 0x81, 0x26, 0xcf, 0x21, 0x65, 0xaa, 0x84,
0x83, 0x80, 0x07, 0x3a, 0x50, 0x86, 0x61, 0x9e, 0x09, 0x3e, 0x95, 0xb8, 0x90, 0x81, 0xbc, 0x42,
0x25, 0x7a, 0xa9, 0xd4, 0xac, 0x7b, 0xf9, 0xc5, 0x82, 0xf1, 0x0b, 0xc6, 0xe8, 0x45, 0xf2, 0x55,
0x1a, 0xe7, 0x33, 0x2c, 0x9a, 0xd9, 0x80, 0x6e, 0x98, 0xe6, 0x09, 0x97, 0x8d, 0x74, 0x3d, 0x25,
0x2c, 0xc1, 0xa2, 0x55, 0x83, 0xc5, 0x12, 0xb0, 0xda, 0x75, 0x60, 0x19, 0xc0, 0xe9, 0x98, 0xc0,
0x21, 0x1f, 0xc2, 0x40, 0xb4, 0xe7, 0x87, 0x98, 0x70, 0xcc, 0xf4, 0x3d, 0x04, 0xa1, 0xda, 0x97,
0x1a, 0xf7, 0x0a, 0x36, 0xaa, 0x85, 0xea, 0x57, 0xe0, 0x46, 0x56, 0x10, 0xb7, 0x26, 0x8b, 0x75,
0x95, 0x62, 0x49, 0xb6, 0x00, 0xe6, 0xf9, 0x59, 0x4c, 0x43, 0x5f, 0x18, 0x54, 0x75, 0xb6, 0xd2,
0x9c, 0x66, 0xf1, 0xa2, 0xe7, 0x8e, 0xd1, 0xb3, 0xfb, 0x19, 0x8c, 0xd5, 0x23, 0x5c, 0x1d, 0xd0,
0x16, 0xc0, 0x95, 0x54, 0xf8, 0x34, 0x52, 0xef, 0x8f, 0xed, 0xd9, 0x4a, 0xf3, 0x32, 0x62, 0xee,
0x17, 0x60, 0x1f, 0xa7, 0xaa, 0x67, 0x46, 0x9e, 0x80, 0x1d, 0x17, 0x82, 0x7e, 0xaa, 0xc8, 0x02,
0x72, 0x85, 0x9f, 0xb7, 0x70, 0x72, 0x9f, 0x43, 0xbf, 0x50, 0x17, 0x7d, 0x58, 0x37, 0xf5, 0xd1,
0x5a, 0xea, 0xc3, 0xfd, 0xc3, 0x82, 0x8d, 0x6a, 0xc9, 0x7a, 0x54, 0xa7, 0x30, 0x2a, 0x53, 0xf8,
0xb3, 0x60, 0xae, 0x6b, 0x79, 0x62, 0xd6, 0x52, 0xdf, 0x56, 0x16, 0xc8, 0x5e, 0x05, 0x73, 0x85,
0x9e, 0x61, 0x6c, 0xa8, 0x26, 0x6f, 0x61, 0xbd, 0xe6, 0xd2, 0xf0, 0xfa, 0x3c, 0x36, 0x5f, 0x9f,
0xca, 0x0b, 0x5a, 0xee, 0x36, 0x9f, 0xa4, 0x67, 0x70, 0x57, 0x01, 0x76, 0xbf, 0xc4, 0x57, 0x31,
0xfb, 0x2a, 0x0c, 0xad, 0x65, 0x18, 0xba, 0x13, 0x70, 0xea, 0x5b, 0x55, 0x33, 0x7b, 0xbf, 0x76,
0x61, 0x78, 0x82, 0xc1, 0x35, 0x62, 0x24, 0x08, 0x3c, 0x23, 0x17, 0xc5, 0xb0, 0xaa, 0x1f, 0x59,
0xe4, 0xd1, 0xf2, 0x54, 0x1a, 0xbf, 0xea, 0x26, 0x1f, 0xff, 0x95, 0x9b, 0xbe, 0x68, 0x2b, 0xe4,
0x18, 0x06, 0xc6, 0x57, 0x0c, 0xd9, 0x34, 0x36, 0xd6, 0x3e, 0xce, 0x26, 0x5b, 0x37, 0x58, 0xcd,
0x68, 0x06, 0x1b, 0x9a, 0xd1, 0xea, 0xfc, 0x6b, 0x46, 0x6b, 0xa2, 0x50, 0x19, 0xcd, 0x60, 0x3a,
0x33, 0x5a, 0x9d, 0x5b, 0xcd, 0x68, 0x4d, 0xf4, 0x28, 0xa3, 0x19, 0x5c, 0x63, 0x46, 0xab, 0xd3,
0xa6, 0x19, 0xad, 0x89, 0xa0, 0x56, 0xc8, 0x1b, 0x18, 0x9a, 0x17, 0x9f, 0x18, 0x1b, 0x1a, 0x98,
0x6b, 0x72, 0xff, 0x26, 0xb3, 0x19, 0xd0, 0xc4, 0xb9, 0x19, 0xb0, 0xe1, 0xa6, 0x9b, 0x01, 0x9b,
0xae, 0x87, 0xbb, 0x42, 0xbe, 0x81, 0x3b, 0xcb, 0x78, 0x23, 0x0f, 0x96, 0xdb, 0xaa, 0xc1, 0x78,
0xe2, 0xde, 0xe6, 0x52, 0x04, 0x3f, 0xeb, 0xc9, 0xdf, 0x8c, 0x4f, 0xff, 0x0c, 0x00, 0x00, 0xff,
0xff, 0x04, 0x12, 0x06, 0xcd, 0x75, 0x0c, 0x00, 0x00,
// 1225 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x57, 0x4b, 0x6f, 0xdb, 0xc6,
0x13, 0x0f, 0xf5, 0x8a, 0x38, 0x92, 0xfc, 0xb7, 0x57, 0xfe, 0x37, 0x82, 0x6c, 0xa7, 0x0a, 0x9b,
0x14, 0x0e, 0x6a, 0x18, 0x81, 0xdb, 0x43, 0xd2, 0xa0, 0x40, 0x03, 0x3f, 0x00, 0x03, 0x4e, 0x02,
0xd0, 0x71, 0x81, 0xa2, 0x07, 0x82, 0x26, 0xc7, 0xea, 0xc2, 0x14, 0xa9, 0x72, 0x97, 0x76, 0xd2,
0xaf, 0xd0, 0x6b, 0xaf, 0x3d, 0xf4, 0xd4, 0x7b, 0x3f, 0x40, 0x2f, 0xfd, 0x54, 0xbd, 0x15, 0xfb,
0x20, 0xb5, 0x14, 0x69, 0xa7, 0x45, 0x91, 0xdb, 0xee, 0x6f, 0x66, 0xe7, 0xb5, 0xbf, 0x9d, 0x21,
0xa1, 0x77, 0x41, 0x23, 0x4c, 0x77, 0xe7, 0x69, 0xc2, 0x13, 0xd2, 0x95, 0x1b, 0x6f, 0x7e, 0xee,
0xbc, 0x86, 0x8d, 0x93, 0x24, 0xb9, 0xcc, 0xe6, 0x07, 0x34, 0xc5, 0x80, 0x27, 0xe9, 0xbb, 0xc3,
0x98, 0xa7, 0xef, 0x5c, 0xfc, 0x21, 0x43, 0xc6, 0xc9, 0x26, 0xd8, 0x61, 0x2e, 0x18, 0x59, 0x13,
0x6b, 0xdb, 0x76, 0x17, 0x00, 0x21, 0xd0, 0x8a, 0xfd, 0x19, 0x8e, 0x1a, 0x52, 0x20, 0xd7, 0xce,
0x21, 0x6c, 0xd6, 0x1b, 0x64, 0xf3, 0x24, 0x66, 0x48, 0x1e, 0x41, 0x1b, 0x05, 0x20, 0xad, 0xf5,
0xf6, 0xfe, 0xb7, 0x9b, 0x87, 0xb2, 0xab, 0xf4, 0x94, 0xd4, 0xf9, 0xc3, 0x02, 0x72, 0x42, 0x19,
0x17, 0x20, 0x45, 0xf6, 0xcf, 0xe2, 0xf9, 0x08, 0x3a, 0xf3, 0x14, 0x2f, 0xe8, 0x5b, 0x1d, 0x91,
0xde, 0x91, 0x1d, 0x58, 0x63, 0xdc, 0x4f, 0xf9, 0x51, 0x9a, 0xcc, 0x8e, 0x68, 0x84, 0xaf, 0x44,
0xd0, 0x4d, 0xa9, 0x52, 0x15, 0x90, 0x5d, 0x20, 0x34, 0x0e, 0xa2, 0x8c, 0xd1, 0x2b, 0x3c, 0xcd,
0xa5, 0xa3, 0xd6, 0xc4, 0xda, 0xee, 0xba, 0x35, 0x12, 0xb2, 0x0e, 0xed, 0x88, 0xce, 0x28, 0x1f,
0xb5, 0x27, 0xd6, 0xf6, 0xc0, 0x55, 0x1b, 0xe7, 0x6b, 0x18, 0x96, 0xe2, 0xd7, 0xe9, 0x3f, 0x86,
0xbb, 0xa8, 0xa0, 0x91, 0x35, 0x69, 0xd6, 0x15, 0x20, 0x97, 0x3b, 0xbf, 0x34, 0xa0, 0x2d, 0xa1,
0xa2, 0xce, 0xd6, 0xa2, 0xce, 0xe4, 0x01, 0xf4, 0x29, 0xf3, 0x16, 0xc5, 0x68, 0xc8, 0xf8, 0x7a,
0x94, 0x15, 0x75, 0x27, 0x9f, 0x41, 0x27, 0xf8, 0x3e, 0x8b, 0x2f, 0xd9, 0xa8, 0x29, 0x5d, 0x0d,
0x17, 0xae, 0x44, 0xb2, 0xfb, 0x42, 0xe6, 0x6a, 0x15, 0xf2, 0x14, 0xc0, 0xe7, 0x3c, 0xa5, 0xe7,
0x19, 0x47, 0x26, 0xb3, 0xed, 0xed, 0x8d, 0x8c, 0x03, 0x19, 0xc3, 0x17, 0x85, 0xdc, 0x35, 0x74,
0xc9, 0x33, 0xe8, 0xe2, 0x5b, 0x8e, 0x71, 0x88, 0xe1, 0xa8, 0x2d, 0x1d, 0x6d, 0x2d, 0xe5, 0xb4,
0x7b, 0xa8, 0xe5, 0x2a, 0xc3, 0x42, 0x7d, 0xfc, 0x1c, 0x06, 0x25, 0x11, 0x59, 0x85, 0xe6, 0x25,
0xe6, 0x37, 0x2b, 0x96, 0xa2, 0xba, 0x57, 0x7e, 0x94, 0x29, 0x92, 0xf5, 0x5d, 0xb5, 0xf9, 0xb2,
0xf1, 0xd4, 0x72, 0x7e, 0xb6, 0x60, 0xed, 0xf0, 0x0a, 0x63, 0xfe, 0x2a, 0xe1, 0xf4, 0x82, 0x06,
0x3e, 0xa7, 0x49, 0x4c, 0x76, 0xc0, 0x4e, 0xa2, 0xd0, 0xbb, 0x95, 0x63, 0xdd, 0x24, 0xd2, 0xfe,
0x76, 0xc0, 0x8e, 0xf1, 0x5a, 0x6b, 0x37, 0x6e, 0xd0, 0x8e, 0xf1, 0x5a, 0x69, 0x7f, 0x02, 0x83,
0x10, 0x23, 0xe4, 0xe8, 0x15, 0x75, 0x15, 0x45, 0xef, 0x2b, 0x50, 0xd6, 0x93, 0x39, 0xbf, 0x5a,
0x60, 0x17, 0xe5, 0x25, 0xf7, 0xe0, 0xae, 0x30, 0xe7, 0xd1, 0x50, 0x27, 0xd5, 0x11, 0xdb, 0xe3,
0x50, 0x70, 0x35, 0xb9, 0xb8, 0x60, 0xc8, 0xa5, 0xdb, 0xa6, 0xab, 0x77, 0xe2, 0xae, 0x19, 0xfd,
0x51, 0xd1, 0xb3, 0xe5, 0xca, 0xb5, 0xa8, 0xc1, 0x8c, 0xd3, 0x19, 0xca, 0x6b, 0x69, 0xba, 0x6a,
0x43, 0x86, 0xd0, 0x46, 0x8f, 0xfb, 0x53, 0xc9, 0x3b, 0xdb, 0x6d, 0xe1, 0x1b, 0x7f, 0x4a, 0x1e,
0xc2, 0x0a, 0x4b, 0xb2, 0x34, 0x40, 0x2f, 0x77, 0xdb, 0x91, 0xd2, 0xbe, 0x42, 0x8f, 0xa4, 0x73,
0xe7, 0xa7, 0x06, 0xac, 0x94, 0x6f, 0x94, 0x6c, 0x80, 0x2d, 0x4f, 0x48, 0xe7, 0x96, 0x74, 0x2e,
0xbb, 0xc4, 0x69, 0x29, 0x80, 0x86, 0x19, 0x40, 0x7e, 0x64, 0x96, 0x84, 0x2a, 0xde, 0x81, 0x3a,
0xf2, 0x32, 0x09, 0x51, 0xdc, 0x64, 0x46, 0x43, 0x19, 0xf1, 0xc0, 0x15, 0x4b, 0x81, 0x4c, 0x69,
0xa8, 0x5f, 0x89, 0x58, 0x8a, 0x1a, 0x04, 0xa9, 0xb4, 0xdb, 0x51, 0x35, 0x50, 0x3b, 0x51, 0x83,
0x99, 0x40, 0xef, 0xaa, 0xc4, 0xc4, 0x9a, 0x4c, 0xa0, 0x97, 0xe2, 0x3c, 0xd2, 0xd7, 0x3c, 0xea,
0x4a, 0x91, 0x09, 0x91, 0xfb, 0x00, 0x41, 0x12, 0x45, 0x18, 0x48, 0x05, 0x5b, 0x2a, 0x18, 0x88,
0xb8, 0x0a, 0xce, 0x23, 0x8f, 0x61, 0x30, 0x82, 0x89, 0xb5, 0xdd, 0x76, 0x3b, 0x9c, 0x47, 0xa7,
0x18, 0x38, 0xdf, 0x02, 0xd9, 0x4f, 0xd1, 0xe7, 0xf8, 0x2f, 0x5a, 0x5f, 0xd1, 0xc6, 0x1a, 0xb7,
0xb6, 0xb1, 0xff, 0xc3, 0xb0, 0x64, 0x5a, 0x75, 0x01, 0xe1, 0xf1, 0x6c, 0x1e, 0x7e, 0x28, 0x8f,
0x25, 0xd3, 0xda, 0xe3, 0xef, 0x16, 0x90, 0x03, 0x49, 0xd3, 0xff, 0xd6, 0xdf, 0x2b, 0x7d, 0xa7,
0x59, 0xed, 0x3b, 0x0f, 0x61, 0x45, 0xa8, 0xa8, 0x97, 0x12, 0xfa, 0xdc, 0xd7, 0xcd, 0xb3, 0x4f,
0x99, 0x0a, 0xe1, 0xc0, 0xe7, 0xbe, 0x36, 0x94, 0x62, 0x90, 0xa5, 0xa2, 0x9f, 0x4a, 0x5e, 0x48,
0x43, 0x6e, 0x0e, 0x89, 0x5c, 0x4a, 0x31, 0xeb, 0x5c, 0x7e, 0xb3, 0x60, 0xf8, 0x82, 0x31, 0x3a,
0x8d, 0xbf, 0x49, 0xa2, 0x6c, 0x86, 0x79, 0x32, 0xeb, 0xd0, 0x0e, 0x92, 0x2c, 0xe6, 0x32, 0x91,
0xb6, 0xab, 0x36, 0x4b, 0xb4, 0x68, 0x54, 0x68, 0xb1, 0x44, 0xac, 0x66, 0x95, 0x58, 0x06, 0x71,
0x5a, 0x26, 0x71, 0xc8, 0xc7, 0xd0, 0x13, 0xe9, 0x79, 0x01, 0xc6, 0x1c, 0x53, 0xfd, 0x0e, 0x41,
0x40, 0xfb, 0x12, 0x71, 0xae, 0x60, 0xbd, 0x1c, 0xa8, 0x9e, 0x02, 0x37, 0x76, 0x05, 0xf1, 0x6a,
0xd2, 0x48, 0x47, 0x29, 0x96, 0x64, 0x0b, 0x60, 0x9e, 0x9d, 0x47, 0x34, 0xf0, 0x84, 0x40, 0x45,
0x67, 0x2b, 0xe4, 0x2c, 0x8d, 0x16, 0x39, 0xb7, 0x8c, 0x9c, 0x9d, 0x2f, 0x60, 0xa8, 0x86, 0x70,
0xb9, 0x40, 0x5b, 0x00, 0x57, 0x12, 0xf0, 0x68, 0xa8, 0xe6, 0x8f, 0xed, 0xda, 0x0a, 0x39, 0x0e,
0x99, 0xf3, 0x15, 0xd8, 0x27, 0x89, 0xca, 0x99, 0x91, 0x27, 0x60, 0x47, 0xf9, 0x46, 0x8f, 0x2a,
0xb2, 0xa0, 0x5c, 0xae, 0xe7, 0x2e, 0x94, 0x9c, 0xe7, 0xd0, 0xcd, 0xe1, 0x3c, 0x0f, 0xeb, 0xa6,
0x3c, 0x1a, 0x4b, 0x79, 0x38, 0x7f, 0x5a, 0xb0, 0x5e, 0x0e, 0x59, 0x97, 0xea, 0x0c, 0x06, 0x85,
0x0b, 0x6f, 0xe6, 0xcf, 0x75, 0x2c, 0x4f, 0xcc, 0x58, 0xaa, 0xc7, 0x8a, 0x00, 0xd9, 0x4b, 0x7f,
0xae, 0xd8, 0xd3, 0x8f, 0x0c, 0x68, 0xfc, 0x06, 0xd6, 0x2a, 0x2a, 0x35, 0xd3, 0xe7, 0xb1, 0x39,
0x7d, 0x4a, 0x13, 0xb4, 0x38, 0x6d, 0x8e, 0xa4, 0x67, 0x70, 0x4f, 0x11, 0x76, 0xbf, 0xe0, 0x57,
0x5e, 0xfb, 0x32, 0x0d, 0xad, 0x65, 0x1a, 0x3a, 0x63, 0x18, 0x55, 0x8f, 0x6a, 0xc2, 0x4f, 0x61,
0xed, 0x94, 0xfb, 0x9c, 0x32, 0x4e, 0x83, 0xe2, 0x53, 0x68, 0x89, 0xb7, 0xd6, 0xfb, 0x1a, 0x62,
0x95, 0xf9, 0xab, 0xd0, 0xe4, 0x3c, 0xe7, 0x94, 0x58, 0x8a, 0x5b, 0x20, 0xa6, 0x27, 0x7d, 0x07,
0x1f, 0xc0, 0x95, 0xe0, 0x03, 0x4f, 0xb8, 0x1f, 0xa9, 0x81, 0xd3, 0x92, 0x03, 0xc7, 0x96, 0x88,
0x9c, 0x38, 0x1b, 0x60, 0x67, 0x0c, 0x43, 0x25, 0x6d, 0xab, 0x71, 0x24, 0x00, 0x29, 0xdc, 0x02,
0x90, 0xcf, 0x47, 0x31, 0xbf, 0xa3, 0xce, 0x0a, 0x64, 0x5f, 0x00, 0x7b, 0x7f, 0xb5, 0xa1, 0x7f,
0x8a, 0xfe, 0x35, 0x62, 0x28, 0xe6, 0x5d, 0x4a, 0xa6, 0x39, 0xb7, 0xca, 0xdf, 0xa4, 0xe4, 0xd1,
0x32, 0x89, 0x6a, 0x3f, 0x82, 0xc7, 0x9f, 0xbe, 0x4f, 0x4d, 0x5f, 0xd3, 0x1d, 0x72, 0x02, 0x3d,
0xe3, 0xa3, 0x8f, 0x6c, 0x1a, 0x07, 0x2b, 0xdf, 0xb2, 0xe3, 0xad, 0x1b, 0xa4, 0xa6, 0x35, 0x63,
0x78, 0x98, 0xd6, 0xaa, 0xe3, 0xca, 0xb4, 0x56, 0x37, 0x71, 0xa4, 0x35, 0x63, 0x30, 0x98, 0xd6,
0xaa, 0xa3, 0xc8, 0xb4, 0x56, 0x37, 0x4d, 0xa4, 0x35, 0xa3, 0x35, 0x9b, 0xd6, 0xaa, 0x53, 0xc6,
0xb4, 0x56, 0xd7, 0xcf, 0xef, 0x90, 0xd7, 0xd0, 0x37, 0xfb, 0x24, 0x31, 0x0e, 0xd4, 0x34, 0xfa,
0xf1, 0xfd, 0x9b, 0xc4, 0xa6, 0x41, 0xb3, 0x2d, 0x98, 0x06, 0x6b, 0x1a, 0xa3, 0x69, 0xb0, 0xae,
0x9b, 0x38, 0x77, 0xc8, 0x77, 0xb0, 0xba, 0xfc, 0x3c, 0xc9, 0x83, 0xe5, 0xb4, 0x2a, 0xaf, 0x7e,
0xec, 0xdc, 0xa6, 0x52, 0x18, 0x3f, 0x06, 0x58, 0xbc, 0x3a, 0xb2, 0xb1, 0x38, 0x53, 0x79, 0xf5,
0xe3, 0xcd, 0x7a, 0x61, 0x6e, 0xea, 0xbc, 0x23, 0x7f, 0xf0, 0x3e, 0xff, 0x3b, 0x00, 0x00, 0xff,
0xff, 0xd6, 0x35, 0x68, 0xc8, 0xef, 0x0d, 0x00, 0x00,
} }

16
weed/pb/master.proto
View File

@ -13,6 +13,8 @@ service Seaweed {
} }
rpc Assign (AssignRequest) returns (AssignResponse) { rpc Assign (AssignRequest) returns (AssignResponse) {
} }
rpc Statistics (StatisticsRequest) returns (StatisticsResponse) {
}
} }
////////////////////////////////////////////////// //////////////////////////////////////////////////
@ -108,3 +110,17 @@ message AssignResponse {
uint64 count = 4; uint64 count = 4;
string error = 5; string error = 5;
} }
message StatisticsRequest {
string replication = 1;
string collection = 2;
string ttl = 3;
}
message StatisticsResponse {
string replication = 1;
string collection = 2;
string ttl = 3;
uint64 total_size = 4;
uint64 used_size = 5;
uint64 file_count = 6;
}

254
weed/pb/master_pb/master.pb.go
View File

@ -21,6 +21,8 @@ It has these top-level messages:
Location Location
AssignRequest AssignRequest
AssignResponse AssignResponse
StatisticsRequest
StatisticsResponse
*/ */
package master_pb package master_pb
@ -585,6 +587,94 @@ func (m *AssignResponse) GetError() string {
return "" return ""
} }
type StatisticsRequest struct {
Replication string `protobuf:"bytes,1,opt,name=replication" json:"replication,omitempty"`
Collection string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
Ttl string `protobuf:"bytes,3,opt,name=ttl" json:"ttl,omitempty"`
}
func (m *StatisticsRequest) Reset() { *m = StatisticsRequest{} }
func (m *StatisticsRequest) String() string { return proto.CompactTextString(m) }
func (*StatisticsRequest) ProtoMessage() {}
func (*StatisticsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
func (m *StatisticsRequest) GetReplication() string {
if m != nil {
return m.Replication
}
return ""
}
func (m *StatisticsRequest) GetCollection() string {
if m != nil {
return m.Collection
}
return ""
}
func (m *StatisticsRequest) GetTtl() string {
if m != nil {
return m.Ttl
}
return ""
}
type StatisticsResponse struct {
Replication string `protobuf:"bytes,1,opt,name=replication" json:"replication,omitempty"`
Collection string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
Ttl string `protobuf:"bytes,3,opt,name=ttl" json:"ttl,omitempty"`
TotalSize uint64 `protobuf:"varint,4,opt,name=total_size,json=totalSize" json:"total_size,omitempty"`
UsedSize uint64 `protobuf:"varint,5,opt,name=used_size,json=usedSize" json:"used_size,omitempty"`
FileCount uint64 `protobuf:"varint,6,opt,name=file_count,json=fileCount" json:"file_count,omitempty"`
}
func (m *StatisticsResponse) Reset() { *m = StatisticsResponse{} }
func (m *StatisticsResponse) String() string { return proto.CompactTextString(m) }
func (*StatisticsResponse) ProtoMessage() {}
func (*StatisticsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
func (m *StatisticsResponse) GetReplication() string {
if m != nil {
return m.Replication
}
return ""
}
func (m *StatisticsResponse) GetCollection() string {
if m != nil {
return m.Collection
}
return ""
}
func (m *StatisticsResponse) GetTtl() string {
if m != nil {
return m.Ttl
}
return ""
}
func (m *StatisticsResponse) GetTotalSize() uint64 {
if m != nil {
return m.TotalSize
}
return 0
}
func (m *StatisticsResponse) GetUsedSize() uint64 {
if m != nil {
return m.UsedSize
}
return 0
}
func (m *StatisticsResponse) GetFileCount() uint64 {
if m != nil {
return m.FileCount
}
return 0
}
func init() { func init() {
proto.RegisterType((*Heartbeat)(nil), "master_pb.Heartbeat") proto.RegisterType((*Heartbeat)(nil), "master_pb.Heartbeat")
proto.RegisterType((*HeartbeatResponse)(nil), "master_pb.HeartbeatResponse") proto.RegisterType((*HeartbeatResponse)(nil), "master_pb.HeartbeatResponse")
@ -600,6 +690,8 @@ func init() {
proto.RegisterType((*Location)(nil), "master_pb.Location") proto.RegisterType((*Location)(nil), "master_pb.Location")
proto.RegisterType((*AssignRequest)(nil), "master_pb.AssignRequest") proto.RegisterType((*AssignRequest)(nil), "master_pb.AssignRequest")
proto.RegisterType((*AssignResponse)(nil), "master_pb.AssignResponse") proto.RegisterType((*AssignResponse)(nil), "master_pb.AssignResponse")
proto.RegisterType((*StatisticsRequest)(nil), "master_pb.StatisticsRequest")
proto.RegisterType((*StatisticsResponse)(nil), "master_pb.StatisticsResponse")
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.
@ -617,6 +709,7 @@ type SeaweedClient interface {
KeepConnected(ctx context.Context, opts ...grpc.CallOption) (Seaweed_KeepConnectedClient, error) KeepConnected(ctx context.Context, opts ...grpc.CallOption) (Seaweed_KeepConnectedClient, error)
LookupVolume(ctx context.Context, in *LookupVolumeRequest, opts ...grpc.CallOption) (*LookupVolumeResponse, error) LookupVolume(ctx context.Context, in *LookupVolumeRequest, opts ...grpc.CallOption) (*LookupVolumeResponse, error)
Assign(ctx context.Context, in *AssignRequest, opts ...grpc.CallOption) (*AssignResponse, error) Assign(ctx context.Context, in *AssignRequest, opts ...grpc.CallOption) (*AssignResponse, error)
Statistics(ctx context.Context, in *StatisticsRequest, opts ...grpc.CallOption) (*StatisticsResponse, error)
} }
type seaweedClient struct { type seaweedClient struct {
@ -707,6 +800,15 @@ func (c *seaweedClient) Assign(ctx context.Context, in *AssignRequest, opts ...g
return out, nil return out, nil
} }
func (c *seaweedClient) Statistics(ctx context.Context, in *StatisticsRequest, opts ...grpc.CallOption) (*StatisticsResponse, error) {
out := new(StatisticsResponse)
err := grpc.Invoke(ctx, "/master_pb.Seaweed/Statistics", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Seaweed service // Server API for Seaweed service
type SeaweedServer interface { type SeaweedServer interface {
@ -714,6 +816,7 @@ type SeaweedServer interface {
KeepConnected(Seaweed_KeepConnectedServer) error KeepConnected(Seaweed_KeepConnectedServer) error
LookupVolume(context.Context, *LookupVolumeRequest) (*LookupVolumeResponse, error) LookupVolume(context.Context, *LookupVolumeRequest) (*LookupVolumeResponse, error)
Assign(context.Context, *AssignRequest) (*AssignResponse, error) Assign(context.Context, *AssignRequest) (*AssignResponse, error)
Statistics(context.Context, *StatisticsRequest) (*StatisticsResponse, error)
} }
func RegisterSeaweedServer(s *grpc.Server, srv SeaweedServer) { func RegisterSeaweedServer(s *grpc.Server, srv SeaweedServer) {
@ -808,6 +911,24 @@ func _Seaweed_Assign_Handler(srv interface{}, ctx context.Context, dec func(inte
return interceptor(ctx, in, info, handler) return interceptor(ctx, in, info, handler)
} }
func _Seaweed_Statistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StatisticsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SeaweedServer).Statistics(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/master_pb.Seaweed/Statistics",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SeaweedServer).Statistics(ctx, req.(*StatisticsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Seaweed_serviceDesc = grpc.ServiceDesc{ var _Seaweed_serviceDesc = grpc.ServiceDesc{
ServiceName: "master_pb.Seaweed", ServiceName: "master_pb.Seaweed",
HandlerType: (*SeaweedServer)(nil), HandlerType: (*SeaweedServer)(nil),
@ -820,6 +941,10 @@ var _Seaweed_serviceDesc = grpc.ServiceDesc{
MethodName: "Assign", MethodName: "Assign",
Handler: _Seaweed_Assign_Handler, Handler: _Seaweed_Assign_Handler,
}, },
{
MethodName: "Statistics",
Handler: _Seaweed_Statistics_Handler,
},
}, },
Streams: []grpc.StreamDesc{ Streams: []grpc.StreamDesc{
{ {
@ -841,66 +966,71 @@ var _Seaweed_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("master.proto", fileDescriptor0) } func init() { proto.RegisterFile("master.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{ var fileDescriptor0 = []byte{
// 971 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x56, 0xcd, 0x6e, 0x23, 0x45,
0x17, 0x4d, 0xb7, 0x7f, 0xfb, 0x3a, 0xce, 0x38, 0x95, 0xe8, 0x53, 0x8f, 0x67, 0xbe, 0x19, 0xd3,
0x6c, 0x8c, 0x40, 0xd1, 0x10, 0x96, 0x08, 0x21, 0xc6, 0x0a, 0x22, 0x4a, 0x60, 0x42, 0x07, 0x66,
0xc1, 0xa6, 0x29, 0x77, 0xdf, 0x44, 0xa5, 0xf4, 0x1f, 0x55, 0xe5, 0xc4, 0x9e, 0x0d, 0xef, 0xc5,
0x82, 0x15, 0x3b, 0x1e, 0x85, 0x1d, 0x4f, 0x80, 0xea, 0xa7, 0xdb, 0x6d, 0x27, 0x61, 0x24, 0x76,
0x55, 0xa7, 0xef, 0xad, 0x3a, 0x75, 0xce, 0xbd, 0x55, 0x0d, 0xbb, 0x19, 0x15, 0x12, 0xf9, 0x51,
0xc9, 0x0b, 0x59, 0x10, 0xcf, 0xcc, 0xa2, 0x72, 0x1e, 0xfc, 0xe5, 0x82, 0xf7, 0x0d, 0x52, 0x2e,
0xe7, 0x48, 0x25, 0xd9, 0x03, 0x97, 0x95, 0xbe, 0x33, 0x71, 0xa6, 0x5e, 0xe8, 0xb2, 0x92, 0x10,
0x68, 0x97, 0x05, 0x97, 0xbe, 0x3b, 0x71, 0xa6, 0xc3, 0x50, 0x8f, 0xc9, 0xff, 0x01, 0xca, 0xc5,
0x3c, 0x65, 0x71, 0xb4, 0xe0, 0xa9, 0xdf, 0xd2, 0xb1, 0x9e, 0x41, 0x7e, 0xe4, 0x29, 0x99, 0xc2,
0x28, 0xa3, 0xcb, 0xe8, 0xb6, 0x48, 0x17, 0x19, 0x46, 0x71, 0xb1, 0xc8, 0xa5, 0xdf, 0xd6, 0xe9,
0x7b, 0x19, 0x5d, 0xbe, 0xd5, 0xf0, 0x4c, 0xa1, 0x64, 0xa2, 0x58, 0x2d, 0xa3, 0x2b, 0x96, 0x62,
0x74, 0x83, 0x2b, 0xbf, 0x33, 0x71, 0xa6, 0xed, 0x10, 0x32, 0xba, 0xfc, 0x9a, 0xa5, 0x78, 0x86,
0x2b, 0xf2, 0x12, 0x06, 0x09, 0x95, 0x34, 0x8a, 0x31, 0x97, 0xc8, 0xfd, 0xae, 0xde, 0x0b, 0x14,
0x34, 0xd3, 0x88, 0xe2, 0xc7, 0x69, 0x7c, 0xe3, 0xf7, 0xf4, 0x17, 0x3d, 0x56, 0xfc, 0x68, 0x92,
0xb1, 0x3c, 0xd2, 0xcc, 0xfb, 0x7a, 0x6b, 0x4f, 0x23, 0x17, 0x8a, 0xfe, 0x17, 0xd0, 0x33, 0xdc,
0x84, 0xef, 0x4d, 0x5a, 0xd3, 0xc1, 0xf1, 0x87, 0x47, 0xb5, 0x1a, 0x47, 0x86, 0xde, 0x69, 0x7e,
0x55, 0xf0, 0x8c, 0x4a, 0x56, 0xe4, 0xdf, 0xa2, 0x10, 0xf4, 0x1a, 0xc3, 0x2a, 0x87, 0x3c, 0x85,
0x7e, 0x8e, 0x77, 0xd1, 0x2d, 0x4b, 0x84, 0x0f, 0x93, 0xd6, 0x74, 0x18, 0xf6, 0x72, 0xbc, 0x7b,
0xcb, 0x12, 0x41, 0x3e, 0x80, 0xdd, 0x04, 0x53, 0x94, 0x98, 0x98, 0xcf, 0x03, 0xfd, 0x79, 0x60,
0x31, 0x15, 0x12, 0x08, 0xd8, 0xaf, 0xc5, 0x0e, 0x51, 0x94, 0x45, 0x2e, 0x90, 0x4c, 0xe1, 0x89,
0x59, 0xfd, 0x92, 0xbd, 0xc3, 0x73, 0x96, 0x31, 0xa9, 0x1d, 0x68, 0x87, 0xdb, 0x30, 0x79, 0x0e,
0x9e, 0xc0, 0x98, 0xa3, 0x3c, 0xc3, 0x95, 0xf6, 0xc4, 0x0b, 0xd7, 0x00, 0xf9, 0x1f, 0x74, 0x53,
0xa4, 0x09, 0x72, 0x6b, 0x8a, 0x9d, 0x05, 0x7f, 0xb8, 0xe0, 0x3f, 0x76, 0x30, 0xed, 0x78, 0xa2,
0xf7, 0x1b, 0x86, 0x2e, 0x4b, 0x94, 0xa2, 0x82, 0xbd, 0x43, 0xbd, 0x7a, 0x3b, 0xd4, 0x63, 0xf2,
0x02, 0x20, 0x2e, 0xd2, 0x14, 0x63, 0x95, 0x68, 0x17, 0x6f, 0x20, 0x4a, 0x71, 0x6d, 0xe2, 0xda,
0xec, 0x76, 0xe8, 0x29, 0xc4, 0xf8, 0x5c, 0xeb, 0x62, 0x03, 0x8c, 0xcf, 0x56, 0x17, 0x13, 0xf2,
0x09, 0x90, 0x4a, 0xba, 0xf9, 0xaa, 0x0e, 0xec, 0xea, 0xc0, 0x91, 0xfd, 0xf2, 0x7a, 0x55, 0x45,
0x3f, 0x03, 0x8f, 0x23, 0x4d, 0xa2, 0x22, 0x4f, 0x57, 0xda, 0xfa, 0x7e, 0xd8, 0x57, 0xc0, 0x9b,
0x3c, 0x5d, 0x91, 0x8f, 0x61, 0x9f, 0x63, 0x99, 0xb2, 0x98, 0x46, 0x65, 0x4a, 0x63, 0xcc, 0x30,
0xaf, 0xaa, 0x60, 0x64, 0x3f, 0x5c, 0x54, 0x38, 0xf1, 0xa1, 0x77, 0x8b, 0x5c, 0xa8, 0x63, 0x79,
0x3a, 0xa4, 0x9a, 0x92, 0x11, 0xb4, 0xa4, 0x4c, 0x7d, 0xd0, 0xa8, 0x1a, 0x06, 0x3d, 0xe8, 0x9c,
0x64, 0xa5, 0x5c, 0x05, 0xbf, 0x3b, 0xf0, 0xe4, 0x72, 0x51, 0x22, 0x7f, 0x9d, 0x16, 0xf1, 0xcd,
0xc9, 0x52, 0x72, 0x4a, 0xde, 0xc0, 0x1e, 0x72, 0x2a, 0x16, 0x5c, 0x71, 0x4f, 0x58, 0x7e, 0xad,
0x25, 0x1d, 0x1c, 0x4f, 0x1b, 0xc5, 0xb5, 0x95, 0x73, 0x74, 0x62, 0x12, 0x66, 0x3a, 0x3e, 0x1c,
0x62, 0x73, 0x3a, 0xfe, 0x09, 0x86, 0x1b, 0xdf, 0x95, 0x31, 0xaa, 0xf0, 0xad, 0x55, 0x7a, 0xac,
0x1c, 0x2f, 0x29, 0x67, 0x72, 0x65, 0x1b, 0xd4, 0xce, 0x94, 0x21, 0xb6, 0xff, 0x54, 0x1d, 0xb6,
0x74, 0x1d, 0x7a, 0x06, 0x39, 0x4d, 0x44, 0xf0, 0x11, 0x1c, 0xcc, 0x52, 0x86, 0xb9, 0x3c, 0x67,
0x42, 0x62, 0x1e, 0xe2, 0x2f, 0x0b, 0x14, 0x52, 0xed, 0x90, 0xd3, 0x0c, 0x6d, 0xfb, 0xeb, 0x71,
0xf0, 0x2b, 0xec, 0x99, 0xd2, 0x39, 0x2f, 0x62, 0x5d, 0x37, 0x4a, 0x18, 0xd5, 0xf7, 0x26, 0x48,
0x0d, 0xb7, 0x2e, 0x04, 0x77, 0xfb, 0x42, 0x68, 0x76, 0x4c, 0xeb, 0xdf, 0x3b, 0xa6, 0x7d, 0xbf,
0x63, 0x7e, 0x80, 0x83, 0xf3, 0xa2, 0xb8, 0x59, 0x94, 0x86, 0x46, 0xc5, 0x75, 0xf3, 0x84, 0xce,
0xa4, 0xa5, 0xf6, 0xac, 0x4f, 0xb8, 0x55, 0xb1, 0xee, 0x76, 0xc5, 0x06, 0x7f, 0x3b, 0x70, 0xb8,
0xb9, 0xac, 0xed, 0xc5, 0x9f, 0xe1, 0xa0, 0x5e, 0x37, 0x4a, 0xed, 0x99, 0xcd, 0x06, 0x83, 0xe3,
0x57, 0x0d, 0x33, 0x1f, 0xca, 0xae, 0xae, 0x8f, 0xa4, 0x12, 0x2b, 0xdc, 0xbf, 0xdd, 0x42, 0xc4,
0x78, 0x09, 0xa3, 0xed, 0x30, 0x55, 0xd0, 0xf5, 0xae, 0x56, 0xd9, 0x7e, 0x95, 0x49, 0x3e, 0x05,
0x6f, 0x4d, 0xc4, 0xd5, 0x44, 0x0e, 0x36, 0x88, 0xd8, 0xbd, 0xd6, 0x51, 0xe4, 0x10, 0x3a, 0xc8,
0x79, 0x51, 0x5d, 0x04, 0x66, 0x12, 0x7c, 0x0e, 0xfd, 0xff, 0xec, 0x62, 0xf0, 0xa7, 0x03, 0xc3,
0xaf, 0x84, 0x60, 0xd7, 0x75, 0xb9, 0x1c, 0x42, 0xc7, 0xb4, 0xa9, 0xb9, 0xac, 0xcc, 0x84, 0x4c,
0x60, 0x60, 0xbb, 0xac, 0x21, 0x7d, 0x13, 0x7a, 0xef, 0x6d, 0x62, 0x3b, 0xaf, 0x6d, 0xa8, 0x49,
0x99, 0x6e, 0x3f, 0x03, 0x9d, 0x47, 0x9f, 0x81, 0x6e, 0xe3, 0x19, 0x78, 0x06, 0x9e, 0x4e, 0xca,
0x8b, 0x04, 0xed, 0xfb, 0xd0, 0x57, 0xc0, 0x77, 0x45, 0xa2, 0xcb, 0xba, 0x3a, 0x8c, 0x35, 0x7e,
0x04, 0xad, 0xab, 0x5a, 0x7c, 0x35, 0xac, 0x24, 0x72, 0x1f, 0x93, 0xe8, 0xde, 0xcb, 0x57, 0x0b,
0xd2, 0x6e, 0x0a, 0x52, 0x7b, 0xd1, 0x69, 0x78, 0x71, 0xfc, 0x9b, 0x0b, 0xbd, 0x4b, 0xa4, 0x77,
0x88, 0x09, 0x39, 0x85, 0xe1, 0x25, 0xe6, 0xc9, 0xfa, 0x15, 0x3e, 0x6c, 0xd8, 0x5b, 0xa3, 0xe3,
0xe7, 0x0f, 0xa1, 0x15, 0xff, 0x60, 0x67, 0xea, 0xbc, 0x72, 0xc8, 0x05, 0x0c, 0xcf, 0x10, 0xcb,
0x59, 0x91, 0xe7, 0x18, 0x4b, 0x4c, 0xc8, 0x8b, 0x46, 0xd2, 0x03, 0x3d, 0x3f, 0x7e, 0x7a, 0xef,
0xf1, 0xab, 0x4a, 0xc4, 0xae, 0xf8, 0x3d, 0xec, 0x36, 0x4b, 0x7d, 0x63, 0xc1, 0x07, 0x1a, 0x73,
0xfc, 0xf2, 0x3d, 0x3d, 0x12, 0xec, 0x90, 0x2f, 0xa1, 0x6b, 0xc4, 0x27, 0x7e, 0x23, 0x78, 0xa3,
0xb8, 0x36, 0x78, 0x6d, 0x3a, 0x15, 0xec, 0xcc, 0xbb, 0xfa, 0x2f, 0xe6, 0xb3, 0x7f, 0x02, 0x00,
0x00, 0xff, 0xff, 0xbc, 0xef, 0x85, 0x4d, 0xd5, 0x08, 0x00, 0x00,
// 1055 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x56, 0x4b, 0x6f, 0xe4, 0x44,
0x10, 0x5e, 0x7b, 0x9e, 0xae, 0xd9, 0xc9, 0x4e, 0x3a, 0x11, 0xf2, 0xce, 0xbe, 0x06, 0x73, 0x19,
0x04, 0x8a, 0x96, 0x70, 0x44, 0x08, 0xb1, 0xd1, 0x22, 0xa2, 0x04, 0x36, 0x38, 0xb0, 0x07, 0x2e,
0xa6, 0x63, 0x57, 0xa2, 0x56, 0xfc, 0xa2, 0xbb, 0x27, 0x99, 0xd9, 0x0b, 0x47, 0xfe, 0x15, 0x17,
0xb8, 0xf1, 0x53, 0xb8, 0xf1, 0x0b, 0x50, 0x3f, 0xec, 0xf1, 0x38, 0x09, 0x91, 0x90, 0xb8, 0xb5,
0xbf, 0xae, 0xee, 0xaa, 0xfe, 0xbe, 0x7a, 0x18, 0x1e, 0x66, 0x54, 0x48, 0xe4, 0x7b, 0x25, 0x2f,
0x64, 0x41, 0x3c, 0xf3, 0x15, 0x95, 0x67, 0xc1, 0x5f, 0x2e, 0x78, 0x5f, 0x23, 0xe5, 0xf2, 0x0c,
0xa9, 0x24, 0x5b, 0xe0, 0xb2, 0xd2, 0x77, 0x66, 0xce, 0xdc, 0x0b, 0x5d, 0x56, 0x12, 0x02, 0xdd,
0xb2, 0xe0, 0xd2, 0x77, 0x67, 0xce, 0x7c, 0x1c, 0xea, 0x35, 0x79, 0x06, 0x50, 0x2e, 0xce, 0x52,
0x16, 0x47, 0x0b, 0x9e, 0xfa, 0x1d, 0x6d, 0xeb, 0x19, 0xe4, 0x07, 0x9e, 0x92, 0x39, 0x4c, 0x32,
0xba, 0x8c, 0xae, 0x8a, 0x74, 0x91, 0x61, 0x14, 0x17, 0x8b, 0x5c, 0xfa, 0x5d, 0x7d, 0x7c, 0x2b,
0xa3, 0xcb, 0xb7, 0x1a, 0x3e, 0x50, 0x28, 0x99, 0xa9, 0xa8, 0x96, 0xd1, 0x39, 0x4b, 0x31, 0xba,
0xc4, 0x95, 0xdf, 0x9b, 0x39, 0xf3, 0x6e, 0x08, 0x19, 0x5d, 0x7e, 0xc5, 0x52, 0x3c, 0xc2, 0x15,
0x79, 0x01, 0xa3, 0x84, 0x4a, 0x1a, 0xc5, 0x98, 0x4b, 0xe4, 0x7e, 0x5f, 0xfb, 0x02, 0x05, 0x1d,
0x68, 0x44, 0xc5, 0xc7, 0x69, 0x7c, 0xe9, 0x0f, 0xf4, 0x8e, 0x5e, 0xab, 0xf8, 0x68, 0x92, 0xb1,
0x3c, 0xd2, 0x91, 0x0f, 0xb5, 0x6b, 0x4f, 0x23, 0x27, 0x2a, 0xfc, 0xcf, 0x61, 0x60, 0x62, 0x13,
0xbe, 0x37, 0xeb, 0xcc, 0x47, 0xfb, 0x1f, 0xec, 0xd5, 0x6c, 0xec, 0x99, 0xf0, 0x0e, 0xf3, 0xf3,
0x82, 0x67, 0x54, 0xb2, 0x22, 0xff, 0x06, 0x85, 0xa0, 0x17, 0x18, 0x56, 0x67, 0xc8, 0x63, 0x18,
0xe6, 0x78, 0x1d, 0x5d, 0xb1, 0x44, 0xf8, 0x30, 0xeb, 0xcc, 0xc7, 0xe1, 0x20, 0xc7, 0xeb, 0xb7,
0x2c, 0x11, 0xe4, 0x7d, 0x78, 0x98, 0x60, 0x8a, 0x12, 0x13, 0xb3, 0x3d, 0xd2, 0xdb, 0x23, 0x8b,
0x29, 0x93, 0x40, 0xc0, 0x76, 0x4d, 0x76, 0x88, 0xa2, 0x2c, 0x72, 0x81, 0x64, 0x0e, 0x8f, 0xcc,
0xed, 0xa7, 0xec, 0x1d, 0x1e, 0xb3, 0x8c, 0x49, 0xad, 0x40, 0x37, 0x6c, 0xc3, 0xe4, 0x29, 0x78,
0x02, 0x63, 0x8e, 0xf2, 0x08, 0x57, 0x5a, 0x13, 0x2f, 0x5c, 0x03, 0xe4, 0x3d, 0xe8, 0xa7, 0x48,
0x13, 0xe4, 0x56, 0x14, 0xfb, 0x15, 0xfc, 0xe1, 0x82, 0x7f, 0xd7, 0xc3, 0xb4, 0xe2, 0x89, 0xf6,
0x37, 0x0e, 0x5d, 0x96, 0x28, 0x46, 0x05, 0x7b, 0x87, 0xfa, 0xf6, 0x6e, 0xa8, 0xd7, 0xe4, 0x39,
0x40, 0x5c, 0xa4, 0x29, 0xc6, 0xea, 0xa0, 0xbd, 0xbc, 0x81, 0x28, 0xc6, 0xb5, 0x88, 0x6b, 0xb1,
0xbb, 0xa1, 0xa7, 0x10, 0xa3, 0x73, 0xcd, 0x8b, 0x35, 0x30, 0x3a, 0x5b, 0x5e, 0x8c, 0xc9, 0xc7,
0x40, 0x2a, 0xea, 0xce, 0x56, 0xb5, 0x61, 0x5f, 0x1b, 0x4e, 0xec, 0xce, 0xab, 0x55, 0x65, 0xfd,
0x04, 0x3c, 0x8e, 0x34, 0x89, 0x8a, 0x3c, 0x5d, 0x69, 0xe9, 0x87, 0xe1, 0x50, 0x01, 0x6f, 0xf2,
0x74, 0x45, 0x3e, 0x82, 0x6d, 0x8e, 0x65, 0xca, 0x62, 0x1a, 0x95, 0x29, 0x8d, 0x31, 0xc3, 0xbc,
0xca, 0x82, 0x89, 0xdd, 0x38, 0xa9, 0x70, 0xe2, 0xc3, 0xe0, 0x0a, 0xb9, 0x50, 0xcf, 0xf2, 0xb4,
0x49, 0xf5, 0x49, 0x26, 0xd0, 0x91, 0x32, 0xf5, 0x41, 0xa3, 0x6a, 0x19, 0x0c, 0xa0, 0xf7, 0x3a,
0x2b, 0xe5, 0x2a, 0xf8, 0xcd, 0x81, 0x47, 0xa7, 0x8b, 0x12, 0xf9, 0xab, 0xb4, 0x88, 0x2f, 0x5f,
0x2f, 0x25, 0xa7, 0xe4, 0x0d, 0x6c, 0x21, 0xa7, 0x62, 0xc1, 0x55, 0xec, 0x09, 0xcb, 0x2f, 0x34,
0xa5, 0xa3, 0xfd, 0x79, 0x23, 0xb9, 0x5a, 0x67, 0xf6, 0x5e, 0x9b, 0x03, 0x07, 0xda, 0x3e, 0x1c,
0x63, 0xf3, 0x73, 0xfa, 0x23, 0x8c, 0x37, 0xf6, 0x95, 0x30, 0x2a, 0xf1, 0xad, 0x54, 0x7a, 0xad,
0x14, 0x2f, 0x29, 0x67, 0x72, 0x65, 0x0b, 0xd4, 0x7e, 0x29, 0x41, 0x6c, 0xfd, 0xa9, 0x3c, 0xec,
0xe8, 0x3c, 0xf4, 0x0c, 0x72, 0x98, 0x88, 0xe0, 0x43, 0xd8, 0x39, 0x48, 0x19, 0xe6, 0xf2, 0x98,
0x09, 0x89, 0x79, 0x88, 0x3f, 0x2f, 0x50, 0x48, 0xe5, 0x21, 0xa7, 0x19, 0xda, 0xf2, 0xd7, 0xeb,
0xe0, 0x17, 0xd8, 0x32, 0xa9, 0x73, 0x5c, 0xc4, 0x3a, 0x6f, 0x14, 0x31, 0xaa, 0xee, 0x8d, 0x91,
0x5a, 0xb6, 0x1a, 0x82, 0xdb, 0x6e, 0x08, 0xcd, 0x8a, 0xe9, 0xfc, 0x7b, 0xc5, 0x74, 0x6f, 0x56,
0xcc, 0xf7, 0xb0, 0x73, 0x5c, 0x14, 0x97, 0x8b, 0xd2, 0x84, 0x51, 0xc5, 0xba, 0xf9, 0x42, 0x67,
0xd6, 0x51, 0x3e, 0xeb, 0x17, 0xb6, 0x32, 0xd6, 0x6d, 0x67, 0x6c, 0xf0, 0xb7, 0x03, 0xbb, 0x9b,
0xd7, 0xda, 0x5a, 0xfc, 0x09, 0x76, 0xea, 0x7b, 0xa3, 0xd4, 0xbe, 0xd9, 0x38, 0x18, 0xed, 0xbf,
0x6c, 0x88, 0x79, 0xdb, 0xe9, 0xaa, 0x7d, 0x24, 0x15, 0x59, 0xe1, 0xf6, 0x55, 0x0b, 0x11, 0xd3,
0x25, 0x4c, 0xda, 0x66, 0x2a, 0xa1, 0x6b, 0xaf, 0x96, 0xd9, 0x61, 0x75, 0x92, 0x7c, 0x02, 0xde,
0x3a, 0x10, 0x57, 0x07, 0xb2, 0xb3, 0x11, 0x88, 0xf5, 0xb5, 0xb6, 0x22, 0xbb, 0xd0, 0x43, 0xce,
0x8b, 0xaa, 0x11, 0x98, 0x8f, 0xe0, 0x33, 0x18, 0xfe, 0x67, 0x15, 0x83, 0x3f, 0x1d, 0x18, 0x7f,
0x29, 0x04, 0xbb, 0xa8, 0xd3, 0x65, 0x17, 0x7a, 0xa6, 0x4c, 0x4d, 0xb3, 0x32, 0x1f, 0x64, 0x06,
0x23, 0x5b, 0x65, 0x0d, 0xea, 0x9b, 0xd0, 0xbd, 0xdd, 0xc4, 0x56, 0x5e, 0xd7, 0x84, 0x26, 0x65,
0xda, 0x1e, 0x03, 0xbd, 0x3b, 0xc7, 0x40, 0xbf, 0x31, 0x06, 0x9e, 0x80, 0xa7, 0x0f, 0xe5, 0x45,
0x82, 0x76, 0x3e, 0x0c, 0x15, 0xf0, 0x6d, 0x91, 0xe8, 0xb4, 0xae, 0x1e, 0x63, 0x85, 0x9f, 0x40,
0xe7, 0xbc, 0x26, 0x5f, 0x2d, 0x2b, 0x8a, 0xdc, 0xbb, 0x28, 0xba, 0x31, 0xf9, 0x6a, 0x42, 0xba,
0x4d, 0x42, 0x6a, 0x2d, 0x7a, 0x4d, 0x2d, 0x2e, 0x60, 0xfb, 0x54, 0x52, 0xc9, 0x84, 0x64, 0xb1,
0xa8, 0x18, 0x6d, 0x71, 0xe7, 0xdc, 0xc7, 0x9d, 0x7b, 0x17, 0x77, 0x9d, 0x9a, 0xbb, 0xe0, 0x77,
0x07, 0x48, 0xd3, 0x93, 0x7d, 0xee, 0xff, 0xe0, 0x4a, 0xd1, 0x23, 0x0b, 0x49, 0xd3, 0x48, 0x0f,
0x10, 0x3b, 0x06, 0x34, 0xa2, 0x26, 0x98, 0x12, 0x64, 0x21, 0x30, 0x31, 0xbb, 0x66, 0x06, 0x0c,
0x15, 0xa0, 0x37, 0x37, 0x47, 0x48, 0xbf, 0x35, 0x42, 0xf6, 0x7f, 0xed, 0xc0, 0xe0, 0x14, 0xe9,
0x35, 0x62, 0x42, 0x0e, 0x61, 0x7c, 0x8a, 0x79, 0xb2, 0xfe, 0x69, 0xd9, 0x6d, 0x54, 0x43, 0x8d,
0x4e, 0x9f, 0xde, 0x86, 0x56, 0xef, 0x0f, 0x1e, 0xcc, 0x9d, 0x97, 0x0e, 0x39, 0x81, 0xf1, 0x11,
0x62, 0x79, 0x50, 0xe4, 0x39, 0xc6, 0x12, 0x13, 0xf2, 0xbc, 0x71, 0xe8, 0x96, 0x16, 0x39, 0x7d,
0x7c, 0xe3, 0x5f, 0xa1, 0xaa, 0x28, 0x7b, 0xe3, 0x77, 0xf0, 0xb0, 0xd9, 0x19, 0x36, 0x2e, 0xbc,
0xa5, 0x8f, 0x4d, 0x5f, 0xdc, 0xd3, 0x52, 0x82, 0x07, 0xe4, 0x0b, 0xe8, 0x9b, 0x5c, 0x25, 0x7e,
0xc3, 0x78, 0xa3, 0x16, 0x37, 0xe2, 0xda, 0x4c, 0xec, 0xe0, 0x01, 0x39, 0x02, 0x58, 0x67, 0x00,
0x69, 0xf2, 0x72, 0x23, 0x05, 0xa7, 0xcf, 0xee, 0xd8, 0xad, 0x2e, 0x3b, 0xeb, 0xeb, 0x3f, 0xc8,
0x4f, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xc7, 0x9f, 0x0a, 0x25, 0x51, 0x0a, 0x00, 0x00,
} }

25
weed/server/filer_grpc_server.go
View File

@ -5,6 +5,8 @@ import (
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
"strconv"
"strings"
"time" "time"
"github.com/chrislusf/seaweedfs/weed/filer2" "github.com/chrislusf/seaweedfs/weed/filer2"
@ -12,8 +14,7 @@ import (
"github.com/chrislusf/seaweedfs/weed/operation" "github.com/chrislusf/seaweedfs/weed/operation"
"github.com/chrislusf/seaweedfs/weed/pb/filer_pb" "github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
"github.com/chrislusf/seaweedfs/weed/util" "github.com/chrislusf/seaweedfs/weed/util"
"strconv"
"strings"
"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
) )
func (fs *FilerServer) LookupDirectoryEntry(ctx context.Context, req *filer_pb.LookupDirectoryEntryRequest) (*filer_pb.LookupDirectoryEntryResponse, error) { func (fs *FilerServer) LookupDirectoryEntry(ctx context.Context, req *filer_pb.LookupDirectoryEntryRequest) (*filer_pb.LookupDirectoryEntryResponse, error) {
@ -233,3 +234,23 @@ func (fs *FilerServer) DeleteCollection(ctx context.Context, req *filer_pb.Delet
return &filer_pb.DeleteCollectionResponse{}, err return &filer_pb.DeleteCollectionResponse{}, err
} }
func (fs *FilerServer) Statistics(ctx context.Context, req *filer_pb.StatisticsRequest) (resp *filer_pb.StatisticsResponse, err error) {
input := &master_pb.StatisticsRequest{
Replication: req.Replication,
Collection: req.Collection,
Ttl: req.Ttl,
}
output, err := operation.Statistics(fs.filer.GetMaster(), input)
if err != nil {
return nil, err
}
return &filer_pb.StatisticsResponse{
TotalSize: output.TotalSize,
UsedSize: output.UsedSize,
FileCount: output.FileCount,
}, nil
}

26
weed/server/master_grpc_server_volume.go
View File

@ -84,3 +84,29 @@ func (ms *MasterServer) Assign(ctx context.Context, req *master_pb.AssignRequest
Count: count, Count: count,
}, nil }, nil
} }
func (ms *MasterServer) Statistics(ctx context.Context, req *master_pb.StatisticsRequest) (*master_pb.StatisticsResponse, error) {
if req.Replication == "" {
req.Replication = ms.defaultReplicaPlacement
}
replicaPlacement, err := storage.NewReplicaPlacementFromString(req.Replication)
if err != nil {
return nil, err
}
ttl, err := storage.ReadTTL(req.Ttl)
if err != nil {
return nil, err
}
volumeLayout := ms.Topo.GetVolumeLayout(req.Collection, replicaPlacement, ttl)
stats := volumeLayout.Stats()
resp := &master_pb.StatisticsResponse{
TotalSize: stats.TotalSize,
UsedSize: stats.UsedSize,
FileCount: stats.FileCount,
}
return resp, nil
}

29
weed/topology/volume_layout.go
View File

@ -5,6 +5,7 @@ import (
"fmt" "fmt"
"math/rand" "math/rand"
"sync" "sync"
"time"
"github.com/chrislusf/seaweedfs/weed/glog" "github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/storage" "github.com/chrislusf/seaweedfs/weed/storage"
@ -22,6 +23,12 @@ type VolumeLayout struct {
accessLock sync.RWMutex accessLock sync.RWMutex
} }
type VolumeLayoutStats struct {
TotalSize uint64
UsedSize uint64
FileCount uint64
}
func NewVolumeLayout(rp *storage.ReplicaPlacement, ttl *storage.TTL, volumeSizeLimit uint64) *VolumeLayout { func NewVolumeLayout(rp *storage.ReplicaPlacement, ttl *storage.TTL, volumeSizeLimit uint64) *VolumeLayout {
return &VolumeLayout{ return &VolumeLayout{
rp: rp, rp: rp,
@ -265,3 +272,25 @@ func (vl *VolumeLayout) ToMap() map[string]interface{} {
//m["locations"] = vl.vid2location //m["locations"] = vl.vid2location
return m return m
} }
func (vl *VolumeLayout) Stats() *VolumeLayoutStats {
vl.accessLock.RLock()
defer vl.accessLock.RUnlock()
ret := &VolumeLayoutStats{}
freshThreshold := time.Now().Unix() - 60
for vid, vll := range vl.vid2location {
size, fileCount := vll.Stats(vid, freshThreshold)
ret.FileCount += uint64(fileCount)
ret.UsedSize += size
if vl.readonlyVolumes[vid] {
ret.TotalSize += size
} else {
ret.TotalSize += vl.volumeSizeLimit
}
}
return ret
}

14
weed/topology/volume_location_list.go
View File

@ -2,6 +2,8 @@ package topology
import ( import (
"fmt" "fmt"
"github.com/chrislusf/seaweedfs/weed/storage"
) )
type VolumeLocationList struct { type VolumeLocationList struct {
@ -63,3 +65,15 @@ func (dnll *VolumeLocationList) Refresh(freshThreshHold int64) {
dnll.list = l dnll.list = l
} }
} }
func (dnll *VolumeLocationList) Stats(vid storage.VolumeId, freshThreshHold int64) (size uint64, fileCount int) {
for _, dnl := range dnll.list {
if dnl.LastSeen < freshThreshHold {
vinfo, err := dnl.GetVolumesById(vid)
if err == nil {
return vinfo.Size - vinfo.DeletedByteCount, vinfo.FileCount - vinfo.DeleteCount
}
}
}
return 0, 0
}
Write Preview
Loading…
Cancel
Save