Merge pull request #1 from chrislusf/master

sync

16 files changed, 3056 insertions, 558 deletions

diff --git a/weed/pb/Makefile b/weed/pb/Makefile
index c50410574..6680b7ca2 100644
--- a/weed/pb/Makefile
+++ b/weed/pb/Makefile
@@ -6,5 +6,7 @@ gen:
 	protoc master.proto --go_out=plugins=grpc:./master_pb
 	protoc volume_server.proto --go_out=plugins=grpc:./volume_server_pb
 	protoc filer.proto --go_out=plugins=grpc:./filer_pb
+	protoc iam.proto --go_out=plugins=grpc:./iam_pb
+	protoc queue.proto --go_out=plugins=grpc:./queue_pb
 	# protoc filer.proto --java_out=../../other/java/client/src/main/java
 	cp filer.proto ../../other/java/client/src/main/proto
diff --git a/weed/pb/filer.proto b/weed/pb/filer.proto
index 18ccca44f..8df46e917 100644
--- a/weed/pb/filer.proto
+++ b/weed/pb/filer.proto
@@ -12,7 +12,7 @@ service SeaweedFiler {
     rpc LookupDirectoryEntry (LookupDirectoryEntryRequest) returns (LookupDirectoryEntryResponse) {
     }
 
-    rpc ListEntries (ListEntriesRequest) returns (ListEntriesResponse) {
+    rpc ListEntries (ListEntriesRequest) returns (stream ListEntriesResponse) {
     }
 
     rpc CreateEntry (CreateEntryRequest) returns (CreateEntryResponse) {
@@ -24,6 +24,9 @@ service SeaweedFiler {
     rpc DeleteEntry (DeleteEntryRequest) returns (DeleteEntryResponse) {
     }
 
+    rpc StreamDeleteEntries (stream DeleteEntryRequest) returns (stream DeleteEntryResponse) {
+    }
+
     rpc AtomicRenameEntry (AtomicRenameEntryRequest) returns (AtomicRenameEntryResponse) {
     }
 
@@ -64,7 +67,7 @@ message ListEntriesRequest {
 }
 
 message ListEntriesResponse {
-    repeated Entry entries = 1;
+    Entry entry = 1;
 }
 
 message Entry {
@@ -96,6 +99,8 @@ message FileChunk {
     string source_file_id = 6; // to be deprecated
     FileId fid = 7;
     FileId source_fid = 8;
+    bytes cipher_key = 9;
+    bool is_gzipped = 10;
 }
 
 message FileId {
@@ -123,9 +128,11 @@ message FuseAttributes {
 message CreateEntryRequest {
     string directory = 1;
     Entry entry = 2;
+    bool o_excl = 3;
 }
 
 message CreateEntryResponse {
+    string error = 1;
 }
 
 message UpdateEntryRequest {
@@ -145,6 +152,7 @@ message DeleteEntryRequest {
 }
 
 message DeleteEntryResponse {
+    string error = 1;
 }
 
 message AtomicRenameEntryRequest {
@@ -163,6 +171,7 @@ message AssignVolumeRequest {
     string replication = 3;
     int32 ttl_sec = 4;
     string data_center = 5;
+    string parent_path = 6;
 }
 
 message AssignVolumeResponse {
@@ -171,6 +180,9 @@ message AssignVolumeResponse {
     string public_url = 3;
     int32 count = 4;
     string auth = 5;
+    string collection = 6;
+    string replication = 7;
+    string error = 8;
 }
 
 message LookupVolumeRequest {
@@ -217,4 +229,7 @@ message GetFilerConfigurationResponse {
     string replication = 2;
     string collection = 3;
     uint32 max_mb = 4;
+    string dir_buckets = 5;
+    string dir_queues = 6;
+    bool cipher = 7;
 }
diff --git a/weed/pb/filer_pb/filer.pb.go b/weed/pb/filer_pb/filer.pb.go
index 89541d6f3..9cf659ece 100644
--- a/weed/pb/filer_pb/filer.pb.go
+++ b/weed/pb/filer_pb/filer.pb.go
@@ -151,7 +151,7 @@ func (m *ListEntriesRequest) GetLimit() uint32 {
 }
 
 type ListEntriesResponse struct {
-	Entries []*Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
+	Entry *Entry `protobuf:"bytes,1,opt,name=entry" json:"entry,omitempty"`
 }
 
 func (m *ListEntriesResponse) Reset()                    { *m = ListEntriesResponse{} }
@@ -159,9 +159,9 @@ func (m *ListEntriesResponse) String() string            { return proto.CompactT
 func (*ListEntriesResponse) ProtoMessage()               {}
 func (*ListEntriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 
-func (m *ListEntriesResponse) GetEntries() []*Entry {
+func (m *ListEntriesResponse) GetEntry() *Entry {
 	if m != nil {
-		return m.Entries
+		return m.Entry
 	}
 	return nil
 }
@@ -287,6 +287,8 @@ type FileChunk struct {
 	SourceFileId string  `protobuf:"bytes,6,opt,name=source_file_id,json=sourceFileId" json:"source_file_id,omitempty"`
 	Fid          *FileId `protobuf:"bytes,7,opt,name=fid" json:"fid,omitempty"`
 	SourceFid    *FileId `protobuf:"bytes,8,opt,name=source_fid,json=sourceFid" json:"source_fid,omitempty"`
+	CipherKey    []byte  `protobuf:"bytes,9,opt,name=cipher_key,json=cipherKey,proto3" json:"cipher_key,omitempty"`
+	IsGzipped    bool    `protobuf:"varint,10,opt,name=is_gzipped,json=isGzipped" json:"is_gzipped,omitempty"`
 }
 
 func (m *FileChunk) Reset()                    { *m = FileChunk{} }
@@ -350,6 +352,20 @@ func (m *FileChunk) GetSourceFid() *FileId {
 	return nil
 }
 
+func (m *FileChunk) GetCipherKey() []byte {
+	if m != nil {
+		return m.CipherKey
+	}
+	return nil
+}
+
+func (m *FileChunk) GetIsGzipped() bool {
+	if m != nil {
+		return m.IsGzipped
+	}
+	return false
+}
+
 type FileId struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
 	FileKey  uint64 `protobuf:"varint,2,opt,name=file_key,json=fileKey" json:"file_key,omitempty"`
@@ -497,6 +513,7 @@ func (m *FuseAttributes) GetSymlinkTarget() string {
 type CreateEntryRequest struct {
 	Directory string `protobuf:"bytes,1,opt,name=directory" json:"directory,omitempty"`
 	Entry     *Entry `protobuf:"bytes,2,opt,name=entry" json:"entry,omitempty"`
+	OExcl     bool   `protobuf:"varint,3,opt,name=o_excl,json=oExcl" json:"o_excl,omitempty"`
 }
 
 func (m *CreateEntryRequest) Reset()                    { *m = CreateEntryRequest{} }
@@ -518,7 +535,15 @@ func (m *CreateEntryRequest) GetEntry() *Entry {
 	return nil
 }
 
+func (m *CreateEntryRequest) GetOExcl() bool {
+	if m != nil {
+		return m.OExcl
+	}
+	return false
+}
+
 type CreateEntryResponse struct {
+	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
 }
 
 func (m *CreateEntryResponse) Reset()                    { *m = CreateEntryResponse{} }
@@ -526,6 +551,13 @@ func (m *CreateEntryResponse) String() string            { return proto.CompactT
 func (*CreateEntryResponse) ProtoMessage()               {}
 func (*CreateEntryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
+func (m *CreateEntryResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
 type UpdateEntryRequest struct {
 	Directory string `protobuf:"bytes,1,opt,name=directory" json:"directory,omitempty"`
 	Entry     *Entry `protobuf:"bytes,2,opt,name=entry" json:"entry,omitempty"`
@@ -608,6 +640,7 @@ func (m *DeleteEntryRequest) GetIgnoreRecursiveError() bool {
 }
 
 type DeleteEntryResponse struct {
+	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
 }
 
 func (m *DeleteEntryResponse) Reset()                    { *m = DeleteEntryResponse{} }
@@ -615,6 +648,13 @@ func (m *DeleteEntryResponse) String() string            { return proto.CompactT
 func (*DeleteEntryResponse) ProtoMessage()               {}
 func (*DeleteEntryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
 
+func (m *DeleteEntryResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
 type AtomicRenameEntryRequest struct {
 	OldDirectory string `protobuf:"bytes,1,opt,name=old_directory,json=oldDirectory" json:"old_directory,omitempty"`
 	OldName      string `protobuf:"bytes,2,opt,name=old_name,json=oldName" json:"old_name,omitempty"`
@@ -669,6 +709,7 @@ type AssignVolumeRequest struct {
 	Replication string `protobuf:"bytes,3,opt,name=replication" json:"replication,omitempty"`
 	TtlSec      int32  `protobuf:"varint,4,opt,name=ttl_sec,json=ttlSec" json:"ttl_sec,omitempty"`
 	DataCenter  string `protobuf:"bytes,5,opt,name=data_center,json=dataCenter" json:"data_center,omitempty"`
+	ParentPath  string `protobuf:"bytes,6,opt,name=parent_path,json=parentPath" json:"parent_path,omitempty"`
 }
 
 func (m *AssignVolumeRequest) Reset()                    { *m = AssignVolumeRequest{} }
@@ -711,12 +752,22 @@ func (m *AssignVolumeRequest) GetDataCenter() string {
 	return ""
 }
 
+func (m *AssignVolumeRequest) GetParentPath() string {
+	if m != nil {
+		return m.ParentPath
+	}
+	return ""
+}
+
 type AssignVolumeResponse struct {
-	FileId    string `protobuf:"bytes,1,opt,name=file_id,json=fileId" json:"file_id,omitempty"`
-	Url       string `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"`
-	PublicUrl string `protobuf:"bytes,3,opt,name=public_url,json=publicUrl" json:"public_url,omitempty"`
-	Count     int32  `protobuf:"varint,4,opt,name=count" json:"count,omitempty"`
-	Auth      string `protobuf:"bytes,5,opt,name=auth" json:"auth,omitempty"`
+	FileId      string `protobuf:"bytes,1,opt,name=file_id,json=fileId" json:"file_id,omitempty"`
+	Url         string `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"`
+	PublicUrl   string `protobuf:"bytes,3,opt,name=public_url,json=publicUrl" json:"public_url,omitempty"`
+	Count       int32  `protobuf:"varint,4,opt,name=count" json:"count,omitempty"`
+	Auth        string `protobuf:"bytes,5,opt,name=auth" json:"auth,omitempty"`
+	Collection  string `protobuf:"bytes,6,opt,name=collection" json:"collection,omitempty"`
+	Replication string `protobuf:"bytes,7,opt,name=replication" json:"replication,omitempty"`
+	Error       string `protobuf:"bytes,8,opt,name=error" json:"error,omitempty"`
 }
 
 func (m *AssignVolumeResponse) Reset()                    { *m = AssignVolumeResponse{} }
@@ -759,6 +810,27 @@ func (m *AssignVolumeResponse) GetAuth() string {
 	return ""
 }
 
+func (m *AssignVolumeResponse) GetCollection() string {
+	if m != nil {
+		return m.Collection
+	}
+	return ""
+}
+
+func (m *AssignVolumeResponse) GetReplication() string {
+	if m != nil {
+		return m.Replication
+	}
+	return ""
+}
+
+func (m *AssignVolumeResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
 type LookupVolumeRequest struct {
 	VolumeIds []string `protobuf:"bytes,1,rep,name=volume_ids,json=volumeIds" json:"volume_ids,omitempty"`
 }
@@ -956,6 +1028,9 @@ type GetFilerConfigurationResponse struct {
 	Replication string   `protobuf:"bytes,2,opt,name=replication" json:"replication,omitempty"`
 	Collection  string   `protobuf:"bytes,3,opt,name=collection" json:"collection,omitempty"`
 	MaxMb       uint32   `protobuf:"varint,4,opt,name=max_mb,json=maxMb" json:"max_mb,omitempty"`
+	DirBuckets  string   `protobuf:"bytes,5,opt,name=dir_buckets,json=dirBuckets" json:"dir_buckets,omitempty"`
+	DirQueues   string   `protobuf:"bytes,6,opt,name=dir_queues,json=dirQueues" json:"dir_queues,omitempty"`
+	Cipher      bool     `protobuf:"varint,7,opt,name=cipher" json:"cipher,omitempty"`
 }
 
 func (m *GetFilerConfigurationResponse) Reset()                    { *m = GetFilerConfigurationResponse{} }
@@ -991,6 +1066,27 @@ func (m *GetFilerConfigurationResponse) GetMaxMb() uint32 {
 	return 0
 }
 
+func (m *GetFilerConfigurationResponse) GetDirBuckets() string {
+	if m != nil {
+		return m.DirBuckets
+	}
+	return ""
+}
+
+func (m *GetFilerConfigurationResponse) GetDirQueues() string {
+	if m != nil {
+		return m.DirQueues
+	}
+	return ""
+}
+
+func (m *GetFilerConfigurationResponse) GetCipher() bool {
+	if m != nil {
+		return m.Cipher
+	}
+	return false
+}
+
 func init() {
 	proto.RegisterType((*LookupDirectoryEntryRequest)(nil), "filer_pb.LookupDirectoryEntryRequest")
 	proto.RegisterType((*LookupDirectoryEntryResponse)(nil), "filer_pb.LookupDirectoryEntryResponse")
@@ -1036,10 +1132,11 @@ const _ = grpc.SupportPackageIsVersion4
 
 type SeaweedFilerClient interface {
 	LookupDirectoryEntry(ctx context.Context, in *LookupDirectoryEntryRequest, opts ...grpc.CallOption) (*LookupDirectoryEntryResponse, error)
-	ListEntries(ctx context.Context, in *ListEntriesRequest, opts ...grpc.CallOption) (*ListEntriesResponse, error)
+	ListEntries(ctx context.Context, in *ListEntriesRequest, opts ...grpc.CallOption) (SeaweedFiler_ListEntriesClient, error)
 	CreateEntry(ctx context.Context, in *CreateEntryRequest, opts ...grpc.CallOption) (*CreateEntryResponse, error)
 	UpdateEntry(ctx context.Context, in *UpdateEntryRequest, opts ...grpc.CallOption) (*UpdateEntryResponse, error)
 	DeleteEntry(ctx context.Context, in *DeleteEntryRequest, opts ...grpc.CallOption) (*DeleteEntryResponse, error)
+	StreamDeleteEntries(ctx context.Context, opts ...grpc.CallOption) (SeaweedFiler_StreamDeleteEntriesClient, error)
 	AtomicRenameEntry(ctx context.Context, in *AtomicRenameEntryRequest, opts ...grpc.CallOption) (*AtomicRenameEntryResponse, error)
 	AssignVolume(ctx context.Context, in *AssignVolumeRequest, opts ...grpc.CallOption) (*AssignVolumeResponse, error)
 	LookupVolume(ctx context.Context, in *LookupVolumeRequest, opts ...grpc.CallOption) (*LookupVolumeResponse, error)
@@ -1065,13 +1162,36 @@ func (c *seaweedFilerClient) LookupDirectoryEntry(ctx context.Context, in *Looku
 	return out, nil
 }
 
-func (c *seaweedFilerClient) ListEntries(ctx context.Context, in *ListEntriesRequest, opts ...grpc.CallOption) (*ListEntriesResponse, error) {
-	out := new(ListEntriesResponse)
-	err := grpc.Invoke(ctx, "/filer_pb.SeaweedFiler/ListEntries", in, out, c.cc, opts...)
+func (c *seaweedFilerClient) ListEntries(ctx context.Context, in *ListEntriesRequest, opts ...grpc.CallOption) (SeaweedFiler_ListEntriesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SeaweedFiler_serviceDesc.Streams[0], c.cc, "/filer_pb.SeaweedFiler/ListEntries", opts...)
 	if err != nil {
 		return nil, err
 	}
-	return out, nil
+	x := &seaweedFilerListEntriesClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type SeaweedFiler_ListEntriesClient interface {
+	Recv() (*ListEntriesResponse, error)
+	grpc.ClientStream
+}
+
+type seaweedFilerListEntriesClient struct {
+	grpc.ClientStream
+}
+
+func (x *seaweedFilerListEntriesClient) Recv() (*ListEntriesResponse, error) {
+	m := new(ListEntriesResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
 }
 
 func (c *seaweedFilerClient) CreateEntry(ctx context.Context, in *CreateEntryRequest, opts ...grpc.CallOption) (*CreateEntryResponse, error) {
@@ -1101,6 +1221,37 @@ func (c *seaweedFilerClient) DeleteEntry(ctx context.Context, in *DeleteEntryReq
 	return out, nil
 }
 
+func (c *seaweedFilerClient) StreamDeleteEntries(ctx context.Context, opts ...grpc.CallOption) (SeaweedFiler_StreamDeleteEntriesClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SeaweedFiler_serviceDesc.Streams[1], c.cc, "/filer_pb.SeaweedFiler/StreamDeleteEntries", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &seaweedFilerStreamDeleteEntriesClient{stream}
+	return x, nil
+}
+
+type SeaweedFiler_StreamDeleteEntriesClient interface {
+	Send(*DeleteEntryRequest) error
+	Recv() (*DeleteEntryResponse, error)
+	grpc.ClientStream
+}
+
+type seaweedFilerStreamDeleteEntriesClient struct {
+	grpc.ClientStream
+}
+
+func (x *seaweedFilerStreamDeleteEntriesClient) Send(m *DeleteEntryRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *seaweedFilerStreamDeleteEntriesClient) Recv() (*DeleteEntryResponse, error) {
+	m := new(DeleteEntryResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func (c *seaweedFilerClient) AtomicRenameEntry(ctx context.Context, in *AtomicRenameEntryRequest, opts ...grpc.CallOption) (*AtomicRenameEntryResponse, error) {
 	out := new(AtomicRenameEntryResponse)
 	err := grpc.Invoke(ctx, "/filer_pb.SeaweedFiler/AtomicRenameEntry", in, out, c.cc, opts...)
@@ -1159,10 +1310,11 @@ func (c *seaweedFilerClient) GetFilerConfiguration(ctx context.Context, in *GetF
 
 type SeaweedFilerServer interface {
 	LookupDirectoryEntry(context.Context, *LookupDirectoryEntryRequest) (*LookupDirectoryEntryResponse, error)
-	ListEntries(context.Context, *ListEntriesRequest) (*ListEntriesResponse, error)
+	ListEntries(*ListEntriesRequest, SeaweedFiler_ListEntriesServer) error
 	CreateEntry(context.Context, *CreateEntryRequest) (*CreateEntryResponse, error)
 	UpdateEntry(context.Context, *UpdateEntryRequest) (*UpdateEntryResponse, error)
 	DeleteEntry(context.Context, *DeleteEntryRequest) (*DeleteEntryResponse, error)
+	StreamDeleteEntries(SeaweedFiler_StreamDeleteEntriesServer) error
 	AtomicRenameEntry(context.Context, *AtomicRenameEntryRequest) (*AtomicRenameEntryResponse, error)
 	AssignVolume(context.Context, *AssignVolumeRequest) (*AssignVolumeResponse, error)
 	LookupVolume(context.Context, *LookupVolumeRequest) (*LookupVolumeResponse, error)
@@ -1193,22 +1345,25 @@ func _SeaweedFiler_LookupDirectoryEntry_Handler(srv interface{}, ctx context.Con
 	return interceptor(ctx, in, info, handler)
 }
 
-func _SeaweedFiler_ListEntries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListEntriesRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(SeaweedFilerServer).ListEntries(ctx, in)
+func _SeaweedFiler_ListEntries_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(ListEntriesRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/filer_pb.SeaweedFiler/ListEntries",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(SeaweedFilerServer).ListEntries(ctx, req.(*ListEntriesRequest))
-	}
-	return interceptor(ctx, in, info, handler)
+	return srv.(SeaweedFilerServer).ListEntries(m, &seaweedFilerListEntriesServer{stream})
+}
+
+type SeaweedFiler_ListEntriesServer interface {
+	Send(*ListEntriesResponse) error
+	grpc.ServerStream
+}
+
+type seaweedFilerListEntriesServer struct {
+	grpc.ServerStream
+}
+
+func (x *seaweedFilerListEntriesServer) Send(m *ListEntriesResponse) error {
+	return x.ServerStream.SendMsg(m)
 }
 
 func _SeaweedFiler_CreateEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
@@ -1265,6 +1420,32 @@ func _SeaweedFiler_DeleteEntry_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
+func _SeaweedFiler_StreamDeleteEntries_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SeaweedFilerServer).StreamDeleteEntries(&seaweedFilerStreamDeleteEntriesServer{stream})
+}
+
+type SeaweedFiler_StreamDeleteEntriesServer interface {
+	Send(*DeleteEntryResponse) error
+	Recv() (*DeleteEntryRequest, error)
+	grpc.ServerStream
+}
+
+type seaweedFilerStreamDeleteEntriesServer struct {
+	grpc.ServerStream
+}
+
+func (x *seaweedFilerStreamDeleteEntriesServer) Send(m *DeleteEntryResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *seaweedFilerStreamDeleteEntriesServer) Recv() (*DeleteEntryRequest, error) {
+	m := new(DeleteEntryRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func _SeaweedFiler_AtomicRenameEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(AtomicRenameEntryRequest)
 	if err := dec(in); err != nil {
@@ -1382,10 +1563,6 @@ var _SeaweedFiler_serviceDesc = grpc.ServiceDesc{
 			Handler:    _SeaweedFiler_LookupDirectoryEntry_Handler,
 		},
 		{
-			MethodName: "ListEntries",
-			Handler:    _SeaweedFiler_ListEntries_Handler,
-		},
-		{
 			MethodName: "CreateEntry",
 			Handler:    _SeaweedFiler_CreateEntry_Handler,
 		},
@@ -1422,113 +1599,134 @@ var _SeaweedFiler_serviceDesc = grpc.ServiceDesc{
 			Handler:    _SeaweedFiler_GetFilerConfiguration_Handler,
 		},
 	},
-	Streams:  []grpc.StreamDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "ListEntries",
+			Handler:       _SeaweedFiler_ListEntries_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "StreamDeleteEntries",
+			Handler:       _SeaweedFiler_StreamDeleteEntries_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
 	Metadata: "filer.proto",
 }
 
 func init() { proto.RegisterFile("filer.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 1608 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x58, 0x49, 0x6f, 0xdc, 0x46,
-	0x16, 0x36, 0x7b, 0xe7, 0xeb, 0x6e, 0x5b, 0x2a, 0xc9, 0x36, 0xdd, 0x5a, 0x46, 0xa6, 0xc6, 0x1e,
-	0x19, 0x63, 0x68, 0x0c, 0x8f, 0x0f, 0xf6, 0x18, 0x03, 0xc4, 0xd6, 0x12, 0x08, 0x91, 0x17, 0x50,
-	0x76, 0x90, 0x20, 0x40, 0x08, 0x8a, 0xac, 0x6e, 0x55, 0x44, 0xb2, 0x3a, 0xc5, 0xa2, 0x24, 0xe7,
-	0x27, 0xe4, 0x98, 0x63, 0x80, 0x9c, 0xf3, 0x27, 0x82, 0x5c, 0x02, 0xff, 0x9d, 0x1c, 0x73, 0x0e,
-	0xaa, 0x8a, 0x64, 0x17, 0x9b, 0x2d, 0xc9, 0x41, 0xe0, 0x1b, 0xeb, 0x2d, 0xdf, 0x5b, 0xea, 0x2d,
-	0xd5, 0x0d, 0xdd, 0x21, 0x09, 0x31, 0xdb, 0x1c, 0x33, 0xca, 0x29, 0xea, 0xc8, 0x83, 0x3b, 0x3e,
-	0xb4, 0x5f, 0xc1, 0xd2, 0x3e, 0xa5, 0xc7, 0xe9, 0x78, 0x9b, 0x30, 0xec, 0x73, 0xca, 0xde, 0xed,
-	0xc4, 0x9c, 0xbd, 0x73, 0xf0, 0xb7, 0x29, 0x4e, 0x38, 0x5a, 0x06, 0x33, 0xc8, 0x19, 0x96, 0xb1,
-	0x66, 0x6c, 0x98, 0xce, 0x84, 0x80, 0x10, 0x34, 0x62, 0x2f, 0xc2, 0x56, 0x4d, 0x32, 0xe4, 0xb7,
-	0xbd, 0x03, 0xcb, 0xb3, 0x01, 0x93, 0x31, 0x8d, 0x13, 0x8c, 0xee, 0x40, 0x13, 0x0b, 0x82, 0x44,
-	0xeb, 0x3e, 0xbc, 0xb6, 0x99, 0xbb, 0xb2, 0xa9, 0xe4, 0x14, 0xd7, 0xfe, 0xd5, 0x00, 0xb4, 0x4f,
-	0x12, 0x2e, 0x88, 0x04, 0x27, 0x1f, 0xe6, 0xcf, 0x0d, 0x68, 0x8d, 0x19, 0x1e, 0x92, 0xb3, 0xcc,
-	0xa3, 0xec, 0x84, 0xee, 0xc3, 0x7c, 0xc2, 0x3d, 0xc6, 0x77, 0x19, 0x8d, 0x76, 0x49, 0x88, 0x5f,
-	0x0a, 0xa7, 0xeb, 0x52, 0xa4, 0xca, 0x40, 0x9b, 0x80, 0x48, 0xec, 0x87, 0x69, 0x42, 0x4e, 0xf0,
-	0x41, 0xce, 0xb5, 0x1a, 0x6b, 0xc6, 0x46, 0xc7, 0x99, 0xc1, 0x41, 0x8b, 0xd0, 0x0c, 0x49, 0x44,
-	0xb8, 0xd5, 0x5c, 0x33, 0x36, 0xfa, 0x8e, 0x3a, 0xd8, 0x9f, 0xc0, 0x42, 0xc9, 0xff, 0x2c, 0xfc,
-	0x7b, 0xd0, 0xc6, 0x8a, 0x64, 0x19, 0x6b, 0xf5, 0x59, 0x09, 0xc8, 0xf9, 0xf6, 0x4f, 0x35, 0x68,
-	0x4a, 0x52, 0x91, 0x67, 0x63, 0x92, 0x67, 0x74, 0x1b, 0x7a, 0x24, 0x71, 0x27, 0xc9, 0xa8, 0x49,
-	0xff, 0xba, 0x24, 0x29, 0xf2, 0x8e, 0xfe, 0x0d, 0x2d, 0xff, 0x28, 0x8d, 0x8f, 0x13, 0xab, 0x2e,
-	0x4d, 0x2d, 0x4c, 0x4c, 0x89, 0x60, 0xb7, 0x04, 0xcf, 0xc9, 0x44, 0xd0, 0x63, 0x00, 0x8f, 0x73,
-	0x46, 0x0e, 0x53, 0x8e, 0x13, 0x19, 0x6d, 0xf7, 0xa1, 0xa5, 0x29, 0xa4, 0x09, 0x7e, 0x56, 0xf0,
-	0x1d, 0x4d, 0x16, 0x3d, 0x81, 0x0e, 0x3e, 0xe3, 0x38, 0x0e, 0x70, 0x60, 0x35, 0xa5, 0xa1, 0x95,
-	0xa9, 0x98, 0x36, 0x77, 0x32, 0xbe, 0x8a, 0xb0, 0x10, 0x1f, 0x3c, 0x85, 0x7e, 0x89, 0x85, 0xe6,
-	0xa0, 0x7e, 0x8c, 0xf3, 0x9b, 0x15, 0x9f, 0x22, 0xbb, 0x27, 0x5e, 0x98, 0xaa, 0x22, 0xeb, 0x39,
-	0xea, 0xf0, 0xbf, 0xda, 0x63, 0xc3, 0xde, 0x06, 0x73, 0x37, 0x0d, 0xc3, 0x42, 0x31, 0x20, 0x2c,
-	0x57, 0x0c, 0x08, 0x9b, 0x14, 0x5a, 0xed, 0xc2, 0x42, 0xfb, 0xc5, 0x80, 0xf9, 0x9d, 0x13, 0x1c,
-	0xf3, 0x97, 0x94, 0x93, 0x21, 0xf1, 0x3d, 0x4e, 0x68, 0x8c, 0xee, 0x83, 0x49, 0xc3, 0xc0, 0xbd,
-	0xb0, 0x52, 0x3b, 0x34, 0xcc, 0xbc, 0xbe, 0x0f, 0x66, 0x8c, 0x4f, 0xdd, 0x0b, 0xcd, 0x75, 0x62,
-	0x7c, 0xaa, 0xa4, 0xd7, 0xa1, 0x1f, 0xe0, 0x10, 0x73, 0xec, 0x16, 0xb7, 0x23, 0xae, 0xae, 0xa7,
-	0x88, 0x5b, 0xea, 0x3a, 0xee, 0xc2, 0x35, 0x01, 0x39, 0xf6, 0x18, 0x8e, 0xb9, 0x3b, 0xf6, 0xf8,
-	0x91, 0xbc, 0x13, 0xd3, 0xe9, 0xc7, 0xf8, 0xf4, 0xb5, 0xa4, 0xbe, 0xf6, 0xf8, 0x91, 0xfd, 0x87,
-	0x01, 0x66, 0x71, 0x99, 0xe8, 0x26, 0xb4, 0x85, 0x59, 0x97, 0x04, 0x59, 0x26, 0x5a, 0xe2, 0xb8,
-	0x17, 0x88, 0xce, 0xa0, 0xc3, 0x61, 0x82, 0xb9, 0x74, 0xaf, 0xee, 0x64, 0x27, 0x51, 0x59, 0x09,
-	0xf9, 0x4e, 0x35, 0x43, 0xc3, 0x91, 0xdf, 0x22, 0xe3, 0x11, 0x27, 0x11, 0x96, 0x06, 0xeb, 0x8e,
-	0x3a, 0xa0, 0x05, 0x68, 0x62, 0x97, 0x7b, 0x23, 0x59, 0xe5, 0xa6, 0xd3, 0xc0, 0x6f, 0xbc, 0x11,
-	0xfa, 0x27, 0x5c, 0x4d, 0x68, 0xca, 0x7c, 0xec, 0xe6, 0x66, 0x5b, 0x92, 0xdb, 0x53, 0xd4, 0x5d,
-	0x65, 0xdc, 0x86, 0xfa, 0x90, 0x04, 0x56, 0x5b, 0x26, 0x66, 0xae, 0x5c, 0x84, 0x7b, 0x81, 0x23,
-	0x98, 0xe8, 0x3f, 0x00, 0x05, 0x52, 0x60, 0x75, 0xce, 0x11, 0x35, 0x73, 0xdc, 0xc0, 0xfe, 0x02,
-	0x5a, 0x19, 0xfc, 0x12, 0x98, 0x27, 0x34, 0x4c, 0xa3, 0x22, 0xec, 0xbe, 0xd3, 0x51, 0x84, 0xbd,
-	0x00, 0xdd, 0x02, 0x39, 0xeb, 0x5c, 0x51, 0x55, 0x35, 0x19, 0xa4, 0xcc, 0xd0, 0x67, 0x58, 0x4e,
-	0x0b, 0x9f, 0xd2, 0x63, 0xa2, 0xa2, 0x6f, 0x3b, 0xd9, 0xc9, 0xfe, 0xbd, 0x06, 0x57, 0xcb, 0xe5,
-	0x2e, 0x4c, 0x48, 0x14, 0x99, 0x2b, 0x43, 0xc2, 0x48, 0xd8, 0x83, 0x52, 0xbe, 0x6a, 0x7a, 0xbe,
-	0x72, 0x95, 0x88, 0x06, 0xca, 0x40, 0x5f, 0xa9, 0xbc, 0xa0, 0x01, 0x16, 0xd5, 0x9a, 0x92, 0x40,
-	0x26, 0xb8, 0xef, 0x88, 0x4f, 0x41, 0x19, 0x91, 0x20, 0x1b, 0x21, 0xe2, 0x53, 0xba, 0xc7, 0x24,
-	0x6e, 0x4b, 0x5d, 0x99, 0x3a, 0x89, 0x2b, 0x8b, 0x04, 0xb5, 0xad, 0xee, 0x41, 0x7c, 0xa3, 0x35,
-	0xe8, 0x32, 0x3c, 0x0e, 0xb3, 0xea, 0x95, 0xe9, 0x33, 0x1d, 0x9d, 0x84, 0x56, 0x01, 0x7c, 0x1a,
-	0x86, 0xd8, 0x97, 0x02, 0xa6, 0x14, 0xd0, 0x28, 0xa2, 0x72, 0x38, 0x0f, 0xdd, 0x04, 0xfb, 0x16,
-	0xac, 0x19, 0x1b, 0x4d, 0xa7, 0xc5, 0x79, 0x78, 0x80, 0x7d, 0x11, 0x47, 0x9a, 0x60, 0xe6, 0xca,
-	0x01, 0xd4, 0x95, 0x7a, 0x1d, 0x41, 0x90, 0xa3, 0x72, 0x05, 0x60, 0xc4, 0x68, 0x3a, 0x56, 0xdc,
-	0xde, 0x5a, 0x5d, 0xcc, 0x63, 0x49, 0x91, 0xec, 0x3b, 0x70, 0x35, 0x79, 0x17, 0x85, 0x24, 0x3e,
-	0x76, 0xb9, 0xc7, 0x46, 0x98, 0x5b, 0x7d, 0x55, 0xc3, 0x19, 0xf5, 0x8d, 0x24, 0xda, 0x5f, 0x02,
-	0xda, 0x62, 0xd8, 0xe3, 0xf8, 0x2f, 0xac, 0x9e, 0x0f, 0xec, 0xee, 0xeb, 0xb0, 0x50, 0x82, 0x56,
-	0x53, 0x58, 0x58, 0x7c, 0x3b, 0x0e, 0x3e, 0x96, 0xc5, 0x12, 0x74, 0x66, 0xf1, 0xbd, 0x01, 0x68,
-	0x5b, 0x36, 0xf8, 0xdf, 0xdb, 0xaf, 0xa2, 0xe5, 0xc4, 0xdc, 0x57, 0x03, 0x24, 0xf0, 0xb8, 0x97,
-	0x6d, 0xa6, 0x1e, 0x49, 0x14, 0xfe, 0xb6, 0xc7, 0xbd, 0x6c, 0x3b, 0x30, 0xec, 0xa7, 0x4c, 0x2c,
-	0x2b, 0x59, 0x57, 0x72, 0x3b, 0x38, 0x39, 0x09, 0x3d, 0x82, 0x1b, 0x64, 0x14, 0x53, 0x86, 0x27,
-	0x62, 0x2e, 0x66, 0x8c, 0x32, 0x59, 0x6f, 0x1d, 0x67, 0x51, 0x71, 0x0b, 0x85, 0x1d, 0xc1, 0x13,
-	0xe1, 0x95, 0xc2, 0xc8, 0xc2, 0xfb, 0xd1, 0x00, 0xeb, 0x19, 0xa7, 0x11, 0xf1, 0x1d, 0x2c, 0xdc,
-	0x2c, 0x05, 0xb9, 0x0e, 0x7d, 0x31, 0x4c, 0xa7, 0x03, 0xed, 0xd1, 0x30, 0x98, 0x2c, 0xab, 0x5b,
-	0x20, 0xe6, 0xa9, 0xab, 0xc5, 0xdb, 0xa6, 0x61, 0x20, 0xcb, 0x68, 0x1d, 0xc4, 0xd0, 0xd3, 0xf4,
-	0xd5, 0xea, 0xee, 0xc5, 0xf8, 0xb4, 0xa4, 0x2f, 0x84, 0xa4, 0xbe, 0x9a, 0x94, 0xed, 0x18, 0x9f,
-	0x0a, 0x7d, 0x7b, 0x09, 0x6e, 0xcd, 0xf0, 0x2d, 0xf3, 0xfc, 0x67, 0x03, 0x16, 0x9e, 0x25, 0x09,
-	0x19, 0xc5, 0x9f, 0xcb, 0x99, 0x91, 0x3b, 0xbd, 0x08, 0x4d, 0x9f, 0xa6, 0x31, 0x97, 0xce, 0x36,
-	0x1d, 0x75, 0x98, 0x6a, 0xa3, 0x5a, 0xa5, 0x8d, 0xa6, 0x1a, 0xb1, 0x5e, 0x6d, 0x44, 0xad, 0xd1,
-	0x1a, 0xa5, 0x46, 0xfb, 0x07, 0x74, 0xc5, 0x75, 0xba, 0x3e, 0x8e, 0x39, 0x66, 0xd9, 0x98, 0x05,
-	0x41, 0xda, 0x92, 0x14, 0xfb, 0x7b, 0x03, 0x16, 0xcb, 0x9e, 0x66, 0x6f, 0x8a, 0x73, 0xa7, 0xbe,
-	0x18, 0x33, 0x2c, 0xcc, 0xdc, 0x14, 0x9f, 0xa2, 0x61, 0xc7, 0xe9, 0x61, 0x48, 0x7c, 0x57, 0x30,
-	0x94, 0x7b, 0xa6, 0xa2, 0xbc, 0x65, 0xe1, 0x24, 0xe8, 0x86, 0x1e, 0x34, 0x82, 0x86, 0x97, 0xf2,
-	0xa3, 0x7c, 0xf2, 0x8b, 0x6f, 0xfb, 0x11, 0x2c, 0xa8, 0x67, 0x5e, 0x39, 0x6b, 0x2b, 0x00, 0xc5,
-	0x2c, 0x56, 0x2f, 0x1c, 0xd3, 0x31, 0xf3, 0x61, 0x9c, 0xd8, 0xff, 0x07, 0x73, 0x9f, 0xaa, 0x44,
-	0x24, 0xe8, 0x01, 0x98, 0x61, 0x7e, 0xc8, 0x1e, 0x43, 0x68, 0xd2, 0x54, 0xb9, 0x9c, 0x33, 0x11,
-	0xb2, 0x9f, 0x42, 0x27, 0x27, 0xe7, 0xb1, 0x19, 0xe7, 0xc5, 0x56, 0x9b, 0x8a, 0xcd, 0xfe, 0xcd,
-	0x80, 0xc5, 0xb2, 0xcb, 0x59, 0xfa, 0xde, 0x42, 0xbf, 0x30, 0xe1, 0x46, 0xde, 0x38, 0xf3, 0xe5,
-	0x81, 0xee, 0x4b, 0x55, 0xad, 0x70, 0x30, 0x79, 0xe1, 0x8d, 0x55, 0x49, 0xf5, 0x42, 0x8d, 0x34,
-	0x78, 0x03, 0xf3, 0x15, 0x91, 0x19, 0xef, 0x9b, 0x7b, 0xfa, 0xfb, 0xa6, 0xf4, 0x46, 0x2b, 0xb4,
-	0xf5, 0x47, 0xcf, 0x13, 0xb8, 0xa9, 0xfa, 0x6f, 0xab, 0x28, 0xba, 0x3c, 0xf7, 0xe5, 0xda, 0x34,
-	0xa6, 0x6b, 0xd3, 0x1e, 0x80, 0x55, 0x55, 0xcd, 0xba, 0x60, 0x04, 0xf3, 0x07, 0xdc, 0xe3, 0x24,
-	0xe1, 0xc4, 0x2f, 0x1e, 0xdb, 0x53, 0xc5, 0x6c, 0x5c, 0xb6, 0x55, 0xaa, 0xed, 0x30, 0x07, 0x75,
-	0xce, 0xf3, 0x3a, 0x13, 0x9f, 0xe2, 0x16, 0x90, 0x6e, 0x29, 0xbb, 0x83, 0x8f, 0x60, 0x4a, 0xd4,
-	0x03, 0xa7, 0xdc, 0x0b, 0xd5, 0xd6, 0x6e, 0xc8, 0xad, 0x6d, 0x4a, 0x8a, 0x5c, 0xdb, 0x6a, 0xb1,
-	0x05, 0x8a, 0xdb, 0x54, 0x3b, 0x5d, 0x10, 0x24, 0x73, 0x05, 0x40, 0xb6, 0x94, 0xea, 0x86, 0x96,
-	0xd2, 0x15, 0x94, 0x2d, 0x41, 0xb0, 0x57, 0x61, 0xf9, 0x53, 0xcc, 0xc5, 0xfb, 0x83, 0x6d, 0xd1,
-	0x78, 0x48, 0x46, 0x29, 0xf3, 0xb4, 0xab, 0xb0, 0x7f, 0x30, 0x60, 0xe5, 0x1c, 0x81, 0x2c, 0x60,
-	0x0b, 0xda, 0x91, 0x97, 0x70, 0xcc, 0xf2, 0x2e, 0xc9, 0x8f, 0xd3, 0xa9, 0xa8, 0x5d, 0x96, 0x8a,
-	0x7a, 0x25, 0x15, 0xd7, 0xa1, 0x15, 0x79, 0x67, 0x6e, 0x74, 0x98, 0x3d, 0x30, 0x9a, 0x91, 0x77,
-	0xf6, 0xe2, 0xf0, 0xe1, 0xfb, 0x36, 0xf4, 0x0e, 0xb0, 0x77, 0x8a, 0x71, 0x20, 0x1d, 0x43, 0xa3,
-	0xbc, 0x21, 0xca, 0x3f, 0xd5, 0xd0, 0x9d, 0xe9, 0xca, 0x9f, 0xf9, 0xdb, 0x70, 0x70, 0xf7, 0x32,
-	0xb1, 0xac, 0xb6, 0xae, 0xa0, 0x7d, 0xe8, 0x6a, 0xbf, 0x85, 0xd0, 0xb2, 0xa6, 0x58, 0xf9, 0x89,
-	0x37, 0x58, 0x39, 0x87, 0xab, 0xa3, 0x69, 0x3b, 0x5d, 0x47, 0xab, 0xbe, 0x22, 0x74, 0xb4, 0x59,
-	0x0f, 0x01, 0x89, 0xa6, 0xed, 0x6b, 0x1d, 0xad, 0xfa, 0x42, 0xd0, 0xd1, 0x66, 0x2d, 0x79, 0x89,
-	0xa6, 0xad, 0x47, 0x1d, 0xad, 0xba, 0xfc, 0x75, 0xb4, 0x59, 0x3b, 0xf5, 0x0a, 0xfa, 0x1a, 0xe6,
-	0x2b, 0x8b, 0x0b, 0xd9, 0x13, 0xad, 0xf3, 0x36, 0xee, 0x60, 0xfd, 0x42, 0x99, 0x02, 0xff, 0x15,
-	0xf4, 0xf4, 0x85, 0x82, 0x34, 0x87, 0x66, 0xac, 0xc4, 0xc1, 0xea, 0x79, 0x6c, 0x1d, 0x50, 0x9f,
-	0x95, 0x3a, 0xe0, 0x8c, 0x6d, 0xa1, 0x03, 0xce, 0x1a, 0xb1, 0xf6, 0x15, 0xf4, 0x15, 0xcc, 0x4d,
-	0xcf, 0x2c, 0x74, 0x7b, 0x3a, 0x6d, 0x95, 0x51, 0x38, 0xb0, 0x2f, 0x12, 0x29, 0xc0, 0xf7, 0x00,
-	0x26, 0xa3, 0x08, 0x2d, 0x4d, 0x74, 0x2a, 0xa3, 0x70, 0xb0, 0x3c, 0x9b, 0x59, 0x40, 0x7d, 0x03,
-	0xd7, 0x67, 0xf6, 0x3b, 0xd2, 0x9a, 0xe4, 0xa2, 0x89, 0x31, 0xf8, 0xd7, 0xa5, 0x72, 0xb9, 0xad,
-	0xe7, 0xab, 0x30, 0x97, 0xa8, 0x36, 0x1e, 0x26, 0x9b, 0x7e, 0x48, 0x70, 0xcc, 0x9f, 0x83, 0xd4,
-	0x78, 0xcd, 0x28, 0xa7, 0x87, 0x2d, 0xf9, 0x1f, 0xcf, 0x7f, 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff,
-	0x0e, 0xa9, 0xb5, 0x68, 0xf2, 0x11, 0x00, 0x00,
+	// 1759 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x58, 0x4f, 0x6f, 0xdb, 0xc8,
+	0x15, 0x0f, 0x25, 0x4b, 0x16, 0x9f, 0xa4, 0xac, 0x3d, 0x72, 0xb2, 0x8a, 0x62, 0xa7, 0x5e, 0xa6,
+	0xd9, 0xba, 0x48, 0xe0, 0x06, 0xee, 0x1e, 0x76, 0xbb, 0xed, 0x21, 0x71, 0x9c, 0x45, 0xd0, 0x24,
+	0x9b, 0xd2, 0x49, 0xb1, 0x45, 0x81, 0x12, 0x34, 0x39, 0x96, 0xa7, 0xa6, 0x38, 0xdc, 0x99, 0x61,
+	0x6c, 0xef, 0x47, 0x29, 0xd0, 0x43, 0xbf, 0x43, 0x8f, 0x45, 0x2f, 0x45, 0x81, 0x7e, 0x8e, 0x1e,
+	0x7b, 0xe8, 0x67, 0x28, 0xe6, 0x0d, 0x49, 0x0d, 0x45, 0xd9, 0xde, 0xed, 0x62, 0x6f, 0x9c, 0xf7,
+	0x6f, 0xde, 0xfc, 0xde, 0x5f, 0x09, 0xfa, 0xc7, 0x2c, 0xa1, 0x62, 0x37, 0x13, 0x5c, 0x71, 0xd2,
+	0xc3, 0x43, 0x90, 0x1d, 0x79, 0x5f, 0xc2, 0xdd, 0x97, 0x9c, 0x9f, 0xe6, 0xd9, 0x33, 0x26, 0x68,
+	0xa4, 0xb8, 0xb8, 0x38, 0x48, 0x95, 0xb8, 0xf0, 0xe9, 0xd7, 0x39, 0x95, 0x8a, 0x6c, 0x82, 0x1b,
+	0x97, 0x8c, 0xb1, 0xb3, 0xed, 0xec, 0xb8, 0xfe, 0x9c, 0x40, 0x08, 0xac, 0xa4, 0xe1, 0x8c, 0x8e,
+	0x5b, 0xc8, 0xc0, 0x6f, 0xef, 0x00, 0x36, 0x97, 0x1b, 0x94, 0x19, 0x4f, 0x25, 0x25, 0x0f, 0xa0,
+	0x43, 0x35, 0x01, 0xad, 0xf5, 0xf7, 0x3e, 0xd8, 0x2d, 0x5d, 0xd9, 0x35, 0x72, 0x86, 0xeb, 0xfd,
+	0xdd, 0x01, 0xf2, 0x92, 0x49, 0xa5, 0x89, 0x8c, 0xca, 0x6f, 0xe7, 0xcf, 0x6d, 0xe8, 0x66, 0x82,
+	0x1e, 0xb3, 0xf3, 0xc2, 0xa3, 0xe2, 0x44, 0x1e, 0xc1, 0xba, 0x54, 0xa1, 0x50, 0xcf, 0x05, 0x9f,
+	0x3d, 0x67, 0x09, 0x7d, 0xad, 0x9d, 0x6e, 0xa3, 0x48, 0x93, 0x41, 0x76, 0x81, 0xb0, 0x34, 0x4a,
+	0x72, 0xc9, 0xde, 0xd3, 0xc3, 0x92, 0x3b, 0x5e, 0xd9, 0x76, 0x76, 0x7a, 0xfe, 0x12, 0x0e, 0xd9,
+	0x80, 0x4e, 0xc2, 0x66, 0x4c, 0x8d, 0x3b, 0xdb, 0xce, 0xce, 0xd0, 0x37, 0x07, 0xef, 0x97, 0x30,
+	0xaa, 0xf9, 0xff, 0xdd, 0x9e, 0xff, 0xe7, 0x16, 0x74, 0x90, 0x50, 0x61, 0xec, 0xcc, 0x31, 0x26,
+	0x1f, 0xc1, 0x80, 0xc9, 0x60, 0x0e, 0x44, 0x0b, 0x7d, 0xeb, 0x33, 0x59, 0x61, 0x4e, 0x1e, 0x42,
+	0x37, 0x3a, 0xc9, 0xd3, 0x53, 0x39, 0x6e, 0x6f, 0xb7, 0x77, 0xfa, 0x7b, 0xa3, 0xf9, 0x45, 0xfa,
+	0xa1, 0xfb, 0x9a, 0xe7, 0x17, 0x22, 0xe4, 0x53, 0x80, 0x50, 0x29, 0xc1, 0x8e, 0x72, 0x45, 0x25,
+	0xbe, 0xb4, 0xbf, 0x37, 0xb6, 0x14, 0x72, 0x49, 0x9f, 0x54, 0x7c, 0xdf, 0x92, 0x25, 0x9f, 0x41,
+	0x8f, 0x9e, 0x2b, 0x9a, 0xc6, 0x34, 0x1e, 0x77, 0xf0, 0xa2, 0xad, 0x85, 0x17, 0xed, 0x1e, 0x14,
+	0x7c, 0xf3, 0xbe, 0x4a, 0x7c, 0xf2, 0x39, 0x0c, 0x6b, 0x2c, 0xb2, 0x06, 0xed, 0x53, 0x5a, 0x46,
+	0x55, 0x7f, 0x6a, 0x64, 0xdf, 0x87, 0x49, 0x6e, 0x12, 0x6c, 0xe0, 0x9b, 0xc3, 0x2f, 0x5a, 0x9f,
+	0x3a, 0xde, 0x33, 0x70, 0x9f, 0xe7, 0x49, 0x52, 0x29, 0xc6, 0x4c, 0x94, 0x8a, 0x31, 0x13, 0x73,
+	0x94, 0x5b, 0x57, 0xa2, 0xfc, 0x37, 0x07, 0xd6, 0x0f, 0xde, 0xd3, 0x54, 0xbd, 0xe6, 0x8a, 0x1d,
+	0xb3, 0x28, 0x54, 0x8c, 0xa7, 0xe4, 0x11, 0xb8, 0x3c, 0x89, 0x83, 0x2b, 0xc3, 0xd4, 0xe3, 0x49,
+	0xe1, 0xf5, 0x23, 0x70, 0x53, 0x7a, 0x16, 0x5c, 0x79, 0x5d, 0x2f, 0xa5, 0x67, 0x46, 0xfa, 0x3e,
+	0x0c, 0x63, 0x9a, 0x50, 0x45, 0x83, 0x2a, 0x3a, 0x3a, 0x74, 0x03, 0x43, 0xdc, 0x37, 0xe1, 0xf8,
+	0x18, 0x3e, 0xd0, 0x26, 0xb3, 0x50, 0xd0, 0x54, 0x05, 0x59, 0xa8, 0x4e, 0x30, 0x26, 0xae, 0x3f,
+	0x4c, 0xe9, 0xd9, 0x1b, 0xa4, 0xbe, 0x09, 0xd5, 0x89, 0xf7, 0xd7, 0x16, 0xb8, 0x55, 0x30, 0xc9,
+	0x87, 0xb0, 0xaa, 0xaf, 0x0d, 0x58, 0x5c, 0x20, 0xd1, 0xd5, 0xc7, 0x17, 0xb1, 0xae, 0x0a, 0x7e,
+	0x7c, 0x2c, 0xa9, 0x42, 0xf7, 0xda, 0x7e, 0x71, 0xd2, 0x99, 0x25, 0xd9, 0x37, 0xa6, 0x10, 0x56,
+	0x7c, 0xfc, 0xd6, 0x88, 0xcf, 0x14, 0x9b, 0x51, 0xbc, 0xb0, 0xed, 0x9b, 0x03, 0x19, 0x41, 0x87,
+	0x06, 0x2a, 0x9c, 0x62, 0x86, 0xbb, 0xfe, 0x0a, 0x7d, 0x1b, 0x4e, 0xc9, 0x8f, 0xe1, 0xa6, 0xe4,
+	0xb9, 0x88, 0x68, 0x50, 0x5e, 0xdb, 0x45, 0xee, 0xc0, 0x50, 0x9f, 0x9b, 0xcb, 0x3d, 0x68, 0x1f,
+	0xb3, 0x78, 0xbc, 0x8a, 0xc0, 0xac, 0xd5, 0x93, 0xf0, 0x45, 0xec, 0x6b, 0x26, 0xf9, 0x19, 0x40,
+	0x65, 0x29, 0x1e, 0xf7, 0x2e, 0x11, 0x75, 0x4b, 0xbb, 0x31, 0xd9, 0x02, 0x88, 0x58, 0x76, 0x42,
+	0x45, 0xa0, 0x13, 0xc6, 0xc5, 0xe4, 0x70, 0x0d, 0xe5, 0xd7, 0xf4, 0x42, 0xb3, 0x99, 0x0c, 0xa6,
+	0xdf, 0xb0, 0x2c, 0xa3, 0xf1, 0x18, 0x10, 0x61, 0x97, 0xc9, 0x2f, 0x0c, 0xc1, 0xfb, 0x0a, 0xba,
+	0x85, 0x73, 0x77, 0xc1, 0x7d, 0xcf, 0x93, 0x7c, 0x56, 0x81, 0x36, 0xf4, 0x7b, 0x86, 0xf0, 0x22,
+	0x26, 0x77, 0x00, 0xbb, 0x24, 0x5e, 0xd1, 0x42, 0x88, 0x10, 0x5f, 0x7d, 0xc1, 0x6d, 0xe8, 0x46,
+	0x9c, 0x9f, 0x32, 0x83, 0xdd, 0xaa, 0x5f, 0x9c, 0xbc, 0xff, 0xb6, 0xe0, 0x66, 0xbd, 0x58, 0xf4,
+	0x15, 0x68, 0x05, 0x91, 0x76, 0xd0, 0x0c, 0x9a, 0x3d, 0xac, 0xa1, 0xdd, 0xb2, 0xd1, 0x2e, 0x55,
+	0x66, 0x3c, 0x36, 0x17, 0x0c, 0x8d, 0xca, 0x2b, 0x1e, 0x53, 0x9d, 0xeb, 0x39, 0x8b, 0x31, 0x3c,
+	0x43, 0x5f, 0x7f, 0x6a, 0xca, 0x94, 0xc5, 0x45, 0xf3, 0xd1, 0x9f, 0xe8, 0x9e, 0x40, 0xbb, 0x5d,
+	0x13, 0x70, 0x73, 0xd2, 0x01, 0x9f, 0x69, 0xea, 0xaa, 0x89, 0xa2, 0xfe, 0x26, 0xdb, 0xd0, 0x17,
+	0x34, 0x4b, 0x8a, 0xdc, 0x47, 0xf0, 0x5d, 0xdf, 0x26, 0x91, 0x7b, 0x00, 0x11, 0x4f, 0x12, 0x1a,
+	0xa1, 0x80, 0x8b, 0x02, 0x16, 0x45, 0xe7, 0x9d, 0x52, 0x49, 0x20, 0x69, 0x84, 0x50, 0x77, 0xfc,
+	0xae, 0x52, 0xc9, 0x21, 0x8d, 0xf4, 0x3b, 0x72, 0x49, 0x45, 0x80, 0xed, 0xab, 0x8f, 0x7a, 0x3d,
+	0x4d, 0xc0, 0x26, 0xbb, 0x05, 0x30, 0x15, 0x3c, 0xcf, 0x0c, 0x77, 0xb0, 0xdd, 0xd6, 0x9d, 0x1c,
+	0x29, 0xc8, 0x7e, 0x00, 0x37, 0xe5, 0xc5, 0x2c, 0x61, 0xe9, 0x69, 0xa0, 0x42, 0x31, 0xa5, 0x6a,
+	0x3c, 0x34, 0x15, 0x50, 0x50, 0xdf, 0x22, 0xd1, 0xcb, 0x80, 0xec, 0x0b, 0x1a, 0x2a, 0xfa, 0x1d,
+	0x86, 0xd6, 0xb7, 0xeb, 0x0d, 0xe4, 0x16, 0x74, 0x79, 0x40, 0xcf, 0xa3, 0xa4, 0x28, 0xd1, 0x0e,
+	0x3f, 0x38, 0x8f, 0x12, 0xef, 0x21, 0x8c, 0x6a, 0x37, 0x16, 0x6d, 0x7d, 0x03, 0x3a, 0x54, 0x08,
+	0x5e, 0x36, 0x21, 0x73, 0xf0, 0x7e, 0x07, 0xe4, 0x5d, 0x16, 0xff, 0x10, 0xee, 0x79, 0xb7, 0x60,
+	0x54, 0x33, 0x6d, 0xfc, 0xf0, 0xfe, 0xe9, 0x00, 0x79, 0x86, 0xbd, 0xe4, 0xfb, 0x8d, 0x71, 0x5d,
+	0xdd, 0x7a, 0xc4, 0x98, 0x5e, 0x15, 0x87, 0x2a, 0x2c, 0x06, 0xe0, 0x80, 0x49, 0x63, 0xff, 0x59,
+	0xa8, 0xc2, 0x62, 0x10, 0x09, 0x1a, 0xe5, 0x42, 0xcf, 0x44, 0x4c, 0x42, 0x1c, 0x44, 0x7e, 0x49,
+	0x22, 0x9f, 0xc0, 0x6d, 0x36, 0x4d, 0xb9, 0xa0, 0x73, 0xb1, 0xc0, 0x40, 0xd5, 0x45, 0xe1, 0x0d,
+	0xc3, 0xad, 0x14, 0x0e, 0x10, 0xb9, 0x87, 0x30, 0xaa, 0x3d, 0xe3, 0x4a, 0x98, 0xff, 0xe4, 0xc0,
+	0xf8, 0x89, 0xe2, 0x33, 0x16, 0xf9, 0x54, 0x3b, 0x5f, 0x7b, 0xfa, 0x7d, 0x18, 0xea, 0x6e, 0xbe,
+	0xf8, 0xfc, 0x01, 0x4f, 0xe2, 0xf9, 0xb4, 0xbc, 0x03, 0xba, 0xa1, 0x07, 0x16, 0x0a, 0xab, 0x3c,
+	0x89, 0x31, 0x13, 0xef, 0x83, 0xee, 0xba, 0x96, 0xbe, 0xd9, 0x1b, 0x06, 0x29, 0x3d, 0xab, 0xe9,
+	0x6b, 0x21, 0xd4, 0x37, 0xad, 0x7a, 0x35, 0xa5, 0x67, 0x5a, 0xdf, 0xbb, 0x0b, 0x77, 0x96, 0xf8,
+	0x56, 0x84, 0xeb, 0x5f, 0x0e, 0x8c, 0x9e, 0x48, 0xc9, 0xa6, 0xe9, 0x6f, 0xb1, 0xed, 0x94, 0x4e,
+	0x6f, 0x40, 0x27, 0xe2, 0x79, 0xaa, 0xd0, 0xd9, 0x8e, 0x6f, 0x0e, 0x0b, 0x95, 0xd8, 0x6a, 0x54,
+	0xe2, 0x42, 0x2d, 0xb7, 0x9b, 0xb5, 0x6c, 0xd5, 0xea, 0x4a, 0xad, 0x56, 0x7f, 0x04, 0x7d, 0x1d,
+	0xe4, 0x20, 0xa2, 0xa9, 0xa2, 0xa2, 0xe8, 0xf3, 0xa0, 0x49, 0xfb, 0x48, 0xd1, 0x02, 0xf6, 0x3c,
+	0x32, 0xad, 0x1e, 0xb2, 0xf9, 0x30, 0xfa, 0xb7, 0x03, 0x1b, 0xf5, 0xa7, 0x14, 0x31, 0xbb, 0x74,
+	0x2e, 0xe9, 0x56, 0x26, 0x92, 0xe2, 0x1d, 0xfa, 0x53, 0x37, 0x85, 0x2c, 0x3f, 0x4a, 0x58, 0x14,
+	0x68, 0x86, 0xf1, 0xdf, 0x35, 0x94, 0x77, 0x22, 0x99, 0xa3, 0xb2, 0x62, 0xa3, 0x42, 0x60, 0x25,
+	0xcc, 0xd5, 0x49, 0x39, 0x9b, 0xf4, 0xf7, 0x02, 0x52, 0xdd, 0xeb, 0x90, 0x5a, 0x6d, 0x22, 0x55,
+	0x65, 0x5a, 0xcf, 0xce, 0xb4, 0x4f, 0x60, 0x64, 0x96, 0xdb, 0x7a, 0xb8, 0xb6, 0x00, 0xaa, 0x39,
+	0x22, 0xc7, 0x8e, 0x69, 0x66, 0xe5, 0x20, 0x91, 0xde, 0xaf, 0xc0, 0x7d, 0xc9, 0x8d, 0x5d, 0x49,
+	0x1e, 0x83, 0x9b, 0x94, 0x07, 0x14, 0xed, 0xef, 0x91, 0x79, 0x8d, 0x97, 0x72, 0xfe, 0x5c, 0xc8,
+	0xfb, 0x1c, 0x7a, 0x25, 0xb9, 0xc4, 0xcc, 0xb9, 0x0c, 0xb3, 0xd6, 0x02, 0x66, 0xde, 0x3f, 0x1c,
+	0xd8, 0xa8, 0xbb, 0x5c, 0x84, 0xe5, 0x1d, 0x0c, 0xab, 0x2b, 0x82, 0x59, 0x98, 0x15, 0xbe, 0x3c,
+	0xb6, 0x7d, 0x69, 0xaa, 0x55, 0x0e, 0xca, 0x57, 0x61, 0x66, 0x72, 0x79, 0x90, 0x58, 0xa4, 0xc9,
+	0x5b, 0x58, 0x6f, 0x88, 0x2c, 0xd9, 0xec, 0x7e, 0x6a, 0x6f, 0x76, 0xb5, 0xed, 0xb4, 0xd2, 0xb6,
+	0xd7, 0xbd, 0xcf, 0xe0, 0x43, 0xd3, 0x0e, 0xf6, 0xab, 0x18, 0x96, 0xd8, 0xd7, 0x43, 0xed, 0x2c,
+	0x86, 0xda, 0x9b, 0xc0, 0xb8, 0xa9, 0x5a, 0x94, 0xdf, 0x14, 0xd6, 0x0f, 0x55, 0xa8, 0x98, 0x54,
+	0x2c, 0xaa, 0x7e, 0x62, 0x2c, 0xe4, 0x86, 0x73, 0xdd, 0x44, 0x6c, 0xd6, 0xe1, 0x1a, 0xb4, 0x95,
+	0x2a, 0xf3, 0x57, 0x7f, 0xea, 0x28, 0x10, 0xfb, 0xa6, 0x22, 0x06, 0x3f, 0xc0, 0x55, 0x3a, 0x1f,
+	0x14, 0x57, 0x61, 0x62, 0x36, 0x8e, 0x15, 0xdc, 0x38, 0x5c, 0xa4, 0xe0, 0xca, 0x61, 0x86, 0x72,
+	0x6c, 0xb8, 0x1d, 0xb3, 0x8f, 0x68, 0x02, 0x32, 0xb7, 0x00, 0xb0, 0x54, 0x4d, 0x95, 0x75, 0x8d,
+	0xae, 0xa6, 0xec, 0x6b, 0x82, 0x77, 0x0f, 0x36, 0xbf, 0xa0, 0x4a, 0xef, 0x4e, 0x62, 0x9f, 0xa7,
+	0xc7, 0x6c, 0x9a, 0x8b, 0xd0, 0x0a, 0x85, 0xf7, 0x1f, 0x07, 0xb6, 0x2e, 0x11, 0x28, 0x1e, 0x3c,
+	0x86, 0xd5, 0x59, 0x28, 0x15, 0x15, 0x65, 0x95, 0x94, 0xc7, 0x45, 0x28, 0x5a, 0xd7, 0x41, 0xd1,
+	0x6e, 0x40, 0x71, 0x0b, 0xba, 0xb3, 0xf0, 0x3c, 0x98, 0x1d, 0x15, 0xcb, 0x51, 0x67, 0x16, 0x9e,
+	0xbf, 0x3a, 0xc2, 0xce, 0xc6, 0x44, 0x70, 0x94, 0x47, 0xa7, 0x54, 0xc9, 0xaa, 0xb3, 0x31, 0xf1,
+	0xd4, 0x50, 0xf4, 0xa3, 0xb5, 0xc0, 0xd7, 0x39, 0xcd, 0xa9, 0x2c, 0x7a, 0x85, 0x1e, 0x8e, 0xbf,
+	0x41, 0x02, 0x2e, 0x53, 0xb8, 0x59, 0x62, 0x97, 0xe8, 0xf9, 0xc5, 0x69, 0xef, 0x2f, 0x3d, 0x18,
+	0x1c, 0xd2, 0xf0, 0x8c, 0xd2, 0x18, 0x1f, 0x4c, 0xa6, 0x65, 0xa1, 0xd5, 0x7f, 0xf8, 0x92, 0x07,
+	0x8b, 0x15, 0xb5, 0xf4, 0x97, 0xf6, 0xe4, 0xe3, 0xeb, 0xc4, 0x8a, 0x9c, 0xbd, 0x41, 0x5e, 0x43,
+	0xdf, 0xfa, 0x65, 0x49, 0x36, 0x2d, 0xc5, 0xc6, 0x0f, 0xe6, 0xc9, 0xd6, 0x25, 0xdc, 0xd2, 0xda,
+	0x63, 0x87, 0xbc, 0x84, 0xbe, 0xb5, 0xd2, 0xd8, 0xf6, 0x9a, 0xbb, 0x95, 0x6d, 0x6f, 0xc9, 0x1e,
+	0xe4, 0xdd, 0xd0, 0xd6, 0xac, 0xc5, 0xc4, 0xb6, 0xd6, 0x5c, 0x85, 0x6c, 0x6b, 0xcb, 0xb6, 0x19,
+	0xb4, 0x66, 0xed, 0x01, 0xb6, 0xb5, 0xe6, 0x96, 0x63, 0x5b, 0x5b, 0xb2, 0x3c, 0x78, 0x37, 0xc8,
+	0x57, 0x30, 0x3a, 0x54, 0x82, 0x86, 0xb3, 0x39, 0x7b, 0x01, 0xc1, 0xff, 0xc3, 0xea, 0x8e, 0xf3,
+	0xd8, 0x21, 0x7f, 0x80, 0xf5, 0xc6, 0x94, 0x27, 0xde, 0x5c, 0xf3, 0xb2, 0xf5, 0x64, 0x72, 0xff,
+	0x4a, 0x99, 0xca, 0xf3, 0x2f, 0x61, 0x60, 0x0f, 0x57, 0x62, 0x39, 0xb5, 0x64, 0x7f, 0x98, 0xdc,
+	0xbb, 0x8c, 0x6d, 0x1b, 0xb4, 0xfb, 0xbb, 0x6d, 0x70, 0xc9, 0x84, 0xb3, 0x0d, 0x2e, 0x1b, 0x0b,
+	0xde, 0x0d, 0xf2, 0x7b, 0x58, 0x5b, 0xec, 0xb3, 0xe4, 0xa3, 0x45, 0xe8, 0x1a, 0xed, 0x7b, 0xe2,
+	0x5d, 0x25, 0x52, 0x19, 0x7f, 0x01, 0x30, 0x6f, 0x9f, 0xe4, 0xee, 0x5c, 0xa7, 0xd1, 0xbe, 0x27,
+	0x9b, 0xcb, 0x99, 0x95, 0xa9, 0x3f, 0xc2, 0xad, 0xa5, 0x3d, 0x8a, 0x58, 0x05, 0x78, 0x55, 0x97,
+	0x9b, 0xfc, 0xe4, 0x5a, 0xb9, 0xf2, 0xae, 0xa7, 0xf7, 0x60, 0x4d, 0x9a, 0x16, 0x71, 0x2c, 0x77,
+	0xa3, 0x84, 0xd1, 0x54, 0x3d, 0x05, 0xd4, 0x78, 0x23, 0xb8, 0xe2, 0x47, 0x5d, 0xfc, 0x37, 0xee,
+	0xe7, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x35, 0x0b, 0x9e, 0x2e, 0x9c, 0x13, 0x00, 0x00,
 }
diff --git a/weed/pb/filer_pb/filer_pb_helper.go b/weed/pb/filer_pb/filer_pb_helper.go
index 5c40332e6..96ab2154f 100644
--- a/weed/pb/filer_pb/filer_pb_helper.go
+++ b/weed/pb/filer_pb/filer_pb_helper.go
@@ -1,6 +1,12 @@
 package filer_pb
 
 import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/chrislusf/seaweedfs/weed/glog"
 	"github.com/chrislusf/seaweedfs/weed/storage/needle"
 )
 
@@ -67,3 +73,33 @@ func AfterEntryDeserialization(chunks []*FileChunk) {
 
 	}
 }
+
+func CreateEntry(client SeaweedFilerClient, request *CreateEntryRequest) error {
+	resp, err := client.CreateEntry(context.Background(), request)
+	if err != nil {
+		glog.V(1).Infof("create entry %s/%s %v: %v", request.Directory, request.Entry.Name, request.OExcl, err)
+		return fmt.Errorf("CreateEntry: %v", err)
+	}
+	if resp.Error != "" {
+		glog.V(1).Infof("create entry %s/%s %v: %v", request.Directory, request.Entry.Name, request.OExcl, err)
+		return fmt.Errorf("CreateEntry : %v", resp.Error)
+	}
+	return nil
+}
+
+func LookupEntry(client SeaweedFilerClient, request *LookupDirectoryEntryRequest) (*LookupDirectoryEntryResponse, error) {
+	resp, err := client.LookupDirectoryEntry(context.Background(), request)
+	if err != nil {
+		if err == ErrNotFound || strings.Contains(err.Error(), ErrNotFound.Error()) {
+			return nil, ErrNotFound
+		}
+		glog.V(3).Infof("read %s/%v: %v", request.Directory, request.Name, err)
+		return nil, fmt.Errorf("LookupEntry1: %v", err)
+	}
+	if resp.Entry == nil {
+		return nil, ErrNotFound
+	}
+	return resp, nil
+}
+
+var ErrNotFound = errors.New("filer: no entry is found in filer store")
diff --git a/weed/pb/grpc_client_server.go b/weed/pb/grpc_client_server.go
new file mode 100644
index 000000000..4b5f9eff3
--- /dev/null
+++ b/weed/pb/grpc_client_server.go
@@ -0,0 +1,182 @@
+package pb
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/keepalive"
+
+	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
+	"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
+)
+
+var (
+	// cache grpc connections
+	grpcClients     = make(map[string]*grpc.ClientConn)
+	grpcClientsLock sync.Mutex
+)
+
+func init() {
+	http.DefaultTransport.(*http.Transport).MaxIdleConnsPerHost = 1024
+}
+
+func NewGrpcServer(opts ...grpc.ServerOption) *grpc.Server {
+	var options []grpc.ServerOption
+	options = append(options, grpc.KeepaliveParams(keepalive.ServerParameters{
+		Time:    10 * time.Second, // wait time before ping if no activity
+		Timeout: 20 * time.Second, // ping timeout
+	}), grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
+		MinTime:             60 * time.Second, // min time a client should wait before sending a ping
+		PermitWithoutStream: true,
+	}))
+	for _, opt := range opts {
+		if opt != nil {
+			options = append(options, opt)
+		}
+	}
+	return grpc.NewServer(options...)
+}
+
+func GrpcDial(ctx context.Context, address string, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
+	// opts = append(opts, grpc.WithBlock())
+	// opts = append(opts, grpc.WithTimeout(time.Duration(5*time.Second)))
+	var options []grpc.DialOption
+	options = append(options,
+		// grpc.WithInsecure(),
+		grpc.WithKeepaliveParams(keepalive.ClientParameters{
+			Time:                30 * time.Second, // client ping server if no activity for this long
+			Timeout:             20 * time.Second,
+			PermitWithoutStream: true,
+		}))
+	for _, opt := range opts {
+		if opt != nil {
+			options = append(options, opt)
+		}
+	}
+	return grpc.DialContext(ctx, address, options...)
+}
+
+func WithCachedGrpcClient(fn func(*grpc.ClientConn) error, address string, opts ...grpc.DialOption) error {
+
+	grpcClientsLock.Lock()
+
+	existingConnection, found := grpcClients[address]
+	if found {
+		grpcClientsLock.Unlock()
+		err := fn(existingConnection)
+		if err != nil {
+			grpcClientsLock.Lock()
+			delete(grpcClients, address)
+			grpcClientsLock.Unlock()
+			existingConnection.Close()
+		}
+		return err
+	}
+
+	grpcConnection, err := GrpcDial(context.Background(), address, opts...)
+	if err != nil {
+		grpcClientsLock.Unlock()
+		return fmt.Errorf("fail to dial %s: %v", address, err)
+	}
+
+	grpcClients[address] = grpcConnection
+	grpcClientsLock.Unlock()
+
+	err = fn(grpcConnection)
+	if err != nil {
+		grpcClientsLock.Lock()
+		delete(grpcClients, address)
+		grpcClientsLock.Unlock()
+		grpcConnection.Close()
+	}
+
+	return err
+}
+
+func ParseServerToGrpcAddress(server string) (serverGrpcAddress string, err error) {
+	colonIndex := strings.LastIndex(server, ":")
+	if colonIndex < 0 {
+		return "", fmt.Errorf("server should have hostname:port format: %v", server)
+	}
+
+	port, parseErr := strconv.ParseUint(server[colonIndex+1:], 10, 64)
+	if parseErr != nil {
+		return "", fmt.Errorf("server port parse error: %v", parseErr)
+	}
+
+	grpcPort := int(port) + 10000
+
+	return fmt.Sprintf("%s:%d", server[:colonIndex], grpcPort), nil
+}
+
+func ServerToGrpcAddress(server string) (serverGrpcAddress string) {
+	hostnameAndPort := strings.Split(server, ":")
+	if len(hostnameAndPort) != 2 {
+		return fmt.Sprintf("unexpected server address: %s", server)
+	}
+
+	port, parseErr := strconv.ParseUint(hostnameAndPort[1], 10, 64)
+	if parseErr != nil {
+		return fmt.Sprintf("failed to parse port for %s:%s", hostnameAndPort[0], hostnameAndPort[1])
+	}
+
+	grpcPort := int(port) + 10000
+
+	return fmt.Sprintf("%s:%d", hostnameAndPort[0], grpcPort)
+}
+
+func WithMasterClient(master string, grpcDialOption grpc.DialOption, fn func(client master_pb.SeaweedClient) error) error {
+
+	masterGrpcAddress, parseErr := ParseServerToGrpcAddress(master)
+	if parseErr != nil {
+		return fmt.Errorf("failed to parse master grpc %v: %v", master, parseErr)
+	}
+
+	return WithCachedGrpcClient(func(grpcConnection *grpc.ClientConn) error {
+		client := master_pb.NewSeaweedClient(grpcConnection)
+		return fn(client)
+	}, masterGrpcAddress, grpcDialOption)
+
+}
+
+func WithFilerClient(filer string, grpcDialOption grpc.DialOption, fn func(client filer_pb.SeaweedFilerClient) error) error {
+
+	filerGrpcAddress, parseErr := ParseServerToGrpcAddress(filer)
+	if parseErr != nil {
+		return fmt.Errorf("failed to parse filer grpc %v: %v", filer, parseErr)
+	}
+
+	return WithGrpcFilerClient(filerGrpcAddress, grpcDialOption, fn)
+
+}
+
+func WithGrpcFilerClient(filerGrpcAddress string, grpcDialOption grpc.DialOption, fn func(client filer_pb.SeaweedFilerClient) error) error {
+
+	return WithCachedGrpcClient(func(grpcConnection *grpc.ClientConn) error {
+		client := filer_pb.NewSeaweedFilerClient(grpcConnection)
+		return fn(client)
+	}, filerGrpcAddress, grpcDialOption)
+
+}
+
+func ParseFilerGrpcAddress(filer string) (filerGrpcAddress string, err error) {
+	hostnameAndPort := strings.Split(filer, ":")
+	if len(hostnameAndPort) != 2 {
+		return "", fmt.Errorf("filer should have hostname:port format: %v", hostnameAndPort)
+	}
+
+	filerPort, parseErr := strconv.ParseUint(hostnameAndPort[1], 10, 64)
+	if parseErr != nil {
+		return "", fmt.Errorf("filer port parse error: %v", parseErr)
+	}
+
+	filerGrpcPort := int(filerPort) + 10000
+
+	return fmt.Sprintf("%s:%d", hostnameAndPort[0], filerGrpcPort), nil
+}
diff --git a/weed/pb/iam.proto b/weed/pb/iam.proto
new file mode 100644
index 000000000..2eef22dd9
--- /dev/null
+++ b/weed/pb/iam.proto
@@ -0,0 +1,50 @@
+syntax = "proto3";
+
+package iam_pb;
+
+option java_package = "seaweedfs.client";
+option java_outer_classname = "IamProto";
+
+//////////////////////////////////////////////////
+
+service SeaweedIdentityAccessManagement {
+
+}
+
+//////////////////////////////////////////////////
+
+message S3ApiConfiguration {
+    repeated Identity identities = 1;
+}
+
+message Identity {
+    string name = 1;
+    repeated Credential credentials = 2;
+    repeated string actions = 3;
+}
+
+message Credential {
+    string access_key = 1;
+    string secret_key = 2;
+    // uint64 expiration = 3;
+    // bool is_disabled = 4;
+}
+
+/*
+message Policy {
+    repeated Statement statements = 1;
+}
+
+message Statement {
+    repeated Action action = 1;
+    repeated Resource resource = 2;
+}
+
+message Action {
+    string action = 1;
+}
+message Resource {
+    string bucket = 1;
+    // string path = 2;
+}
+*/
\ No newline at end of file
diff --git a/weed/pb/iam_pb/iam.pb.go b/weed/pb/iam_pb/iam.pb.go
new file mode 100644
index 000000000..b7d7b038b
--- /dev/null
+++ b/weed/pb/iam_pb/iam.pb.go
@@ -0,0 +1,174 @@
+// Code generated by protoc-gen-go.
+// source: iam.proto
+// DO NOT EDIT!
+
+/*
+Package iam_pb is a generated protocol buffer package.
+
+It is generated from these files:
+	iam.proto
+
+It has these top-level messages:
+	S3ApiConfiguration
+	Identity
+	Credential
+*/
+package iam_pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type S3ApiConfiguration struct {
+	Identities []*Identity `protobuf:"bytes,1,rep,name=identities" json:"identities,omitempty"`
+}
+
+func (m *S3ApiConfiguration) Reset()                    { *m = S3ApiConfiguration{} }
+func (m *S3ApiConfiguration) String() string            { return proto.CompactTextString(m) }
+func (*S3ApiConfiguration) ProtoMessage()               {}
+func (*S3ApiConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *S3ApiConfiguration) GetIdentities() []*Identity {
+	if m != nil {
+		return m.Identities
+	}
+	return nil
+}
+
+type Identity struct {
+	Name        string        `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Credentials []*Credential `protobuf:"bytes,2,rep,name=credentials" json:"credentials,omitempty"`
+	Actions     []string      `protobuf:"bytes,3,rep,name=actions" json:"actions,omitempty"`
+}
+
+func (m *Identity) Reset()                    { *m = Identity{} }
+func (m *Identity) String() string            { return proto.CompactTextString(m) }
+func (*Identity) ProtoMessage()               {}
+func (*Identity) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *Identity) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Identity) GetCredentials() []*Credential {
+	if m != nil {
+		return m.Credentials
+	}
+	return nil
+}
+
+func (m *Identity) GetActions() []string {
+	if m != nil {
+		return m.Actions
+	}
+	return nil
+}
+
+type Credential struct {
+	AccessKey string `protobuf:"bytes,1,opt,name=access_key,json=accessKey" json:"access_key,omitempty"`
+	SecretKey string `protobuf:"bytes,2,opt,name=secret_key,json=secretKey" json:"secret_key,omitempty"`
+}
+
+func (m *Credential) Reset()                    { *m = Credential{} }
+func (m *Credential) String() string            { return proto.CompactTextString(m) }
+func (*Credential) ProtoMessage()               {}
+func (*Credential) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *Credential) GetAccessKey() string {
+	if m != nil {
+		return m.AccessKey
+	}
+	return ""
+}
+
+func (m *Credential) GetSecretKey() string {
+	if m != nil {
+		return m.SecretKey
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*S3ApiConfiguration)(nil), "iam_pb.S3ApiConfiguration")
+	proto.RegisterType((*Identity)(nil), "iam_pb.Identity")
+	proto.RegisterType((*Credential)(nil), "iam_pb.Credential")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for SeaweedIdentityAccessManagement service
+
+type SeaweedIdentityAccessManagementClient interface {
+}
+
+type seaweedIdentityAccessManagementClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewSeaweedIdentityAccessManagementClient(cc *grpc.ClientConn) SeaweedIdentityAccessManagementClient {
+	return &seaweedIdentityAccessManagementClient{cc}
+}
+
+// Server API for SeaweedIdentityAccessManagement service
+
+type SeaweedIdentityAccessManagementServer interface {
+}
+
+func RegisterSeaweedIdentityAccessManagementServer(s *grpc.Server, srv SeaweedIdentityAccessManagementServer) {
+	s.RegisterService(&_SeaweedIdentityAccessManagement_serviceDesc, srv)
+}
+
+var _SeaweedIdentityAccessManagement_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "iam_pb.SeaweedIdentityAccessManagement",
+	HandlerType: (*SeaweedIdentityAccessManagementServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams:     []grpc.StreamDesc{},
+	Metadata:    "iam.proto",
+}
+
+func init() { proto.RegisterFile("iam.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 250 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x4c, 0x90, 0x41, 0x4b, 0xc3, 0x40,
+	0x10, 0x85, 0x69, 0x23, 0xb5, 0x99, 0x5e, 0xca, 0x9c, 0xf6, 0xa0, 0x18, 0x73, 0xca, 0x29, 0x48,
+	0xeb, 0x1f, 0xa8, 0x05, 0xa1, 0x16, 0x41, 0xd2, 0x1f, 0x50, 0xa6, 0xdb, 0x69, 0x19, 0xec, 0x6e,
+	0x42, 0x76, 0x45, 0xf2, 0xef, 0x25, 0xbb, 0x46, 0x7b, 0xdb, 0x7d, 0xdf, 0x7b, 0xb3, 0x3b, 0x0f,
+	0x52, 0x21, 0x53, 0x36, 0x6d, 0xed, 0x6b, 0x9c, 0x08, 0x99, 0x7d, 0x73, 0xc8, 0x5f, 0x01, 0x77,
+	0xcb, 0x55, 0x23, 0xeb, 0xda, 0x9e, 0xe4, 0xfc, 0xd5, 0x92, 0x97, 0xda, 0xe2, 0x13, 0x80, 0x1c,
+	0xd9, 0x7a, 0xf1, 0xc2, 0x4e, 0x8d, 0xb2, 0xa4, 0x98, 0x2d, 0xe6, 0x65, 0x8c, 0x94, 0x9b, 0x48,
+	0xba, 0xea, 0xca, 0x93, 0x5b, 0x98, 0x0e, 0x3a, 0x22, 0xdc, 0x58, 0x32, 0xac, 0x46, 0xd9, 0xa8,
+	0x48, 0xab, 0x70, 0xc6, 0x67, 0x98, 0xe9, 0x96, 0x83, 0x83, 0x2e, 0x4e, 0x8d, 0xc3, 0x48, 0x1c,
+	0x46, 0xae, 0xff, 0x50, 0x75, 0x6d, 0x43, 0x05, 0xb7, 0xa4, 0xfb, 0x1f, 0x39, 0x95, 0x64, 0x49,
+	0x91, 0x56, 0xc3, 0x35, 0x7f, 0x03, 0xf8, 0x0f, 0xe1, 0x3d, 0x00, 0x69, 0xcd, 0xce, 0xed, 0x3f,
+	0xb9, 0xfb, 0x7d, 0x37, 0x8d, 0xca, 0x96, 0xbb, 0x1e, 0x3b, 0xd6, 0x2d, 0xfb, 0x80, 0xc7, 0x11,
+	0x47, 0x65, 0xcb, 0xdd, 0xe2, 0x11, 0x1e, 0x76, 0x4c, 0xdf, 0xcc, 0xc7, 0x61, 0x85, 0x55, 0x88,
+	0xbe, 0x93, 0xa5, 0x33, 0x1b, 0xb6, 0xfe, 0xe5, 0x0e, 0xe6, 0x2e, 0x5a, 0x4e, 0xae, 0xd4, 0x17,
+	0xe9, 0xb5, 0xe9, 0x86, 0xcc, 0x47, 0x5f, 0xe6, 0x61, 0x12, 0x3a, 0x5d, 0xfe, 0x04, 0x00, 0x00,
+	0xff, 0xff, 0x83, 0x4f, 0x61, 0x03, 0x60, 0x01, 0x00, 0x00,
+}
diff --git a/weed/pb/master.proto b/weed/pb/master.proto
index f03b3a9ab..4310b2602 100644
--- a/weed/pb/master.proto
+++ b/weed/pb/master.proto
@@ -25,6 +25,8 @@ service Seaweed {
     }
     rpc GetMasterConfiguration (GetMasterConfigurationRequest) returns (GetMasterConfigurationResponse) {
     }
+    rpc ListMasterClients (ListMasterClientsRequest) returns (ListMasterClientsResponse) {
+    }
 }
 
 //////////////////////////////////////////////////
@@ -58,6 +60,7 @@ message HeartbeatResponse {
     string leader = 2;
     string metrics_address = 3;
     uint32 metrics_interval_seconds = 4;
+    repeated StorageBackend storage_backends = 5;
 }
 
 message VolumeInformationMessage {
@@ -73,6 +76,8 @@ message VolumeInformationMessage {
     uint32 ttl = 10;
     uint32 compact_revision = 11;
     int64 modified_at_second = 12;
+    string remote_storage_name = 13;
+    string remote_storage_key = 14;
 }
 
 message VolumeShortInformationMessage {
@@ -89,6 +94,12 @@ message VolumeEcShardInformationMessage {
     uint32 ec_index_bits = 3;
 }
 
+message StorageBackend {
+    string type = 1;
+    string id = 2;
+    map<string, string> properties = 3;
+}
+
 message Empty {
 }
 
@@ -103,6 +114,7 @@ message SuperBlockExtra {
 
 message KeepConnectedRequest {
     string name = 1;
+    uint32 grpc_port = 2;
 }
 
 message VolumeLocation {
@@ -201,6 +213,7 @@ message DataNodeInfo {
     uint64 active_volume_count = 5;
     repeated VolumeInformationMessage volume_infos = 6;
     repeated VolumeEcShardInformationMessage ec_shard_infos = 7;
+    uint64 remote_volume_count = 8;
 }
 message RackInfo {
     string id = 1;
@@ -209,6 +222,7 @@ message RackInfo {
     uint64 free_volume_count = 4;
     uint64 active_volume_count = 5;
     repeated DataNodeInfo data_node_infos = 6;
+    uint64 remote_volume_count = 7;
 }
 message DataCenterInfo {
     string id = 1;
@@ -217,6 +231,7 @@ message DataCenterInfo {
     uint64 free_volume_count = 4;
     uint64 active_volume_count = 5;
     repeated RackInfo rack_infos = 6;
+    uint64 remote_volume_count = 7;
 }
 message TopologyInfo {
     string id = 1;
@@ -225,6 +240,7 @@ message TopologyInfo {
     uint64 free_volume_count = 4;
     uint64 active_volume_count = 5;
     repeated DataCenterInfo data_center_infos = 6;
+    uint64 remote_volume_count = 7;
 }
 message VolumeListRequest {
 }
@@ -251,3 +267,10 @@ message GetMasterConfigurationResponse {
     string metrics_address = 1;
     uint32 metrics_interval_seconds = 2;
 }
+
+message ListMasterClientsRequest {
+    string client_type = 1;
+}
+message ListMasterClientsResponse {
+    repeated string grpc_addresses = 1;
+}
diff --git a/weed/pb/master_pb/master.pb.go b/weed/pb/master_pb/master.pb.go
index e9fe8164c..c33e2b768 100644
--- a/weed/pb/master_pb/master.pb.go
+++ b/weed/pb/master_pb/master.pb.go
@@ -14,6 +14,7 @@ It has these top-level messages:
 	VolumeInformationMessage
 	VolumeShortInformationMessage
 	VolumeEcShardInformationMessage
+	StorageBackend
 	Empty
 	SuperBlockExtra
 	KeepConnectedRequest
@@ -41,6 +42,8 @@ It has these top-level messages:
 	LookupEcVolumeResponse
 	GetMasterConfigurationRequest
 	GetMasterConfigurationResponse
+	ListMasterClientsRequest
+	ListMasterClientsResponse
 */
 package master_pb
 
@@ -204,10 +207,11 @@ func (m *Heartbeat) GetHasNoEcShards() bool {
 }
 
 type HeartbeatResponse struct {
-	VolumeSizeLimit        uint64 `protobuf:"varint,1,opt,name=volume_size_limit,json=volumeSizeLimit" json:"volume_size_limit,omitempty"`
-	Leader                 string `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"`
-	MetricsAddress         string `protobuf:"bytes,3,opt,name=metrics_address,json=metricsAddress" json:"metrics_address,omitempty"`
-	MetricsIntervalSeconds uint32 `protobuf:"varint,4,opt,name=metrics_interval_seconds,json=metricsIntervalSeconds" json:"metrics_interval_seconds,omitempty"`
+	VolumeSizeLimit        uint64            `protobuf:"varint,1,opt,name=volume_size_limit,json=volumeSizeLimit" json:"volume_size_limit,omitempty"`
+	Leader                 string            `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"`
+	MetricsAddress         string            `protobuf:"bytes,3,opt,name=metrics_address,json=metricsAddress" json:"metrics_address,omitempty"`
+	MetricsIntervalSeconds uint32            `protobuf:"varint,4,opt,name=metrics_interval_seconds,json=metricsIntervalSeconds" json:"metrics_interval_seconds,omitempty"`
+	StorageBackends        []*StorageBackend `protobuf:"bytes,5,rep,name=storage_backends,json=storageBackends" json:"storage_backends,omitempty"`
 }
 
 func (m *HeartbeatResponse) Reset()                    { *m = HeartbeatResponse{} }
@@ -243,19 +247,28 @@ func (m *HeartbeatResponse) GetMetricsIntervalSeconds() uint32 {
 	return 0
 }
 
+func (m *HeartbeatResponse) GetStorageBackends() []*StorageBackend {
+	if m != nil {
+		return m.StorageBackends
+	}
+	return nil
+}
+
 type VolumeInformationMessage struct {
-	Id               uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
-	Size             uint64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
-	Collection       string `protobuf:"bytes,3,opt,name=collection" json:"collection,omitempty"`
-	FileCount        uint64 `protobuf:"varint,4,opt,name=file_count,json=fileCount" json:"file_count,omitempty"`
-	DeleteCount      uint64 `protobuf:"varint,5,opt,name=delete_count,json=deleteCount" json:"delete_count,omitempty"`
-	DeletedByteCount uint64 `protobuf:"varint,6,opt,name=deleted_byte_count,json=deletedByteCount" json:"deleted_byte_count,omitempty"`
-	ReadOnly         bool   `protobuf:"varint,7,opt,name=read_only,json=readOnly" json:"read_only,omitempty"`
-	ReplicaPlacement uint32 `protobuf:"varint,8,opt,name=replica_placement,json=replicaPlacement" json:"replica_placement,omitempty"`
-	Version          uint32 `protobuf:"varint,9,opt,name=version" json:"version,omitempty"`
-	Ttl              uint32 `protobuf:"varint,10,opt,name=ttl" json:"ttl,omitempty"`
-	CompactRevision  uint32 `protobuf:"varint,11,opt,name=compact_revision,json=compactRevision" json:"compact_revision,omitempty"`
-	ModifiedAtSecond int64  `protobuf:"varint,12,opt,name=modified_at_second,json=modifiedAtSecond" json:"modified_at_second,omitempty"`
+	Id                uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
+	Size              uint64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
+	Collection        string `protobuf:"bytes,3,opt,name=collection" json:"collection,omitempty"`
+	FileCount         uint64 `protobuf:"varint,4,opt,name=file_count,json=fileCount" json:"file_count,omitempty"`
+	DeleteCount       uint64 `protobuf:"varint,5,opt,name=delete_count,json=deleteCount" json:"delete_count,omitempty"`
+	DeletedByteCount  uint64 `protobuf:"varint,6,opt,name=deleted_byte_count,json=deletedByteCount" json:"deleted_byte_count,omitempty"`
+	ReadOnly          bool   `protobuf:"varint,7,opt,name=read_only,json=readOnly" json:"read_only,omitempty"`
+	ReplicaPlacement  uint32 `protobuf:"varint,8,opt,name=replica_placement,json=replicaPlacement" json:"replica_placement,omitempty"`
+	Version           uint32 `protobuf:"varint,9,opt,name=version" json:"version,omitempty"`
+	Ttl               uint32 `protobuf:"varint,10,opt,name=ttl" json:"ttl,omitempty"`
+	CompactRevision   uint32 `protobuf:"varint,11,opt,name=compact_revision,json=compactRevision" json:"compact_revision,omitempty"`
+	ModifiedAtSecond  int64  `protobuf:"varint,12,opt,name=modified_at_second,json=modifiedAtSecond" json:"modified_at_second,omitempty"`
+	RemoteStorageName string `protobuf:"bytes,13,opt,name=remote_storage_name,json=remoteStorageName" json:"remote_storage_name,omitempty"`
+	RemoteStorageKey  string `protobuf:"bytes,14,opt,name=remote_storage_key,json=remoteStorageKey" json:"remote_storage_key,omitempty"`
 }
 
 func (m *VolumeInformationMessage) Reset()                    { *m = VolumeInformationMessage{} }
@@ -347,6 +360,20 @@ func (m *VolumeInformationMessage) GetModifiedAtSecond() int64 {
 	return 0
 }
 
+func (m *VolumeInformationMessage) GetRemoteStorageName() string {
+	if m != nil {
+		return m.RemoteStorageName
+	}
+	return ""
+}
+
+func (m *VolumeInformationMessage) GetRemoteStorageKey() string {
+	if m != nil {
+		return m.RemoteStorageKey
+	}
+	return ""
+}
+
 type VolumeShortInformationMessage struct {
 	Id               uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
 	Collection       string `protobuf:"bytes,3,opt,name=collection" json:"collection,omitempty"`
@@ -427,13 +454,45 @@ func (m *VolumeEcShardInformationMessage) GetEcIndexBits() uint32 {
 	return 0
 }
 
+type StorageBackend struct {
+	Type       string            `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
+	Id         string            `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
+	Properties map[string]string `protobuf:"bytes,3,rep,name=properties" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+}
+
+func (m *StorageBackend) Reset()                    { *m = StorageBackend{} }
+func (m *StorageBackend) String() string            { return proto.CompactTextString(m) }
+func (*StorageBackend) ProtoMessage()               {}
+func (*StorageBackend) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *StorageBackend) GetType() string {
+	if m != nil {
+		return m.Type
+	}
+	return ""
+}
+
+func (m *StorageBackend) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *StorageBackend) GetProperties() map[string]string {
+	if m != nil {
+		return m.Properties
+	}
+	return nil
+}
+
 type Empty struct {
 }
 
 func (m *Empty) Reset()                    { *m = Empty{} }
 func (m *Empty) String() string            { return proto.CompactTextString(m) }
 func (*Empty) ProtoMessage()               {}
-func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 
 type SuperBlockExtra struct {
 	ErasureCoding *SuperBlockExtra_ErasureCoding `protobuf:"bytes,1,opt,name=erasure_coding,json=erasureCoding" json:"erasure_coding,omitempty"`
@@ -442,7 +501,7 @@ type SuperBlockExtra struct {
 func (m *SuperBlockExtra) Reset()                    { *m = SuperBlockExtra{} }
 func (m *SuperBlockExtra) String() string            { return proto.CompactTextString(m) }
 func (*SuperBlockExtra) ProtoMessage()               {}
-func (*SuperBlockExtra) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+func (*SuperBlockExtra) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 
 func (m *SuperBlockExtra) GetErasureCoding() *SuperBlockExtra_ErasureCoding {
 	if m != nil {
@@ -461,7 +520,7 @@ func (m *SuperBlockExtra_ErasureCoding) Reset()         { *m = SuperBlockExtra_E
 func (m *SuperBlockExtra_ErasureCoding) String() string { return proto.CompactTextString(m) }
 func (*SuperBlockExtra_ErasureCoding) ProtoMessage()    {}
 func (*SuperBlockExtra_ErasureCoding) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{6, 0}
+	return fileDescriptor0, []int{7, 0}
 }
 
 func (m *SuperBlockExtra_ErasureCoding) GetData() uint32 {
@@ -486,13 +545,14 @@ func (m *SuperBlockExtra_ErasureCoding) GetVolumeIds() []uint32 {
 }
 
 type KeepConnectedRequest struct {
-	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Name     string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	GrpcPort uint32 `protobuf:"varint,2,opt,name=grpc_port,json=grpcPort" json:"grpc_port,omitempty"`
 }
 
 func (m *KeepConnectedRequest) Reset()                    { *m = KeepConnectedRequest{} }
 func (m *KeepConnectedRequest) String() string            { return proto.CompactTextString(m) }
 func (*KeepConnectedRequest) ProtoMessage()               {}
-func (*KeepConnectedRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+func (*KeepConnectedRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 
 func (m *KeepConnectedRequest) GetName() string {
 	if m != nil {
@@ -501,6 +561,13 @@ func (m *KeepConnectedRequest) GetName() string {
 	return ""
 }
 
+func (m *KeepConnectedRequest) GetGrpcPort() uint32 {
+	if m != nil {
+		return m.GrpcPort
+	}
+	return 0
+}
+
 type VolumeLocation struct {
 	Url         string   `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"`
 	PublicUrl   string   `protobuf:"bytes,2,opt,name=public_url,json=publicUrl" json:"public_url,omitempty"`
@@ -512,7 +579,7 @@ type VolumeLocation struct {
 func (m *VolumeLocation) Reset()                    { *m = VolumeLocation{} }
 func (m *VolumeLocation) String() string            { return proto.CompactTextString(m) }
 func (*VolumeLocation) ProtoMessage()               {}
-func (*VolumeLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+func (*VolumeLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 
 func (m *VolumeLocation) GetUrl() string {
 	if m != nil {
@@ -557,7 +624,7 @@ type LookupVolumeRequest struct {
 func (m *LookupVolumeRequest) Reset()                    { *m = LookupVolumeRequest{} }
 func (m *LookupVolumeRequest) String() string            { return proto.CompactTextString(m) }
 func (*LookupVolumeRequest) ProtoMessage()               {}
-func (*LookupVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+func (*LookupVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 
 func (m *LookupVolumeRequest) GetVolumeIds() []string {
 	if m != nil {
@@ -580,7 +647,7 @@ type LookupVolumeResponse struct {
 func (m *LookupVolumeResponse) Reset()                    { *m = LookupVolumeResponse{} }
 func (m *LookupVolumeResponse) String() string            { return proto.CompactTextString(m) }
 func (*LookupVolumeResponse) ProtoMessage()               {}
-func (*LookupVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+func (*LookupVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
 func (m *LookupVolumeResponse) GetVolumeIdLocations() []*LookupVolumeResponse_VolumeIdLocation {
 	if m != nil {
@@ -599,7 +666,7 @@ func (m *LookupVolumeResponse_VolumeIdLocation) Reset()         { *m = LookupVol
 func (m *LookupVolumeResponse_VolumeIdLocation) String() string { return proto.CompactTextString(m) }
 func (*LookupVolumeResponse_VolumeIdLocation) ProtoMessage()    {}
 func (*LookupVolumeResponse_VolumeIdLocation) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{10, 0}
+	return fileDescriptor0, []int{11, 0}
 }
 
 func (m *LookupVolumeResponse_VolumeIdLocation) GetVolumeId() string {
@@ -631,7 +698,7 @@ type Location struct {
 func (m *Location) Reset()                    { *m = Location{} }
 func (m *Location) String() string            { return proto.CompactTextString(m) }
 func (*Location) ProtoMessage()               {}
-func (*Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+func (*Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 
 func (m *Location) GetUrl() string {
 	if m != nil {
@@ -662,7 +729,7 @@ type AssignRequest struct {
 func (m *AssignRequest) Reset()                    { *m = AssignRequest{} }
 func (m *AssignRequest) String() string            { return proto.CompactTextString(m) }
 func (*AssignRequest) ProtoMessage()               {}
-func (*AssignRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+func (*AssignRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 
 func (m *AssignRequest) GetCount() uint64 {
 	if m != nil {
@@ -739,7 +806,7 @@ type AssignResponse struct {
 func (m *AssignResponse) Reset()                    { *m = AssignResponse{} }
 func (m *AssignResponse) String() string            { return proto.CompactTextString(m) }
 func (*AssignResponse) ProtoMessage()               {}
-func (*AssignResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+func (*AssignResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 
 func (m *AssignResponse) GetFid() string {
 	if m != nil {
@@ -792,7 +859,7 @@ type StatisticsRequest struct {
 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{14} }
+func (*StatisticsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
 
 func (m *StatisticsRequest) GetReplication() string {
 	if m != nil {
@@ -827,7 +894,7 @@ type StatisticsResponse struct {
 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{15} }
+func (*StatisticsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
 
 func (m *StatisticsResponse) GetReplication() string {
 	if m != nil {
@@ -879,7 +946,7 @@ type StorageType struct {
 func (m *StorageType) Reset()                    { *m = StorageType{} }
 func (m *StorageType) String() string            { return proto.CompactTextString(m) }
 func (*StorageType) ProtoMessage()               {}
-func (*StorageType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
+func (*StorageType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
 
 func (m *StorageType) GetReplication() string {
 	if m != nil {
@@ -902,7 +969,7 @@ type Collection struct {
 func (m *Collection) Reset()                    { *m = Collection{} }
 func (m *Collection) String() string            { return proto.CompactTextString(m) }
 func (*Collection) ProtoMessage()               {}
-func (*Collection) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
+func (*Collection) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
 
 func (m *Collection) GetName() string {
 	if m != nil {
@@ -919,7 +986,7 @@ type CollectionListRequest struct {
 func (m *CollectionListRequest) Reset()                    { *m = CollectionListRequest{} }
 func (m *CollectionListRequest) String() string            { return proto.CompactTextString(m) }
 func (*CollectionListRequest) ProtoMessage()               {}
-func (*CollectionListRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+func (*CollectionListRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
 
 func (m *CollectionListRequest) GetIncludeNormalVolumes() bool {
 	if m != nil {
@@ -942,7 +1009,7 @@ type CollectionListResponse struct {
 func (m *CollectionListResponse) Reset()                    { *m = CollectionListResponse{} }
 func (m *CollectionListResponse) String() string            { return proto.CompactTextString(m) }
 func (*CollectionListResponse) ProtoMessage()               {}
-func (*CollectionListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
+func (*CollectionListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
 
 func (m *CollectionListResponse) GetCollections() []*Collection {
 	if m != nil {
@@ -958,7 +1025,7 @@ type CollectionDeleteRequest struct {
 func (m *CollectionDeleteRequest) Reset()                    { *m = CollectionDeleteRequest{} }
 func (m *CollectionDeleteRequest) String() string            { return proto.CompactTextString(m) }
 func (*CollectionDeleteRequest) ProtoMessage()               {}
-func (*CollectionDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
+func (*CollectionDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
 
 func (m *CollectionDeleteRequest) GetName() string {
 	if m != nil {
@@ -973,7 +1040,7 @@ type CollectionDeleteResponse struct {
 func (m *CollectionDeleteResponse) Reset()                    { *m = CollectionDeleteResponse{} }
 func (m *CollectionDeleteResponse) String() string            { return proto.CompactTextString(m) }
 func (*CollectionDeleteResponse) ProtoMessage()               {}
-func (*CollectionDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+func (*CollectionDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
 
 //
 // volume related
@@ -986,12 +1053,13 @@ type DataNodeInfo struct {
 	ActiveVolumeCount uint64                             `protobuf:"varint,5,opt,name=active_volume_count,json=activeVolumeCount" json:"active_volume_count,omitempty"`
 	VolumeInfos       []*VolumeInformationMessage        `protobuf:"bytes,6,rep,name=volume_infos,json=volumeInfos" json:"volume_infos,omitempty"`
 	EcShardInfos      []*VolumeEcShardInformationMessage `protobuf:"bytes,7,rep,name=ec_shard_infos,json=ecShardInfos" json:"ec_shard_infos,omitempty"`
+	RemoteVolumeCount uint64                             `protobuf:"varint,8,opt,name=remote_volume_count,json=remoteVolumeCount" json:"remote_volume_count,omitempty"`
 }
 
 func (m *DataNodeInfo) Reset()                    { *m = DataNodeInfo{} }
 func (m *DataNodeInfo) String() string            { return proto.CompactTextString(m) }
 func (*DataNodeInfo) ProtoMessage()               {}
-func (*DataNodeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+func (*DataNodeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
 
 func (m *DataNodeInfo) GetId() string {
 	if m != nil {
@@ -1042,6 +1110,13 @@ func (m *DataNodeInfo) GetEcShardInfos() []*VolumeEcShardInformationMessage {
 	return nil
 }
 
+func (m *DataNodeInfo) GetRemoteVolumeCount() uint64 {
+	if m != nil {
+		return m.RemoteVolumeCount
+	}
+	return 0
+}
+
 type RackInfo struct {
 	Id                string          `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
 	VolumeCount       uint64          `protobuf:"varint,2,opt,name=volume_count,json=volumeCount" json:"volume_count,omitempty"`
@@ -1049,12 +1124,13 @@ type RackInfo struct {
 	FreeVolumeCount   uint64          `protobuf:"varint,4,opt,name=free_volume_count,json=freeVolumeCount" json:"free_volume_count,omitempty"`
 	ActiveVolumeCount uint64          `protobuf:"varint,5,opt,name=active_volume_count,json=activeVolumeCount" json:"active_volume_count,omitempty"`
 	DataNodeInfos     []*DataNodeInfo `protobuf:"bytes,6,rep,name=data_node_infos,json=dataNodeInfos" json:"data_node_infos,omitempty"`
+	RemoteVolumeCount uint64          `protobuf:"varint,7,opt,name=remote_volume_count,json=remoteVolumeCount" json:"remote_volume_count,omitempty"`
 }
 
 func (m *RackInfo) Reset()                    { *m = RackInfo{} }
 func (m *RackInfo) String() string            { return proto.CompactTextString(m) }
 func (*RackInfo) ProtoMessage()               {}
-func (*RackInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
+func (*RackInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
 
 func (m *RackInfo) GetId() string {
 	if m != nil {
@@ -1098,6 +1174,13 @@ func (m *RackInfo) GetDataNodeInfos() []*DataNodeInfo {
 	return nil
 }
 
+func (m *RackInfo) GetRemoteVolumeCount() uint64 {
+	if m != nil {
+		return m.RemoteVolumeCount
+	}
+	return 0
+}
+
 type DataCenterInfo struct {
 	Id                string      `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
 	VolumeCount       uint64      `protobuf:"varint,2,opt,name=volume_count,json=volumeCount" json:"volume_count,omitempty"`
@@ -1105,12 +1188,13 @@ type DataCenterInfo struct {
 	FreeVolumeCount   uint64      `protobuf:"varint,4,opt,name=free_volume_count,json=freeVolumeCount" json:"free_volume_count,omitempty"`
 	ActiveVolumeCount uint64      `protobuf:"varint,5,opt,name=active_volume_count,json=activeVolumeCount" json:"active_volume_count,omitempty"`
 	RackInfos         []*RackInfo `protobuf:"bytes,6,rep,name=rack_infos,json=rackInfos" json:"rack_infos,omitempty"`
+	RemoteVolumeCount uint64      `protobuf:"varint,7,opt,name=remote_volume_count,json=remoteVolumeCount" json:"remote_volume_count,omitempty"`
 }
 
 func (m *DataCenterInfo) Reset()                    { *m = DataCenterInfo{} }
 func (m *DataCenterInfo) String() string            { return proto.CompactTextString(m) }
 func (*DataCenterInfo) ProtoMessage()               {}
-func (*DataCenterInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
+func (*DataCenterInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
 
 func (m *DataCenterInfo) GetId() string {
 	if m != nil {
@@ -1154,6 +1238,13 @@ func (m *DataCenterInfo) GetRackInfos() []*RackInfo {
 	return nil
 }
 
+func (m *DataCenterInfo) GetRemoteVolumeCount() uint64 {
+	if m != nil {
+		return m.RemoteVolumeCount
+	}
+	return 0
+}
+
 type TopologyInfo struct {
 	Id                string            `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
 	VolumeCount       uint64            `protobuf:"varint,2,opt,name=volume_count,json=volumeCount" json:"volume_count,omitempty"`
@@ -1161,12 +1252,13 @@ type TopologyInfo struct {
 	FreeVolumeCount   uint64            `protobuf:"varint,4,opt,name=free_volume_count,json=freeVolumeCount" json:"free_volume_count,omitempty"`
 	ActiveVolumeCount uint64            `protobuf:"varint,5,opt,name=active_volume_count,json=activeVolumeCount" json:"active_volume_count,omitempty"`
 	DataCenterInfos   []*DataCenterInfo `protobuf:"bytes,6,rep,name=data_center_infos,json=dataCenterInfos" json:"data_center_infos,omitempty"`
+	RemoteVolumeCount uint64            `protobuf:"varint,7,opt,name=remote_volume_count,json=remoteVolumeCount" json:"remote_volume_count,omitempty"`
 }
 
 func (m *TopologyInfo) Reset()                    { *m = TopologyInfo{} }
 func (m *TopologyInfo) String() string            { return proto.CompactTextString(m) }
 func (*TopologyInfo) ProtoMessage()               {}
-func (*TopologyInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
+func (*TopologyInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
 
 func (m *TopologyInfo) GetId() string {
 	if m != nil {
@@ -1210,13 +1302,20 @@ func (m *TopologyInfo) GetDataCenterInfos() []*DataCenterInfo {
 	return nil
 }
 
+func (m *TopologyInfo) GetRemoteVolumeCount() uint64 {
+	if m != nil {
+		return m.RemoteVolumeCount
+	}
+	return 0
+}
+
 type VolumeListRequest struct {
 }
 
 func (m *VolumeListRequest) Reset()                    { *m = VolumeListRequest{} }
 func (m *VolumeListRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeListRequest) ProtoMessage()               {}
-func (*VolumeListRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
+func (*VolumeListRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
 
 type VolumeListResponse struct {
 	TopologyInfo      *TopologyInfo `protobuf:"bytes,1,opt,name=topology_info,json=topologyInfo" json:"topology_info,omitempty"`
@@ -1226,7 +1325,7 @@ type VolumeListResponse struct {
 func (m *VolumeListResponse) Reset()                    { *m = VolumeListResponse{} }
 func (m *VolumeListResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeListResponse) ProtoMessage()               {}
-func (*VolumeListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
+func (*VolumeListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
 
 func (m *VolumeListResponse) GetTopologyInfo() *TopologyInfo {
 	if m != nil {
@@ -1249,7 +1348,7 @@ type LookupEcVolumeRequest struct {
 func (m *LookupEcVolumeRequest) Reset()                    { *m = LookupEcVolumeRequest{} }
 func (m *LookupEcVolumeRequest) String() string            { return proto.CompactTextString(m) }
 func (*LookupEcVolumeRequest) ProtoMessage()               {}
-func (*LookupEcVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
+func (*LookupEcVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
 
 func (m *LookupEcVolumeRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -1266,7 +1365,7 @@ type LookupEcVolumeResponse struct {
 func (m *LookupEcVolumeResponse) Reset()                    { *m = LookupEcVolumeResponse{} }
 func (m *LookupEcVolumeResponse) String() string            { return proto.CompactTextString(m) }
 func (*LookupEcVolumeResponse) ProtoMessage()               {}
-func (*LookupEcVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+func (*LookupEcVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
 
 func (m *LookupEcVolumeResponse) GetVolumeId() uint32 {
 	if m != nil {
@@ -1293,7 +1392,7 @@ func (m *LookupEcVolumeResponse_EcShardIdLocation) Reset() {
 func (m *LookupEcVolumeResponse_EcShardIdLocation) String() string { return proto.CompactTextString(m) }
 func (*LookupEcVolumeResponse_EcShardIdLocation) ProtoMessage()    {}
 func (*LookupEcVolumeResponse_EcShardIdLocation) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{29, 0}
+	return fileDescriptor0, []int{30, 0}
 }
 
 func (m *LookupEcVolumeResponse_EcShardIdLocation) GetShardId() uint32 {
@@ -1316,7 +1415,7 @@ type GetMasterConfigurationRequest struct {
 func (m *GetMasterConfigurationRequest) Reset()                    { *m = GetMasterConfigurationRequest{} }
 func (m *GetMasterConfigurationRequest) String() string            { return proto.CompactTextString(m) }
 func (*GetMasterConfigurationRequest) ProtoMessage()               {}
-func (*GetMasterConfigurationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+func (*GetMasterConfigurationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
 
 type GetMasterConfigurationResponse struct {
 	MetricsAddress         string `protobuf:"bytes,1,opt,name=metrics_address,json=metricsAddress" json:"metrics_address,omitempty"`
@@ -1326,7 +1425,7 @@ type GetMasterConfigurationResponse struct {
 func (m *GetMasterConfigurationResponse) Reset()                    { *m = GetMasterConfigurationResponse{} }
 func (m *GetMasterConfigurationResponse) String() string            { return proto.CompactTextString(m) }
 func (*GetMasterConfigurationResponse) ProtoMessage()               {}
-func (*GetMasterConfigurationResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+func (*GetMasterConfigurationResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
 
 func (m *GetMasterConfigurationResponse) GetMetricsAddress() string {
 	if m != nil {
@@ -1342,12 +1441,45 @@ func (m *GetMasterConfigurationResponse) GetMetricsIntervalSeconds() uint32 {
 	return 0
 }
 
+type ListMasterClientsRequest struct {
+	ClientType string `protobuf:"bytes,1,opt,name=client_type,json=clientType" json:"client_type,omitempty"`
+}
+
+func (m *ListMasterClientsRequest) Reset()                    { *m = ListMasterClientsRequest{} }
+func (m *ListMasterClientsRequest) String() string            { return proto.CompactTextString(m) }
+func (*ListMasterClientsRequest) ProtoMessage()               {}
+func (*ListMasterClientsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
+
+func (m *ListMasterClientsRequest) GetClientType() string {
+	if m != nil {
+		return m.ClientType
+	}
+	return ""
+}
+
+type ListMasterClientsResponse struct {
+	GrpcAddresses []string `protobuf:"bytes,1,rep,name=grpc_addresses,json=grpcAddresses" json:"grpc_addresses,omitempty"`
+}
+
+func (m *ListMasterClientsResponse) Reset()                    { *m = ListMasterClientsResponse{} }
+func (m *ListMasterClientsResponse) String() string            { return proto.CompactTextString(m) }
+func (*ListMasterClientsResponse) ProtoMessage()               {}
+func (*ListMasterClientsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
+
+func (m *ListMasterClientsResponse) GetGrpcAddresses() []string {
+	if m != nil {
+		return m.GrpcAddresses
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*Heartbeat)(nil), "master_pb.Heartbeat")
 	proto.RegisterType((*HeartbeatResponse)(nil), "master_pb.HeartbeatResponse")
 	proto.RegisterType((*VolumeInformationMessage)(nil), "master_pb.VolumeInformationMessage")
 	proto.RegisterType((*VolumeShortInformationMessage)(nil), "master_pb.VolumeShortInformationMessage")
 	proto.RegisterType((*VolumeEcShardInformationMessage)(nil), "master_pb.VolumeEcShardInformationMessage")
+	proto.RegisterType((*StorageBackend)(nil), "master_pb.StorageBackend")
 	proto.RegisterType((*Empty)(nil), "master_pb.Empty")
 	proto.RegisterType((*SuperBlockExtra)(nil), "master_pb.SuperBlockExtra")
 	proto.RegisterType((*SuperBlockExtra_ErasureCoding)(nil), "master_pb.SuperBlockExtra.ErasureCoding")
@@ -1378,6 +1510,8 @@ func init() {
 	proto.RegisterType((*LookupEcVolumeResponse_EcShardIdLocation)(nil), "master_pb.LookupEcVolumeResponse.EcShardIdLocation")
 	proto.RegisterType((*GetMasterConfigurationRequest)(nil), "master_pb.GetMasterConfigurationRequest")
 	proto.RegisterType((*GetMasterConfigurationResponse)(nil), "master_pb.GetMasterConfigurationResponse")
+	proto.RegisterType((*ListMasterClientsRequest)(nil), "master_pb.ListMasterClientsRequest")
+	proto.RegisterType((*ListMasterClientsResponse)(nil), "master_pb.ListMasterClientsResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1401,6 +1535,7 @@ type SeaweedClient interface {
 	VolumeList(ctx context.Context, in *VolumeListRequest, opts ...grpc.CallOption) (*VolumeListResponse, error)
 	LookupEcVolume(ctx context.Context, in *LookupEcVolumeRequest, opts ...grpc.CallOption) (*LookupEcVolumeResponse, error)
 	GetMasterConfiguration(ctx context.Context, in *GetMasterConfigurationRequest, opts ...grpc.CallOption) (*GetMasterConfigurationResponse, error)
+	ListMasterClients(ctx context.Context, in *ListMasterClientsRequest, opts ...grpc.CallOption) (*ListMasterClientsResponse, error)
 }
 
 type seaweedClient struct {
@@ -1545,6 +1680,15 @@ func (c *seaweedClient) GetMasterConfiguration(ctx context.Context, in *GetMaste
 	return out, nil
 }
 
+func (c *seaweedClient) ListMasterClients(ctx context.Context, in *ListMasterClientsRequest, opts ...grpc.CallOption) (*ListMasterClientsResponse, error) {
+	out := new(ListMasterClientsResponse)
+	err := grpc.Invoke(ctx, "/master_pb.Seaweed/ListMasterClients", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for Seaweed service
 
 type SeaweedServer interface {
@@ -1558,6 +1702,7 @@ type SeaweedServer interface {
 	VolumeList(context.Context, *VolumeListRequest) (*VolumeListResponse, error)
 	LookupEcVolume(context.Context, *LookupEcVolumeRequest) (*LookupEcVolumeResponse, error)
 	GetMasterConfiguration(context.Context, *GetMasterConfigurationRequest) (*GetMasterConfigurationResponse, error)
+	ListMasterClients(context.Context, *ListMasterClientsRequest) (*ListMasterClientsResponse, error)
 }
 
 func RegisterSeaweedServer(s *grpc.Server, srv SeaweedServer) {
@@ -1760,6 +1905,24 @@ func _Seaweed_GetMasterConfiguration_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Seaweed_ListMasterClients_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListMasterClientsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SeaweedServer).ListMasterClients(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/master_pb.Seaweed/ListMasterClients",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SeaweedServer).ListMasterClients(ctx, req.(*ListMasterClientsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Seaweed_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "master_pb.Seaweed",
 	HandlerType: (*SeaweedServer)(nil),
@@ -1796,6 +1959,10 @@ var _Seaweed_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetMasterConfiguration",
 			Handler:    _Seaweed_GetMasterConfiguration_Handler,
 		},
+		{
+			MethodName: "ListMasterClients",
+			Handler:    _Seaweed_ListMasterClients_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -1817,127 +1984,142 @@ var _Seaweed_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("master.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 1943 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x59, 0x4b, 0x6f, 0x1b, 0xc9,
-	0x11, 0xf6, 0x90, 0x14, 0x45, 0x16, 0x1f, 0x22, 0x5b, 0xb2, 0x96, 0xe6, 0xc6, 0x16, 0x3d, 0x1b,
-	0x60, 0xb5, 0xce, 0x46, 0xd9, 0x68, 0x17, 0x48, 0x80, 0x24, 0x58, 0xd8, 0xb2, 0x76, 0x23, 0xd8,
-	0xf2, 0xda, 0x43, 0xc7, 0x0b, 0x04, 0x08, 0x26, 0xcd, 0x99, 0x96, 0x34, 0xd0, 0xbc, 0x32, 0xdd,
-	0x94, 0xc9, 0xcd, 0x31, 0xb9, 0x05, 0xc8, 0x25, 0x87, 0x9c, 0x72, 0xcf, 0x3d, 0xb7, 0x1c, 0x72,
-	0xc9, 0x8f, 0xc8, 0x39, 0x7f, 0x21, 0xd7, 0x20, 0x40, 0xd0, 0xaf, 0x99, 0x1e, 0x92, 0x92, 0xac,
-	0x05, 0x7c, 0xf0, 0x6d, 0xa6, 0xaa, 0xba, 0xba, 0xe6, 0xab, 0xae, 0xaa, 0xaf, 0x49, 0x68, 0x47,
-	0x98, 0x32, 0x92, 0xed, 0xa5, 0x59, 0xc2, 0x12, 0xd4, 0x94, 0x6f, 0x6e, 0x3a, 0xb1, 0xff, 0x50,
-	0x87, 0xe6, 0xcf, 0x09, 0xce, 0xd8, 0x84, 0x60, 0x86, 0xba, 0x50, 0x09, 0xd2, 0x81, 0x35, 0xb2,
-	0x76, 0x9b, 0x4e, 0x25, 0x48, 0x11, 0x82, 0x5a, 0x9a, 0x64, 0x6c, 0x50, 0x19, 0x59, 0xbb, 0x1d,
-	0x47, 0x3c, 0xa3, 0xbb, 0x00, 0xe9, 0x74, 0x12, 0x06, 0x9e, 0x3b, 0xcd, 0xc2, 0x41, 0x55, 0xd8,
-	0x36, 0xa5, 0xe4, 0x17, 0x59, 0x88, 0x76, 0xa1, 0x17, 0xe1, 0x99, 0x7b, 0x91, 0x84, 0xd3, 0x88,
-	0xb8, 0x5e, 0x32, 0x8d, 0xd9, 0xa0, 0x26, 0x96, 0x77, 0x23, 0x3c, 0x7b, 0x25, 0xc4, 0x07, 0x5c,
-	0x8a, 0x46, 0x3c, 0xaa, 0x99, 0x7b, 0x12, 0x84, 0xc4, 0x3d, 0x27, 0xf3, 0xc1, 0xda, 0xc8, 0xda,
-	0xad, 0x39, 0x10, 0xe1, 0xd9, 0x17, 0x41, 0x48, 0x9e, 0x90, 0x39, 0xda, 0x81, 0x96, 0x8f, 0x19,
-	0x76, 0x3d, 0x12, 0x33, 0x92, 0x0d, 0xea, 0x62, 0x2f, 0xe0, 0xa2, 0x03, 0x21, 0xe1, 0xf1, 0x65,
-	0xd8, 0x3b, 0x1f, 0xac, 0x0b, 0x8d, 0x78, 0xe6, 0xf1, 0x61, 0x3f, 0x0a, 0x62, 0x57, 0x44, 0xde,
-	0x10, 0x5b, 0x37, 0x85, 0xe4, 0x39, 0x0f, 0xff, 0x67, 0xb0, 0x2e, 0x63, 0xa3, 0x83, 0xe6, 0xa8,
-	0xba, 0xdb, 0xda, 0xff, 0x60, 0x2f, 0x47, 0x63, 0x4f, 0x86, 0x77, 0x14, 0x9f, 0x24, 0x59, 0x84,
-	0x59, 0x90, 0xc4, 0xc7, 0x84, 0x52, 0x7c, 0x4a, 0x1c, 0xbd, 0x06, 0x1d, 0x41, 0x2b, 0x26, 0xaf,
-	0x5d, 0xed, 0x02, 0x84, 0x8b, 0xdd, 0x25, 0x17, 0xe3, 0xb3, 0x24, 0x63, 0x2b, 0xfc, 0x40, 0x4c,
-	0x5e, 0xbf, 0x52, 0xae, 0x5e, 0xc0, 0x86, 0x4f, 0x42, 0xc2, 0x88, 0x9f, 0xbb, 0x6b, 0xdd, 0xd0,
-	0x5d, 0x57, 0x39, 0xd0, 0x2e, 0xbf, 0x0b, 0xdd, 0x33, 0x4c, 0xdd, 0x38, 0xc9, 0x3d, 0xb6, 0x47,
-	0xd6, 0x6e, 0xc3, 0x69, 0x9f, 0x61, 0xfa, 0x2c, 0xd1, 0x56, 0x5f, 0x42, 0x93, 0x78, 0x2e, 0x3d,
-	0xc3, 0x99, 0x4f, 0x07, 0x3d, 0xb1, 0xe5, 0x83, 0xa5, 0x2d, 0x0f, 0xbd, 0x31, 0x37, 0x58, 0xb1,
-	0x69, 0x83, 0x48, 0x15, 0x45, 0xcf, 0xa0, 0xc3, 0xc1, 0x28, 0x9c, 0xf5, 0x6f, 0xec, 0x8c, 0xa3,
-	0x79, 0xa8, 0xfd, 0xbd, 0x82, 0xbe, 0x46, 0xa4, 0xf0, 0x89, 0x6e, 0xec, 0x53, 0xc3, 0x9a, 0xfb,
-	0xfd, 0x10, 0x7a, 0x0a, 0x96, 0xc2, 0xed, 0xa6, 0x00, 0xa6, 0x23, 0x80, 0xd1, 0x86, 0xf6, 0xdf,
-	0x2d, 0xe8, 0xe7, 0xd5, 0xe0, 0x10, 0x9a, 0x26, 0x31, 0x25, 0xe8, 0x01, 0xf4, 0xd5, 0x71, 0xa6,
-	0xc1, 0x37, 0xc4, 0x0d, 0x83, 0x28, 0x60, 0xa2, 0x48, 0x6a, 0xce, 0x86, 0x54, 0x8c, 0x83, 0x6f,
-	0xc8, 0x53, 0x2e, 0x46, 0xdb, 0x50, 0x0f, 0x09, 0xf6, 0x49, 0x26, 0x6a, 0xa6, 0xe9, 0xa8, 0x37,
-	0xf4, 0x21, 0x6c, 0x44, 0x84, 0x65, 0x81, 0x47, 0x5d, 0xec, 0xfb, 0x19, 0xa1, 0x54, 0x95, 0x4e,
-	0x57, 0x89, 0x1f, 0x4a, 0x29, 0xfa, 0x31, 0x0c, 0xb4, 0x61, 0xc0, 0xcf, 0xf8, 0x05, 0x0e, 0x5d,
-	0x4a, 0xbc, 0x24, 0xf6, 0xa9, 0xaa, 0xa3, 0x6d, 0xa5, 0x3f, 0x52, 0xea, 0xb1, 0xd4, 0xda, 0x7f,
-	0xa9, 0xc2, 0xe0, 0xb2, 0x03, 0x2c, 0x2a, 0xdb, 0x17, 0x41, 0x77, 0x9c, 0x4a, 0xe0, 0xf3, 0xca,
-	0xe1, 0x1f, 0x23, 0xa2, 0xac, 0x39, 0xe2, 0x19, 0xdd, 0x03, 0xf0, 0x92, 0x30, 0x24, 0x1e, 0x5f,
-	0xa8, 0xc2, 0x33, 0x24, 0xbc, 0xb2, 0x44, 0xb1, 0x16, 0x45, 0x5d, 0x73, 0x9a, 0x5c, 0x22, 0xeb,
-	0xf9, 0x3e, 0xb4, 0x25, 0xf0, 0xca, 0x40, 0xd6, 0x73, 0x4b, 0xca, 0xa4, 0xc9, 0xc7, 0x80, 0x74,
-	0x82, 0x27, 0xf3, 0xdc, 0xb0, 0x2e, 0x0c, 0x7b, 0x4a, 0xf3, 0x68, 0xae, 0xad, 0xdf, 0x87, 0x66,
-	0x46, 0xb0, 0xef, 0x26, 0x71, 0x38, 0x17, 0x25, 0xde, 0x70, 0x1a, 0x5c, 0xf0, 0x55, 0x1c, 0xce,
-	0xd1, 0xf7, 0xa0, 0x9f, 0x91, 0x34, 0x0c, 0x3c, 0xec, 0xa6, 0x21, 0xf6, 0x48, 0x44, 0x62, 0x5d,
-	0xed, 0x3d, 0xa5, 0x78, 0xae, 0xe5, 0x68, 0x00, 0xeb, 0x17, 0x24, 0xa3, 0xfc, 0xb3, 0x9a, 0xc2,
-	0x44, 0xbf, 0xa2, 0x1e, 0x54, 0x19, 0x0b, 0x07, 0x20, 0xa4, 0xfc, 0x11, 0x7d, 0x04, 0x3d, 0x2f,
-	0x89, 0x52, 0xec, 0x31, 0x37, 0x23, 0x17, 0x81, 0x58, 0xd4, 0x12, 0xea, 0x0d, 0x25, 0x77, 0x94,
-	0x98, 0x7f, 0x4e, 0x94, 0xf8, 0xc1, 0x49, 0x40, 0x7c, 0x17, 0x33, 0x95, 0x26, 0x51, 0x72, 0x55,
-	0xa7, 0xa7, 0x35, 0x0f, 0x99, 0x4c, 0x90, 0xfd, 0x57, 0x0b, 0xee, 0x5e, 0x59, 0xce, 0x4b, 0x49,
-	0xba, 0x2e, 0x21, 0x6f, 0x0b, 0x03, 0x7b, 0x0a, 0x3b, 0xd7, 0x14, 0xd9, 0x35, 0xb1, 0x56, 0x96,
-	0x62, 0xb5, 0xa1, 0x43, 0x3c, 0x37, 0x88, 0x7d, 0x32, 0x73, 0x27, 0x01, 0x93, 0xc7, 0xbf, 0xe3,
-	0xb4, 0x88, 0x77, 0xc4, 0x65, 0x8f, 0x02, 0x46, 0xed, 0x75, 0x58, 0x3b, 0x8c, 0x52, 0x36, 0xb7,
-	0xff, 0x61, 0xc1, 0xc6, 0x78, 0x9a, 0x92, 0xec, 0x51, 0x98, 0x78, 0xe7, 0x87, 0x33, 0x96, 0x61,
-	0xf4, 0x15, 0x74, 0x49, 0x86, 0xe9, 0x34, 0xe3, 0xc7, 0xc6, 0x0f, 0xe2, 0x53, 0xb1, 0x79, 0xb9,
-	0x5b, 0x2e, 0xac, 0xd9, 0x3b, 0x94, 0x0b, 0x0e, 0x84, 0xbd, 0xd3, 0x21, 0xe6, 0xeb, 0xf0, 0x97,
-	0xd0, 0x29, 0xe9, 0x79, 0x4d, 0xf0, 0xd9, 0xa2, 0x3e, 0x4a, 0x3c, 0xf3, 0x7a, 0x4e, 0x71, 0x16,
-	0xb0, 0xb9, 0x9a, 0x81, 0xea, 0x8d, 0xd7, 0x82, 0xea, 0x09, 0x81, 0xcf, 0xbf, 0xa5, 0xca, 0xa7,
-	0x8c, 0x94, 0x1c, 0xf9, 0xd4, 0x7e, 0x00, 0x5b, 0x4f, 0x08, 0x49, 0x0f, 0x92, 0x38, 0x26, 0x1e,
-	0x23, 0xbe, 0x43, 0x7e, 0x33, 0x25, 0x94, 0xf1, 0x2d, 0x62, 0x1c, 0x11, 0x35, 0x62, 0xc5, 0xb3,
-	0xfd, 0x67, 0x0b, 0xba, 0x12, 0xed, 0xa7, 0x89, 0x27, 0x30, 0xe6, 0x19, 0xe1, 0xc3, 0x55, 0x5a,
-	0xf1, 0xc7, 0x85, 0xa9, 0x5b, 0x59, 0x9c, 0xba, 0x77, 0xa0, 0x21, 0xc6, 0x52, 0x11, 0xcc, 0x3a,
-	0x9f, 0x34, 0x81, 0x4f, 0x8b, 0xb2, 0xf4, 0xa5, 0xba, 0x26, 0xd4, 0x2d, 0x3d, 0x39, 0xb8, 0x49,
-	0xd1, 0xb4, 0xd6, 0xcc, 0xa6, 0x65, 0xbf, 0x84, 0xcd, 0xa7, 0x49, 0x72, 0x3e, 0x4d, 0x65, 0x78,
-	0xfa, 0x23, 0xca, 0xdf, 0x6e, 0x8d, 0xaa, 0x3c, 0x96, 0xfc, 0xdb, 0xaf, 0x3b, 0x09, 0xf6, 0x7f,
-	0x2c, 0xd8, 0x2a, 0xbb, 0x55, 0x7d, 0xf6, 0xd7, 0xb0, 0x99, 0xfb, 0x75, 0x43, 0x85, 0x85, 0xdc,
-	0xa0, 0xb5, 0xff, 0x89, 0x91, 0xe6, 0x55, 0xab, 0xf5, 0xec, 0xf6, 0x35, 0x88, 0x4e, 0xff, 0x62,
-	0x41, 0x42, 0x87, 0x33, 0xe8, 0x2d, 0x9a, 0xf1, 0x2e, 0x93, 0xef, 0xaa, 0x10, 0x6f, 0xe8, 0x95,
-	0xe8, 0x87, 0xd0, 0x2c, 0x02, 0xa9, 0x88, 0x40, 0x36, 0x4b, 0x81, 0xa8, 0xbd, 0x0a, 0x2b, 0xb4,
-	0x05, 0x6b, 0x24, 0xcb, 0x92, 0x4c, 0xd5, 0xab, 0x7c, 0xb1, 0x7f, 0x02, 0x8d, 0x6f, 0x9d, 0x5d,
-	0xfb, 0x6f, 0x15, 0xe8, 0x3c, 0xa4, 0x34, 0x38, 0x8d, 0x75, 0x0a, 0xb6, 0x60, 0x4d, 0xf6, 0x4e,
-	0x39, 0x86, 0xe4, 0x0b, 0x1a, 0x41, 0x4b, 0x95, 0xbd, 0x01, 0xbd, 0x29, 0xba, 0xb6, 0xa3, 0xa8,
-	0x56, 0x50, 0x93, 0xa1, 0xf1, 0x76, 0xb8, 0xc0, 0xc1, 0xd6, 0x2e, 0xe5, 0x60, 0x75, 0x83, 0x83,
-	0xbd, 0x0f, 0x4d, 0xb1, 0x28, 0x4e, 0x7c, 0xa2, 0xc8, 0x59, 0x83, 0x0b, 0x9e, 0x25, 0x3e, 0x41,
-	0xfb, 0xb0, 0x1d, 0x91, 0x28, 0xc9, 0xe6, 0x6e, 0x84, 0x53, 0x97, 0x53, 0x40, 0x31, 0x56, 0xa3,
-	0x89, 0x6a, 0x5d, 0x48, 0x6a, 0x8f, 0x71, 0x7a, 0x8c, 0x67, 0x7c, 0xb2, 0x1e, 0x4f, 0xd0, 0x3e,
-	0xdc, 0xfe, 0x3a, 0x0b, 0x18, 0x9e, 0x84, 0xa4, 0x4c, 0x2d, 0x65, 0x2b, 0xdb, 0xd4, 0x4a, 0x83,
-	0x5f, 0xda, 0x7f, 0xb2, 0xa0, 0xab, 0x51, 0x53, 0x27, 0xac, 0x07, 0xd5, 0x93, 0x3c, 0xcb, 0xfc,
-	0x51, 0xe7, 0xa2, 0x72, 0x59, 0x2e, 0x96, 0xf8, 0x6d, 0x8e, 0x7c, 0xcd, 0x44, 0x3e, 0x4f, 0xfa,
-	0x9a, 0x91, 0x74, 0x0e, 0x0d, 0x9e, 0xb2, 0x33, 0x0d, 0x0d, 0x7f, 0xb6, 0x4f, 0xa1, 0x3f, 0x66,
-	0x98, 0x05, 0x94, 0x05, 0x1e, 0xd5, 0xe9, 0x5c, 0x48, 0x9c, 0x75, 0x5d, 0xe2, 0x2a, 0x97, 0x25,
-	0xae, 0x9a, 0x27, 0xce, 0xfe, 0xa7, 0x05, 0xc8, 0xdc, 0x49, 0x41, 0xf0, 0x16, 0xb6, 0xe2, 0x90,
-	0xb1, 0x84, 0x71, 0xa2, 0xc2, 0x29, 0x85, 0x22, 0x06, 0x42, 0xc2, 0xd3, 0xc7, 0x4f, 0xc3, 0x94,
-	0x12, 0x5f, 0x6a, 0x25, 0x2b, 0x68, 0x70, 0x81, 0x50, 0x96, 0x49, 0x45, 0x7d, 0x81, 0x54, 0xd8,
-	0x0f, 0xa1, 0x35, 0x66, 0x49, 0x86, 0x4f, 0xc9, 0xcb, 0x79, 0xfa, 0x26, 0xd1, 0xab, 0xe8, 0x2a,
-	0x05, 0x10, 0x23, 0x80, 0x83, 0x22, 0xfa, 0x55, 0x1d, 0xf8, 0xb7, 0x70, 0xbb, 0xb0, 0x78, 0x1a,
-	0x50, 0xa6, 0xf3, 0xf2, 0x19, 0x6c, 0x07, 0xb1, 0x17, 0x4e, 0x7d, 0xe2, 0xc6, 0x7c, 0x00, 0x86,
-	0x39, 0xaf, 0xb6, 0x04, 0x1d, 0xd9, 0x52, 0xda, 0x67, 0x42, 0xa9, 0xf9, 0xf5, 0xc7, 0x80, 0xf4,
-	0x2a, 0xe2, 0xe5, 0x2b, 0x2a, 0x62, 0x45, 0x4f, 0x69, 0x0e, 0x3d, 0x65, 0x6d, 0xbf, 0x80, 0xed,
-	0xc5, 0xcd, 0x55, 0xaa, 0x7e, 0x04, 0xad, 0x02, 0x76, 0xdd, 0x07, 0x6f, 0x1b, 0xed, 0xa7, 0x58,
-	0xe7, 0x98, 0x96, 0xf6, 0xf7, 0xe1, 0xbd, 0x42, 0xf5, 0x58, 0x34, 0xfa, 0xab, 0x06, 0xd0, 0x10,
-	0x06, 0xcb, 0xe6, 0x32, 0x06, 0xfb, 0xdf, 0x15, 0x68, 0x3f, 0x56, 0x95, 0xcb, 0x59, 0x80, 0x31,
-	0xf7, 0x9b, 0x62, 0xee, 0xdf, 0x87, 0x76, 0xa9, 0x20, 0x25, 0xa1, 0x6c, 0x5d, 0x18, 0x17, 0xbd,
-	0x55, 0x57, 0xc2, 0xaa, 0x30, 0x5b, 0xbc, 0x12, 0x3e, 0x80, 0xfe, 0x49, 0x46, 0xc8, 0xf2, 0xed,
-	0xb1, 0xe6, 0x6c, 0x70, 0x85, 0x69, 0xbb, 0x07, 0x9b, 0xd8, 0x63, 0xc1, 0xc5, 0x82, 0xb5, 0x3c,
-	0x5f, 0x7d, 0xa9, 0x32, 0xed, 0xbf, 0xc8, 0x03, 0x0d, 0xe2, 0x93, 0x84, 0x0e, 0xea, 0x6f, 0x7e,
-	0xfb, 0x53, 0x5f, 0xc3, 0x35, 0x14, 0x3d, 0x87, 0xae, 0xbe, 0x45, 0x28, 0x4f, 0xeb, 0x37, 0xbe,
-	0xa1, 0xb4, 0x49, 0xa1, 0xa2, 0xf6, 0xef, 0x2b, 0xd0, 0x70, 0xb0, 0x77, 0xfe, 0x6e, 0xe3, 0xfb,
-	0x39, 0x6c, 0xe4, 0x3d, 0xbf, 0x04, 0xf1, 0x7b, 0x06, 0x30, 0xe6, 0x51, 0x72, 0x3a, 0xbe, 0xf1,
-	0x46, 0xed, 0xff, 0x59, 0xd0, 0x7d, 0x9c, 0xcf, 0x95, 0x77, 0x1b, 0x8c, 0x7d, 0x00, 0x3e, 0x08,
-	0x4b, 0x38, 0x98, 0xc4, 0x41, 0xa7, 0xdb, 0x69, 0x66, 0xea, 0x89, 0xda, 0x7f, 0xac, 0x40, 0xfb,
-	0x65, 0x92, 0x26, 0x61, 0x72, 0x3a, 0x7f, 0xb7, 0xbf, 0xfe, 0x10, 0xfa, 0x06, 0x67, 0x28, 0x81,
-	0x70, 0x67, 0xe1, 0x30, 0x14, 0xc9, 0x76, 0x36, 0xfc, 0xd2, 0x3b, 0xb5, 0x37, 0xa1, 0xaf, 0x78,
-	0x71, 0xd1, 0x92, 0xed, 0xdf, 0x59, 0x80, 0x4c, 0xa9, 0xea, 0x95, 0x3f, 0x85, 0x0e, 0x53, 0xd8,
-	0x89, 0xfd, 0xd4, 0xe5, 0xc0, 0x3c, 0x7b, 0x26, 0xb6, 0x4e, 0x9b, 0x99, 0x48, 0xff, 0x00, 0xb6,
-	0x96, 0x6e, 0xf8, 0x9c, 0x90, 0x48, 0x84, 0xfb, 0x0b, 0x97, 0xfc, 0xe3, 0x89, 0xfd, 0x19, 0xdc,
-	0x96, 0x24, 0x54, 0xf7, 0x71, 0xdd, 0x5f, 0x97, 0xd8, 0x64, 0xa7, 0x60, 0x93, 0xf6, 0x7f, 0x2d,
-	0xd8, 0x5e, 0x5c, 0xa6, 0xe2, 0xbf, 0x6a, 0x1d, 0xc2, 0x80, 0x54, 0xbf, 0x31, 0x79, 0xb1, 0xa4,
-	0xa3, 0x9f, 0x2e, 0xf1, 0xe2, 0x45, 0xdf, 0x7b, 0xba, 0x0f, 0x15, 0xd4, 0xb8, 0x47, 0xcb, 0x02,
-	0x3a, 0xc4, 0xd0, 0x5f, 0x32, 0xe3, 0xb7, 0x0a, 0xbd, 0xaf, 0x8a, 0x69, 0x5d, 0x2d, 0xfc, 0x16,
-	0xc4, 0xd8, 0xde, 0x81, 0xbb, 0x5f, 0x12, 0x76, 0x2c, 0x6c, 0x0e, 0x92, 0xf8, 0x24, 0x38, 0x9d,
-	0x66, 0xd2, 0xa8, 0x48, 0xed, 0xbd, 0xcb, 0x2c, 0x14, 0x4c, 0x2b, 0x7e, 0x46, 0xb1, 0x6e, 0xfc,
-	0x33, 0x4a, 0xe5, 0xaa, 0x9f, 0x51, 0xf6, 0xff, 0x55, 0x87, 0xf5, 0x31, 0xc1, 0xaf, 0x09, 0xf1,
-	0xd1, 0x11, 0x74, 0xc6, 0x24, 0xf6, 0x8b, 0x1f, 0x48, 0xb7, 0x8c, 0x6f, 0xcc, 0xa5, 0xc3, 0xef,
-	0xac, 0x92, 0xe6, 0x23, 0xf4, 0xd6, 0xae, 0xf5, 0x89, 0x85, 0x5e, 0x40, 0xa7, 0x74, 0x23, 0x44,
-	0x3b, 0xc6, 0xa2, 0x55, 0x77, 0xc5, 0xe1, 0x9d, 0xa5, 0x81, 0xa2, 0x51, 0xcd, 0x5d, 0xb6, 0xcd,
-	0x9b, 0x10, 0xba, 0x77, 0xe9, 0x15, 0x49, 0x3a, 0xdc, 0xb9, 0xe6, 0x0a, 0x65, 0xdf, 0x42, 0x9f,
-	0x43, 0x5d, 0x52, 0x66, 0x34, 0x30, 0x8c, 0x4b, 0x77, 0x8f, 0x52, 0x5c, 0x65, 0x7e, 0x6d, 0xdf,
-	0x42, 0x4f, 0x00, 0x0a, 0xd2, 0x89, 0x4c, 0x60, 0x96, 0x58, 0xef, 0xf0, 0xee, 0x25, 0xda, 0xdc,
-	0xd9, 0xd7, 0xd0, 0x2d, 0x53, 0x23, 0x34, 0x5a, 0xc9, 0x7e, 0x8c, 0xfe, 0x30, 0xbc, 0x7f, 0x85,
-	0x45, 0xee, 0xf8, 0x57, 0xd0, 0x5b, 0x64, 0x3c, 0xc8, 0x5e, 0xb9, 0xb0, 0xc4, 0x9e, 0x86, 0x1f,
-	0x5c, 0x69, 0x63, 0x82, 0x50, 0xb4, 0xa8, 0x12, 0x08, 0x4b, 0xfd, 0xac, 0x04, 0xc2, 0x72, 0x5f,
-	0x93, 0x20, 0x94, 0xeb, 0xba, 0x04, 0xc2, 0xca, 0x2e, 0x54, 0x02, 0x61, 0x75, 0x53, 0xb0, 0x6f,
-	0xa1, 0x04, 0xb6, 0x57, 0x57, 0x1b, 0x32, 0x7f, 0x52, 0xb9, 0xb2, 0x64, 0x87, 0x1f, 0xbd, 0x81,
-	0xa5, 0xde, 0x70, 0x52, 0x17, 0xff, 0x3e, 0x7c, 0xfa, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x44,
-	0x05, 0x7a, 0xc2, 0x8d, 0x18, 0x00, 0x00,
+	// 2183 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0x1b, 0xc7,
+	0x15, 0xf7, 0x92, 0x94, 0x48, 0x3e, 0x7e, 0x8f, 0x64, 0x85, 0x66, 0x62, 0x8b, 0xde, 0xa4, 0x88,
+	0xec, 0xa6, 0x6a, 0xaa, 0x04, 0x68, 0xd0, 0x34, 0x08, 0x2c, 0x59, 0x71, 0x05, 0x5b, 0x8a, 0xbd,
+	0x72, 0x1d, 0xa0, 0x40, 0xb1, 0x19, 0xee, 0x8e, 0xa4, 0x85, 0xf6, 0xab, 0xbb, 0x43, 0x59, 0x4c,
+	0x2f, 0x05, 0x7a, 0xec, 0xa9, 0xe8, 0xa1, 0xff, 0x42, 0x2f, 0x3d, 0xb5, 0x97, 0x5e, 0x72, 0xe9,
+	0x7f, 0xd4, 0x6b, 0x2e, 0xc5, 0x7c, 0xed, 0xce, 0x2e, 0x49, 0x29, 0x0a, 0x90, 0x83, 0x6f, 0xbb,
+	0xef, 0xbd, 0x79, 0xf3, 0xf6, 0xf7, 0xe6, 0xbd, 0xf9, 0x3d, 0x12, 0xda, 0x01, 0x4e, 0x29, 0x49,
+	0xb6, 0xe3, 0x24, 0xa2, 0x11, 0x6a, 0x8a, 0x37, 0x3b, 0x9e, 0x98, 0x7f, 0x59, 0x85, 0xe6, 0x6f,
+	0x08, 0x4e, 0xe8, 0x84, 0x60, 0x8a, 0xba, 0x50, 0xf1, 0xe2, 0xa1, 0x31, 0x36, 0xb6, 0x9a, 0x56,
+	0xc5, 0x8b, 0x11, 0x82, 0x5a, 0x1c, 0x25, 0x74, 0x58, 0x19, 0x1b, 0x5b, 0x1d, 0x8b, 0x3f, 0xa3,
+	0xbb, 0x00, 0xf1, 0x74, 0xe2, 0x7b, 0x8e, 0x3d, 0x4d, 0xfc, 0x61, 0x95, 0xdb, 0x36, 0x85, 0xe4,
+	0xb7, 0x89, 0x8f, 0xb6, 0xa0, 0x1f, 0xe0, 0x4b, 0xfb, 0x22, 0xf2, 0xa7, 0x01, 0xb1, 0x9d, 0x68,
+	0x1a, 0xd2, 0x61, 0x8d, 0x2f, 0xef, 0x06, 0xf8, 0xf2, 0x15, 0x17, 0xef, 0x31, 0x29, 0x1a, 0xb3,
+	0xa8, 0x2e, 0xed, 0x13, 0xcf, 0x27, 0xf6, 0x39, 0x99, 0x0d, 0x57, 0xc6, 0xc6, 0x56, 0xcd, 0x82,
+	0x00, 0x5f, 0x7e, 0xe1, 0xf9, 0xe4, 0x29, 0x99, 0xa1, 0x4d, 0x68, 0xb9, 0x98, 0x62, 0xdb, 0x21,
+	0x21, 0x25, 0xc9, 0x70, 0x95, 0xef, 0x05, 0x4c, 0xb4, 0xc7, 0x25, 0x2c, 0xbe, 0x04, 0x3b, 0xe7,
+	0xc3, 0x3a, 0xd7, 0xf0, 0x67, 0x16, 0x1f, 0x76, 0x03, 0x2f, 0xb4, 0x79, 0xe4, 0x0d, 0xbe, 0x75,
+	0x93, 0x4b, 0x9e, 0xb3, 0xf0, 0x3f, 0x83, 0xba, 0x88, 0x2d, 0x1d, 0x36, 0xc7, 0xd5, 0xad, 0xd6,
+	0xce, 0xbb, 0xdb, 0x19, 0x1a, 0xdb, 0x22, 0xbc, 0x83, 0xf0, 0x24, 0x4a, 0x02, 0x4c, 0xbd, 0x28,
+	0x3c, 0x24, 0x69, 0x8a, 0x4f, 0x89, 0xa5, 0xd6, 0xa0, 0x03, 0x68, 0x85, 0xe4, 0xb5, 0xad, 0x5c,
+	0x00, 0x77, 0xb1, 0x35, 0xe7, 0xe2, 0xf8, 0x2c, 0x4a, 0xe8, 0x02, 0x3f, 0x10, 0x92, 0xd7, 0xaf,
+	0xa4, 0xab, 0x17, 0xd0, 0x73, 0x89, 0x4f, 0x28, 0x71, 0x33, 0x77, 0xad, 0x1b, 0xba, 0xeb, 0x4a,
+	0x07, 0xca, 0xe5, 0x7b, 0xd0, 0x3d, 0xc3, 0xa9, 0x1d, 0x46, 0x99, 0xc7, 0xf6, 0xd8, 0xd8, 0x6a,
+	0x58, 0xed, 0x33, 0x9c, 0x1e, 0x45, 0xca, 0xea, 0x09, 0x34, 0x89, 0x63, 0xa7, 0x67, 0x38, 0x71,
+	0xd3, 0x61, 0x9f, 0x6f, 0xf9, 0x70, 0x6e, 0xcb, 0x7d, 0xe7, 0x98, 0x19, 0x2c, 0xd8, 0xb4, 0x41,
+	0x84, 0x2a, 0x45, 0x47, 0xd0, 0x61, 0x60, 0xe4, 0xce, 0x06, 0x37, 0x76, 0xc6, 0xd0, 0xdc, 0x57,
+	0xfe, 0x5e, 0xc1, 0x40, 0x21, 0x92, 0xfb, 0x44, 0x37, 0xf6, 0xa9, 0x60, 0xcd, 0xfc, 0xbe, 0x0f,
+	0x7d, 0x09, 0x4b, 0xee, 0x76, 0x8d, 0x03, 0xd3, 0xe1, 0xc0, 0x28, 0x43, 0xf3, 0x4f, 0x15, 0x18,
+	0x64, 0xd5, 0x60, 0x91, 0x34, 0x8e, 0xc2, 0x94, 0xa0, 0x87, 0x30, 0x90, 0xc7, 0x39, 0xf5, 0xbe,
+	0x21, 0xb6, 0xef, 0x05, 0x1e, 0xe5, 0x45, 0x52, 0xb3, 0x7a, 0x42, 0x71, 0xec, 0x7d, 0x43, 0x9e,
+	0x31, 0x31, 0xda, 0x80, 0x55, 0x9f, 0x60, 0x97, 0x24, 0xbc, 0x66, 0x9a, 0x96, 0x7c, 0x43, 0xef,
+	0x43, 0x2f, 0x20, 0x34, 0xf1, 0x9c, 0xd4, 0xc6, 0xae, 0x9b, 0x90, 0x34, 0x95, 0xa5, 0xd3, 0x95,
+	0xe2, 0x47, 0x42, 0x8a, 0x3e, 0x81, 0xa1, 0x32, 0xf4, 0xd8, 0x19, 0xbf, 0xc0, 0xbe, 0x9d, 0x12,
+	0x27, 0x0a, 0xdd, 0x54, 0xd6, 0xd1, 0x86, 0xd4, 0x1f, 0x48, 0xf5, 0xb1, 0xd0, 0xa2, 0xc7, 0xd0,
+	0x4f, 0x69, 0x94, 0xe0, 0x53, 0x62, 0x4f, 0xb0, 0x73, 0x4e, 0xd8, 0x8a, 0x15, 0x0e, 0xde, 0x1d,
+	0x0d, 0xbc, 0x63, 0x61, 0xb2, 0x2b, 0x2c, 0xac, 0x5e, 0x5a, 0x78, 0x4f, 0xcd, 0xef, 0xaa, 0x30,
+	0x5c, 0x56, 0x06, 0xbc, 0x3f, 0xb8, 0xfc, 0xd3, 0x3b, 0x56, 0xc5, 0x73, 0x59, 0xfd, 0x31, 0x48,
+	0xf8, 0xb7, 0xd6, 0x2c, 0xfe, 0x8c, 0xee, 0x01, 0x38, 0x91, 0xef, 0x13, 0x87, 0x2d, 0x94, 0x1f,
+	0xa9, 0x49, 0x58, 0x7d, 0xf2, 0x92, 0xcf, 0x5b, 0x43, 0xcd, 0x6a, 0x32, 0x89, 0xe8, 0x0a, 0xf7,
+	0xa1, 0x2d, 0xd2, 0x27, 0x0d, 0x44, 0x57, 0x68, 0x09, 0x99, 0x30, 0xf9, 0x00, 0x90, 0x3a, 0x26,
+	0x93, 0x59, 0x66, 0xb8, 0xca, 0x0d, 0xfb, 0x52, 0xb3, 0x3b, 0x53, 0xd6, 0x6f, 0x43, 0x33, 0x21,
+	0xd8, 0xb5, 0xa3, 0xd0, 0x9f, 0xf1, 0x46, 0xd1, 0xb0, 0x1a, 0x4c, 0xf0, 0x65, 0xe8, 0xcf, 0xd0,
+	0x4f, 0x61, 0x90, 0x90, 0xd8, 0xf7, 0x1c, 0x6c, 0xc7, 0x3e, 0x76, 0x48, 0x40, 0x42, 0xd5, 0x33,
+	0xfa, 0x52, 0xf1, 0x5c, 0xc9, 0xd1, 0x10, 0xea, 0x17, 0x24, 0x49, 0xd9, 0x67, 0x35, 0xb9, 0x89,
+	0x7a, 0x45, 0x7d, 0xa8, 0x52, 0xea, 0x0f, 0x81, 0x4b, 0xd9, 0x23, 0x7a, 0x00, 0x7d, 0x27, 0x0a,
+	0x62, 0xec, 0x50, 0x3b, 0x21, 0x17, 0x1e, 0x5f, 0xd4, 0xe2, 0xea, 0x9e, 0x94, 0x5b, 0x52, 0xcc,
+	0x3e, 0x27, 0x88, 0x5c, 0xef, 0xc4, 0x23, 0xae, 0x8d, 0xa9, 0x4c, 0x36, 0x2f, 0xdc, 0xaa, 0xd5,
+	0x57, 0x9a, 0x47, 0x54, 0xa4, 0x19, 0x6d, 0xc3, 0x5a, 0x42, 0x82, 0x88, 0x12, 0x5b, 0x25, 0x3b,
+	0xc4, 0x01, 0x19, 0x76, 0x38, 0xce, 0x03, 0xa1, 0x92, 0x39, 0x3e, 0xc2, 0x01, 0x61, 0xde, 0x4b,
+	0xf6, 0xac, 0xd7, 0x76, 0xb9, 0x79, 0xbf, 0x60, 0xfe, 0x94, 0xcc, 0xcc, 0x7f, 0x18, 0x70, 0xf7,
+	0xca, 0x96, 0x33, 0x77, 0x04, 0xae, 0x4b, 0xf7, 0x8f, 0x85, 0xb0, 0x39, 0x85, 0xcd, 0x6b, 0x1a,
+	0xc1, 0x35, 0xb1, 0x56, 0xe6, 0x62, 0x35, 0xa1, 0x43, 0x1c, 0xdb, 0x0b, 0x5d, 0x72, 0x69, 0x4f,
+	0x3c, 0x2a, 0x4a, 0xb4, 0x63, 0xb5, 0x88, 0x73, 0xc0, 0x64, 0xbb, 0x1e, 0x4d, 0xcd, 0x6f, 0x0d,
+	0xe8, 0x16, 0x6b, 0x88, 0x55, 0x01, 0x9d, 0xc5, 0x44, 0xde, 0x9b, 0xfc, 0x59, 0x6e, 0x5d, 0x91,
+	0x37, 0xa9, 0x8b, 0x0e, 0x00, 0xe2, 0x24, 0x8a, 0x49, 0x42, 0x3d, 0xc2, 0xfc, 0xb2, 0xb2, 0x7c,
+	0xb0, 0xb4, 0x2c, 0xb7, 0x9f, 0x67, 0xb6, 0xfb, 0x21, 0x4d, 0x66, 0x96, 0xb6, 0x78, 0xf4, 0x19,
+	0xf4, 0x4a, 0x6a, 0x86, 0x0e, 0xcb, 0xaa, 0x08, 0x80, 0x3d, 0xa2, 0x75, 0x58, 0xb9, 0xc0, 0xfe,
+	0x94, 0xc8, 0x10, 0xc4, 0xcb, 0xaf, 0x2a, 0x9f, 0x18, 0x66, 0x1d, 0x56, 0xf6, 0x83, 0x98, 0xce,
+	0xd8, 0x97, 0xf4, 0x8e, 0xa7, 0x31, 0x49, 0x76, 0xfd, 0xc8, 0x39, 0xdf, 0xbf, 0xa4, 0x09, 0x46,
+	0x5f, 0x42, 0x97, 0x24, 0x38, 0x9d, 0x26, 0xac, 0xaa, 0x5c, 0x2f, 0x3c, 0xe5, 0x3e, 0x8b, 0x57,
+	0x52, 0x69, 0xcd, 0xf6, 0xbe, 0x58, 0xb0, 0xc7, 0xed, 0xad, 0x0e, 0xd1, 0x5f, 0x47, 0xbf, 0x83,
+	0x4e, 0x41, 0xcf, 0xc0, 0x62, 0x17, 0xb8, 0xcc, 0x0a, 0x7f, 0x66, 0x4d, 0x33, 0xc6, 0x89, 0x47,
+	0x67, 0x92, 0x68, 0xc8, 0x37, 0xd6, 0x2a, 0x64, 0xe3, 0xf5, 0x5c, 0x01, 0x5a, 0xc7, 0x6a, 0x0a,
+	0xc9, 0x81, 0x9b, 0x9a, 0x4f, 0x60, 0xfd, 0x29, 0x21, 0xf1, 0x5e, 0x14, 0x86, 0xc4, 0xa1, 0xc4,
+	0xb5, 0xc8, 0x1f, 0xa6, 0x24, 0xa5, 0x6c, 0x0b, 0x5e, 0x13, 0x32, 0x1f, 0xec, 0x99, 0x75, 0x81,
+	0xd3, 0x24, 0x76, 0x6c, 0x8d, 0xce, 0x34, 0x98, 0x80, 0x71, 0x02, 0xf3, 0xef, 0x06, 0x74, 0xc5,
+	0x59, 0x7a, 0x16, 0x39, 0xfc, 0x04, 0x31, 0x44, 0x19, 0xbd, 0x91, 0x88, 0x4e, 0x13, 0xbf, 0xc4,
+	0x7b, 0x2a, 0x65, 0xde, 0x73, 0x07, 0x1a, 0x9c, 0x18, 0xe4, 0x91, 0xd6, 0xd9, 0x5d, 0xef, 0xb9,
+	0x69, 0xde, 0xd2, 0x5c, 0xa1, 0xae, 0x71, 0x75, 0x4b, 0xdd, 0xdd, 0xcc, 0x24, 0xbf, 0x36, 0x56,
+	0xf4, 0x6b, 0xc3, 0x7c, 0x09, 0x6b, 0xcf, 0xa2, 0xe8, 0x7c, 0x1a, 0x8b, 0xf0, 0xd4, 0x17, 0x16,
+	0x81, 0x31, 0xc6, 0x55, 0x16, 0x4b, 0x06, 0xcc, 0x75, 0xe7, 0xdc, 0xfc, 0x9f, 0x01, 0xeb, 0x45,
+	0xb7, 0xf2, 0xa6, 0xfb, 0x1a, 0xd6, 0x32, 0xbf, 0xb6, 0x2f, 0xb1, 0x10, 0x1b, 0xb4, 0x76, 0x3e,
+	0xd4, 0xce, 0xc0, 0xa2, 0xd5, 0x8a, 0x3d, 0xb9, 0x0a, 0x44, 0x6b, 0x70, 0x51, 0x92, 0xa4, 0xa3,
+	0x4b, 0xe8, 0x97, 0xcd, 0x58, 0x6e, 0xb2, 0x5d, 0x25, 0xe2, 0x0d, 0xb5, 0x12, 0xfd, 0x02, 0x9a,
+	0x79, 0x20, 0x15, 0x1e, 0xc8, 0x5a, 0x21, 0x10, 0xb9, 0x57, 0x6e, 0xc5, 0xce, 0x3e, 0x49, 0x92,
+	0x28, 0x91, 0xdd, 0x48, 0xbc, 0x98, 0x9f, 0x42, 0xe3, 0x07, 0x67, 0xd7, 0xfc, 0x57, 0x05, 0x3a,
+	0x8f, 0xd2, 0xd4, 0x3b, 0x0d, 0x55, 0x0a, 0xd6, 0x61, 0x45, 0xdc, 0x3b, 0x82, 0x08, 0x88, 0x17,
+	0x34, 0x86, 0x96, 0x6c, 0x6a, 0x1a, 0xf4, 0xba, 0xe8, 0xda, 0x7e, 0x29, 0x1b, 0x5d, 0x4d, 0x84,
+	0xc6, 0xae, 0x92, 0x12, 0x0b, 0x5e, 0x59, 0xca, 0x82, 0x57, 0x35, 0x16, 0xfc, 0x36, 0x34, 0xf9,
+	0xa2, 0x30, 0x72, 0x89, 0xa4, 0xc7, 0x0d, 0x26, 0x38, 0x8a, 0x5c, 0x82, 0x76, 0x60, 0x23, 0x20,
+	0x41, 0x94, 0xcc, 0xec, 0x00, 0xc7, 0x36, 0x23, 0xe1, 0x9c, 0xd8, 0x04, 0x13, 0xd9, 0x98, 0x91,
+	0xd0, 0x1e, 0xe2, 0xf8, 0x10, 0x5f, 0x32, 0x6e, 0x73, 0x38, 0x41, 0x3b, 0x70, 0xfb, 0xab, 0xc4,
+	0xa3, 0x78, 0xe2, 0x93, 0x22, 0xb9, 0x17, 0x8d, 0x7a, 0x4d, 0x29, 0x35, 0x86, 0x6f, 0xfe, 0xcd,
+	0x80, 0xae, 0x42, 0x4d, 0x9e, 0xb0, 0x3e, 0x54, 0x4f, 0xb2, 0x2c, 0xb3, 0x47, 0x95, 0x8b, 0xca,
+	0xb2, 0x5c, 0xcc, 0x4d, 0x18, 0x19, 0xf2, 0x35, 0x1d, 0xf9, 0x2c, 0xe9, 0x2b, 0x5a, 0xd2, 0x19,
+	0x34, 0x78, 0x4a, 0xcf, 0x14, 0x34, 0xec, 0xd9, 0x3c, 0x85, 0xc1, 0x31, 0xc5, 0xd4, 0x4b, 0xa9,
+	0xe7, 0xa4, 0x2a, 0x9d, 0xa5, 0xc4, 0x19, 0xd7, 0x25, 0xae, 0xb2, 0x2c, 0x71, 0xd5, 0x2c, 0x71,
+	0xe6, 0x7f, 0x0d, 0x40, 0xfa, 0x4e, 0x12, 0x82, 0x1f, 0x61, 0x2b, 0x06, 0x19, 0x8d, 0x28, 0xa3,
+	0x8a, 0x8c, 0x8e, 0x49, 0x52, 0xc5, 0x25, 0x2c, 0x7d, 0xec, 0x34, 0x4c, 0x53, 0xe2, 0x0a, 0xad,
+	0x60, 0x54, 0x0d, 0x26, 0xe0, 0xca, 0x22, 0x21, 0x5b, 0x2d, 0x11, 0x32, 0xf3, 0x11, 0xb4, 0xe4,
+	0xe5, 0xf4, 0x92, 0x5d, 0x6c, 0xd7, 0x47, 0x2f, 0xa3, 0xab, 0xe4, 0x40, 0x8c, 0x01, 0xf6, 0xf2,
+	0xe8, 0x17, 0xb4, 0x67, 0xf3, 0x8f, 0x70, 0x3b, 0xb7, 0x78, 0xe6, 0xa5, 0x54, 0xe5, 0xe5, 0x63,
+	0xd8, 0xf0, 0x42, 0xc7, 0x9f, 0xba, 0xc4, 0x0e, 0xd9, 0xf5, 0xee, 0x67, 0x93, 0x8d, 0xc1, 0xa9,
+	0xdc, 0xba, 0xd4, 0x1e, 0x71, 0xa5, 0x9a, 0x70, 0x3e, 0x00, 0xa4, 0x56, 0x11, 0x27, 0x5b, 0x51,
+	0xe1, 0x2b, 0xfa, 0x52, 0xb3, 0xef, 0x48, 0x6b, 0xf3, 0x05, 0x6c, 0x94, 0x37, 0x97, 0xa9, 0xfa,
+	0x25, 0xb4, 0x72, 0xd8, 0x55, 0x1f, 0xbc, 0xad, 0xb5, 0x9f, 0x7c, 0x9d, 0xa5, 0x5b, 0x9a, 0x3f,
+	0x83, 0xb7, 0x72, 0xd5, 0x63, 0xde, 0xe8, 0xaf, 0xb8, 0x9d, 0xcc, 0x11, 0x0c, 0xe7, 0xcd, 0x45,
+	0x0c, 0xe6, 0x5f, 0xab, 0xd0, 0x7e, 0x2c, 0x2b, 0x97, 0x71, 0x1c, 0x8d, 0xd5, 0x08, 0x6a, 0x71,
+	0x1f, 0xda, 0x85, 0x82, 0x14, 0x64, 0xbc, 0x75, 0xa1, 0x8d, 0xda, 0x8b, 0x86, 0xf2, 0x2a, 0x37,
+	0x2b, 0x0f, 0xe5, 0x0f, 0x61, 0x70, 0x92, 0x10, 0x32, 0x3f, 0xbf, 0xd7, 0xac, 0x1e, 0x53, 0xe8,
+	0xb6, 0xdb, 0xb0, 0x86, 0x1d, 0xea, 0x5d, 0x94, 0xac, 0xc5, 0xf9, 0x1a, 0x08, 0x95, 0x6e, 0xff,
+	0x45, 0x16, 0xa8, 0x17, 0x9e, 0x44, 0xe9, 0x70, 0xf5, 0xfb, 0xcf, 0xdf, 0xf2, 0x6b, 0x98, 0x26,
+	0x45, 0xcf, 0xa1, 0xab, 0xe6, 0x38, 0xe9, 0xa9, 0x7e, 0xe3, 0x19, 0xb1, 0x4d, 0x72, 0x55, 0xaa,
+	0x91, 0xea, 0xc2, 0x97, 0x34, 0xc4, 0x97, 0x08, 0x95, 0xde, 0xd8, 0xfe, 0x5d, 0x81, 0x86, 0x85,
+	0x9d, 0xf3, 0x37, 0x3b, 0x1f, 0x9f, 0x43, 0x2f, 0xbb, 0x23, 0x0a, 0x29, 0x79, 0x4b, 0x03, 0x52,
+	0x3f, 0x7a, 0x56, 0xc7, 0xd5, 0xde, 0x96, 0xc2, 0x56, 0x5f, 0x06, 0xdb, 0x3f, 0x2b, 0xd0, 0x7d,
+	0x9c, 0xdd, 0x5b, 0x6f, 0x36, 0x78, 0x3b, 0x00, 0xec, 0xa2, 0x2d, 0xe0, 0xa6, 0x13, 0x13, 0x75,
+	0x3c, 0xac, 0x66, 0x22, 0x9f, 0x6e, 0x8e, 0xd7, 0xb7, 0x15, 0x68, 0xbf, 0x8c, 0xe2, 0xc8, 0x8f,
+	0x4e, 0x67, 0x6f, 0x36, 0x5a, 0xfb, 0x30, 0xd0, 0x38, 0x4c, 0x01, 0xb4, 0x3b, 0xa5, 0xc3, 0x96,
+	0x1f, 0x0e, 0xab, 0xe7, 0x16, 0xde, 0x6f, 0x0e, 0xe0, 0x1a, 0x0c, 0x24, 0xaf, 0xcf, 0xaf, 0x14,
+	0xf3, 0xcf, 0x06, 0x20, 0x5d, 0x2a, 0x7b, 0xfd, 0xaf, 0xa1, 0x43, 0x25, 0xd6, 0x3c, 0x3e, 0x39,
+	0xf9, 0xe8, 0xb5, 0xa0, 0xe7, 0xc2, 0x6a, 0x53, 0x3d, 0x33, 0x3f, 0x87, 0xf5, 0xb9, 0xdf, 0x88,
+	0x18, 0xa1, 0x12, 0x19, 0x19, 0x94, 0x7e, 0x26, 0x3a, 0x9c, 0x98, 0x1f, 0xc3, 0x6d, 0x41, 0xa2,
+	0xd5, 0x3d, 0xa4, 0xee, 0x87, 0x39, 0x36, 0xdc, 0xc9, 0xd9, 0xb0, 0xf9, 0x9d, 0x01, 0x1b, 0xe5,
+	0x65, 0x32, 0xfe, 0xab, 0xd6, 0x21, 0x0c, 0x48, 0xf6, 0x4b, 0x9d, 0xd7, 0x0b, 0x3a, 0xfd, 0xd1,
+	0x1c, 0xaf, 0x2f, 0xfb, 0xde, 0x56, 0x7d, 0x34, 0xa7, 0xf6, 0xfd, 0xb4, 0x28, 0x48, 0x47, 0x18,
+	0x06, 0x73, 0x66, 0x6c, 0x2a, 0x52, 0xfb, 0xca, 0x98, 0xea, 0x72, 0xe1, 0x0f, 0x20, 0xf6, 0xe6,
+	0x26, 0xdc, 0x7d, 0x42, 0xe8, 0x21, 0xb7, 0xd9, 0x8b, 0xc2, 0x13, 0xef, 0x74, 0x9a, 0x08, 0xa3,
+	0x3c, 0xb5, 0xf7, 0x96, 0x59, 0x48, 0x98, 0x16, 0xfc, 0x10, 0x67, 0xdc, 0xf8, 0x87, 0xb8, 0xca,
+	0x55, 0x3f, 0xc4, 0x99, 0x9f, 0xc2, 0x90, 0x9d, 0x2c, 0x19, 0x85, 0xef, 0x91, 0x90, 0x66, 0x3c,
+	0x73, 0x13, 0x5a, 0x0e, 0x97, 0xd8, 0xda, 0x4f, 0x06, 0x20, 0x44, 0x8c, 0x5f, 0x99, 0xbb, 0x70,
+	0x67, 0xc1, 0x62, 0x19, 0xfc, 0x4f, 0xa0, 0xcb, 0xa7, 0x58, 0x19, 0x39, 0x51, 0xb3, 0x5f, 0x87,
+	0x49, 0x1f, 0x29, 0xe1, 0xce, 0x7f, 0xea, 0x50, 0x3f, 0x26, 0xf8, 0x35, 0x21, 0x2e, 0x3a, 0x80,
+	0xce, 0x31, 0x09, 0xdd, 0xfc, 0x37, 0xfe, 0x75, 0x0d, 0xe4, 0x4c, 0x3a, 0x7a, 0x67, 0x91, 0x34,
+	0xe3, 0x20, 0xb7, 0xb6, 0x8c, 0x0f, 0x0d, 0xf4, 0x02, 0x3a, 0x85, 0x79, 0x1b, 0x6d, 0x6a, 0x8b,
+	0x16, 0x4d, 0xe2, 0xa3, 0x3b, 0x73, 0x37, 0xb2, 0x4a, 0x6b, 0xe6, 0xb2, 0xad, 0x8f, 0x92, 0xe8,
+	0xde, 0xd2, 0x19, 0x53, 0x38, 0xdc, 0xbc, 0x66, 0x06, 0x35, 0x6f, 0xa1, 0xcf, 0x61, 0x55, 0xcc,
+	0x1c, 0x68, 0xa8, 0x19, 0x17, 0x86, 0xb7, 0x42, 0x5c, 0xc5, 0x01, 0xc5, 0xbc, 0x85, 0x9e, 0x02,
+	0xe4, 0xac, 0x1d, 0xbd, 0x53, 0xf8, 0x91, 0xa6, 0x34, 0x36, 0x8c, 0xee, 0x2e, 0xd1, 0x66, 0xce,
+	0xbe, 0x82, 0x6e, 0x91, 0x5b, 0xa2, 0xf1, 0x42, 0xfa, 0xa8, 0x35, 0xa8, 0xd1, 0xfd, 0x2b, 0x2c,
+	0x32, 0xc7, 0xbf, 0x87, 0x7e, 0x99, 0x32, 0x22, 0x73, 0xe1, 0xc2, 0x02, 0xfd, 0x1c, 0xbd, 0x7b,
+	0xa5, 0x8d, 0x0e, 0x42, 0xde, 0x23, 0x0b, 0x20, 0xcc, 0x35, 0xd4, 0x02, 0x08, 0xf3, 0x8d, 0x55,
+	0x80, 0x50, 0x6c, 0x2c, 0x05, 0x10, 0x16, 0xb6, 0xc1, 0x02, 0x08, 0x8b, 0xbb, 0x92, 0x79, 0x0b,
+	0x45, 0xb0, 0xb1, 0xb8, 0xdc, 0x91, 0xfe, 0x83, 0xd5, 0x95, 0x3d, 0x63, 0xf4, 0xe0, 0x7b, 0x58,
+	0x66, 0x1b, 0x7e, 0x0d, 0x83, 0xb9, 0xea, 0x44, 0x3a, 0xa4, 0xcb, 0x0a, 0x7f, 0xf4, 0xde, 0xd5,
+	0x46, 0x6a, 0x87, 0xc9, 0x2a, 0xff, 0x8b, 0xee, 0xa3, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0x6a,
+	0xee, 0xfc, 0x90, 0xb2, 0x1b, 0x00, 0x00,
 }
diff --git a/weed/pb/proto_read_write_test.go b/weed/pb/proto_read_write_test.go
new file mode 100644
index 000000000..7f6444ab5
--- /dev/null
+++ b/weed/pb/proto_read_write_test.go
@@ -0,0 +1,43 @@
+package pb
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
+	"github.com/golang/protobuf/jsonpb"
+)
+
+func TestJsonpMarshalUnmarshal(t *testing.T) {
+
+	tv := &volume_server_pb.RemoteFile{
+		BackendType: "aws",
+		BackendId:   "",
+		FileSize:    12,
+	}
+
+	m := jsonpb.Marshaler{
+		EmitDefaults: true,
+		Indent:       "  ",
+	}
+
+	if text, err := m.MarshalToString(tv); err != nil {
+		fmt.Printf("marshal eror: %v\n", err)
+	} else {
+		fmt.Printf("marshalled: %s\n", text)
+	}
+
+	rawJson := `{
+		"backendType":"aws",
+		"backendId":"temp",
+		"FileSize":12
+	}`
+
+	tv1 := &volume_server_pb.RemoteFile{}
+	if err := jsonpb.UnmarshalString(rawJson, tv1); err != nil {
+		fmt.Printf("unmarshal error: %v\n", err)
+	}
+
+	fmt.Printf("unmarshalled: %+v\n", tv1)
+
+}
diff --git a/weed/pb/queue.proto b/weed/pb/queue.proto
new file mode 100644
index 000000000..39b6ee05a
--- /dev/null
+++ b/weed/pb/queue.proto
@@ -0,0 +1,66 @@
+syntax = "proto3";
+
+package queue_pb;
+
+option java_package = "seaweedfs.client";
+option java_outer_classname = "QueueProto";
+
+//////////////////////////////////////////////////
+
+service SeaweedQueue {
+
+    rpc StreamWrite (stream WriteMessageRequest) returns (stream WriteMessageResponse) {
+    }
+
+    rpc StreamRead (ReadMessageRequest) returns (stream ReadMessageResponse) {
+    }
+
+    rpc ConfigureTopic (ConfigureTopicRequest) returns (ConfigureTopicResponse) {
+    }
+
+    rpc DeleteTopic (DeleteTopicRequest) returns (DeleteTopicResponse) {
+    }
+
+}
+
+//////////////////////////////////////////////////
+
+
+message WriteMessageRequest {
+    string topic = 1;
+    int64 event_ns = 2;
+    bytes partition_key = 3;
+    bytes data = 4;
+}
+
+message WriteMessageResponse {
+    string error = 1;
+    int64 ack_ns = 2;
+}
+
+message ReadMessageRequest {
+    string topic = 1;
+    int64 start_ns = 2;
+}
+
+message ReadMessageResponse {
+    string error = 1;
+    int64 event_ns = 2;
+    bytes data = 3;
+}
+
+message ConfigureTopicRequest {
+    string topic = 1;
+    int64 ttl_seconds = 2;
+    int32 partition_count = 3;
+}
+message ConfigureTopicResponse {
+    string error = 1;
+}
+
+message DeleteTopicRequest {
+    string topic = 1;
+}
+message DeleteTopicResponse {
+    string error = 1;
+}
diff --git a/weed/pb/queue_pb/queue.pb.go b/weed/pb/queue_pb/queue.pb.go
new file mode 100644
index 000000000..8ec4d62aa
--- /dev/null
+++ b/weed/pb/queue_pb/queue.pb.go
@@ -0,0 +1,516 @@
+// Code generated by protoc-gen-go.
+// source: queue.proto
+// DO NOT EDIT!
+
+/*
+Package queue_pb is a generated protocol buffer package.
+
+It is generated from these files:
+	queue.proto
+
+It has these top-level messages:
+	WriteMessageRequest
+	WriteMessageResponse
+	ReadMessageRequest
+	ReadMessageResponse
+	ConfigureTopicRequest
+	ConfigureTopicResponse
+	DeleteTopicRequest
+	DeleteTopicResponse
+*/
+package queue_pb
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type WriteMessageRequest struct {
+	Topic        string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+	EventNs      int64  `protobuf:"varint,2,opt,name=event_ns,json=eventNs" json:"event_ns,omitempty"`
+	PartitionKey []byte `protobuf:"bytes,3,opt,name=partition_key,json=partitionKey,proto3" json:"partition_key,omitempty"`
+	Data         []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *WriteMessageRequest) Reset()                    { *m = WriteMessageRequest{} }
+func (m *WriteMessageRequest) String() string            { return proto.CompactTextString(m) }
+func (*WriteMessageRequest) ProtoMessage()               {}
+func (*WriteMessageRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *WriteMessageRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *WriteMessageRequest) GetEventNs() int64 {
+	if m != nil {
+		return m.EventNs
+	}
+	return 0
+}
+
+func (m *WriteMessageRequest) GetPartitionKey() []byte {
+	if m != nil {
+		return m.PartitionKey
+	}
+	return nil
+}
+
+func (m *WriteMessageRequest) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type WriteMessageResponse struct {
+	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+	AckNs int64  `protobuf:"varint,2,opt,name=ack_ns,json=ackNs" json:"ack_ns,omitempty"`
+}
+
+func (m *WriteMessageResponse) Reset()                    { *m = WriteMessageResponse{} }
+func (m *WriteMessageResponse) String() string            { return proto.CompactTextString(m) }
+func (*WriteMessageResponse) ProtoMessage()               {}
+func (*WriteMessageResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *WriteMessageResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
+func (m *WriteMessageResponse) GetAckNs() int64 {
+	if m != nil {
+		return m.AckNs
+	}
+	return 0
+}
+
+type ReadMessageRequest struct {
+	Topic   string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+	StartNs int64  `protobuf:"varint,2,opt,name=start_ns,json=startNs" json:"start_ns,omitempty"`
+}
+
+func (m *ReadMessageRequest) Reset()                    { *m = ReadMessageRequest{} }
+func (m *ReadMessageRequest) String() string            { return proto.CompactTextString(m) }
+func (*ReadMessageRequest) ProtoMessage()               {}
+func (*ReadMessageRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+func (m *ReadMessageRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *ReadMessageRequest) GetStartNs() int64 {
+	if m != nil {
+		return m.StartNs
+	}
+	return 0
+}
+
+type ReadMessageResponse struct {
+	Error   string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+	EventNs int64  `protobuf:"varint,2,opt,name=event_ns,json=eventNs" json:"event_ns,omitempty"`
+	Data    []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *ReadMessageResponse) Reset()                    { *m = ReadMessageResponse{} }
+func (m *ReadMessageResponse) String() string            { return proto.CompactTextString(m) }
+func (*ReadMessageResponse) ProtoMessage()               {}
+func (*ReadMessageResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *ReadMessageResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
+func (m *ReadMessageResponse) GetEventNs() int64 {
+	if m != nil {
+		return m.EventNs
+	}
+	return 0
+}
+
+func (m *ReadMessageResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type ConfigureTopicRequest struct {
+	Topic          string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+	TtlSeconds     int64  `protobuf:"varint,2,opt,name=ttl_seconds,json=ttlSeconds" json:"ttl_seconds,omitempty"`
+	PartitionCount int32  `protobuf:"varint,3,opt,name=partition_count,json=partitionCount" json:"partition_count,omitempty"`
+}
+
+func (m *ConfigureTopicRequest) Reset()                    { *m = ConfigureTopicRequest{} }
+func (m *ConfigureTopicRequest) String() string            { return proto.CompactTextString(m) }
+func (*ConfigureTopicRequest) ProtoMessage()               {}
+func (*ConfigureTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *ConfigureTopicRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+func (m *ConfigureTopicRequest) GetTtlSeconds() int64 {
+	if m != nil {
+		return m.TtlSeconds
+	}
+	return 0
+}
+
+func (m *ConfigureTopicRequest) GetPartitionCount() int32 {
+	if m != nil {
+		return m.PartitionCount
+	}
+	return 0
+}
+
+type ConfigureTopicResponse struct {
+	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+}
+
+func (m *ConfigureTopicResponse) Reset()                    { *m = ConfigureTopicResponse{} }
+func (m *ConfigureTopicResponse) String() string            { return proto.CompactTextString(m) }
+func (*ConfigureTopicResponse) ProtoMessage()               {}
+func (*ConfigureTopicResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func (m *ConfigureTopicResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
+type DeleteTopicRequest struct {
+	Topic string `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
+}
+
+func (m *DeleteTopicRequest) Reset()                    { *m = DeleteTopicRequest{} }
+func (m *DeleteTopicRequest) String() string            { return proto.CompactTextString(m) }
+func (*DeleteTopicRequest) ProtoMessage()               {}
+func (*DeleteTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *DeleteTopicRequest) GetTopic() string {
+	if m != nil {
+		return m.Topic
+	}
+	return ""
+}
+
+type DeleteTopicResponse struct {
+	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+}
+
+func (m *DeleteTopicResponse) Reset()                    { *m = DeleteTopicResponse{} }
+func (m *DeleteTopicResponse) String() string            { return proto.CompactTextString(m) }
+func (*DeleteTopicResponse) ProtoMessage()               {}
+func (*DeleteTopicResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+func (m *DeleteTopicResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*WriteMessageRequest)(nil), "queue_pb.WriteMessageRequest")
+	proto.RegisterType((*WriteMessageResponse)(nil), "queue_pb.WriteMessageResponse")
+	proto.RegisterType((*ReadMessageRequest)(nil), "queue_pb.ReadMessageRequest")
+	proto.RegisterType((*ReadMessageResponse)(nil), "queue_pb.ReadMessageResponse")
+	proto.RegisterType((*ConfigureTopicRequest)(nil), "queue_pb.ConfigureTopicRequest")
+	proto.RegisterType((*ConfigureTopicResponse)(nil), "queue_pb.ConfigureTopicResponse")
+	proto.RegisterType((*DeleteTopicRequest)(nil), "queue_pb.DeleteTopicRequest")
+	proto.RegisterType((*DeleteTopicResponse)(nil), "queue_pb.DeleteTopicResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for SeaweedQueue service
+
+type SeaweedQueueClient interface {
+	StreamWrite(ctx context.Context, opts ...grpc.CallOption) (SeaweedQueue_StreamWriteClient, error)
+	StreamRead(ctx context.Context, in *ReadMessageRequest, opts ...grpc.CallOption) (SeaweedQueue_StreamReadClient, error)
+	ConfigureTopic(ctx context.Context, in *ConfigureTopicRequest, opts ...grpc.CallOption) (*ConfigureTopicResponse, error)
+	DeleteTopic(ctx context.Context, in *DeleteTopicRequest, opts ...grpc.CallOption) (*DeleteTopicResponse, error)
+}
+
+type seaweedQueueClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewSeaweedQueueClient(cc *grpc.ClientConn) SeaweedQueueClient {
+	return &seaweedQueueClient{cc}
+}
+
+func (c *seaweedQueueClient) StreamWrite(ctx context.Context, opts ...grpc.CallOption) (SeaweedQueue_StreamWriteClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SeaweedQueue_serviceDesc.Streams[0], c.cc, "/queue_pb.SeaweedQueue/StreamWrite", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &seaweedQueueStreamWriteClient{stream}
+	return x, nil
+}
+
+type SeaweedQueue_StreamWriteClient interface {
+	Send(*WriteMessageRequest) error
+	Recv() (*WriteMessageResponse, error)
+	grpc.ClientStream
+}
+
+type seaweedQueueStreamWriteClient struct {
+	grpc.ClientStream
+}
+
+func (x *seaweedQueueStreamWriteClient) Send(m *WriteMessageRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *seaweedQueueStreamWriteClient) Recv() (*WriteMessageResponse, error) {
+	m := new(WriteMessageResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *seaweedQueueClient) StreamRead(ctx context.Context, in *ReadMessageRequest, opts ...grpc.CallOption) (SeaweedQueue_StreamReadClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SeaweedQueue_serviceDesc.Streams[1], c.cc, "/queue_pb.SeaweedQueue/StreamRead", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &seaweedQueueStreamReadClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type SeaweedQueue_StreamReadClient interface {
+	Recv() (*ReadMessageResponse, error)
+	grpc.ClientStream
+}
+
+type seaweedQueueStreamReadClient struct {
+	grpc.ClientStream
+}
+
+func (x *seaweedQueueStreamReadClient) Recv() (*ReadMessageResponse, error) {
+	m := new(ReadMessageResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *seaweedQueueClient) ConfigureTopic(ctx context.Context, in *ConfigureTopicRequest, opts ...grpc.CallOption) (*ConfigureTopicResponse, error) {
+	out := new(ConfigureTopicResponse)
+	err := grpc.Invoke(ctx, "/queue_pb.SeaweedQueue/ConfigureTopic", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *seaweedQueueClient) DeleteTopic(ctx context.Context, in *DeleteTopicRequest, opts ...grpc.CallOption) (*DeleteTopicResponse, error) {
+	out := new(DeleteTopicResponse)
+	err := grpc.Invoke(ctx, "/queue_pb.SeaweedQueue/DeleteTopic", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for SeaweedQueue service
+
+type SeaweedQueueServer interface {
+	StreamWrite(SeaweedQueue_StreamWriteServer) error
+	StreamRead(*ReadMessageRequest, SeaweedQueue_StreamReadServer) error
+	ConfigureTopic(context.Context, *ConfigureTopicRequest) (*ConfigureTopicResponse, error)
+	DeleteTopic(context.Context, *DeleteTopicRequest) (*DeleteTopicResponse, error)
+}
+
+func RegisterSeaweedQueueServer(s *grpc.Server, srv SeaweedQueueServer) {
+	s.RegisterService(&_SeaweedQueue_serviceDesc, srv)
+}
+
+func _SeaweedQueue_StreamWrite_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SeaweedQueueServer).StreamWrite(&seaweedQueueStreamWriteServer{stream})
+}
+
+type SeaweedQueue_StreamWriteServer interface {
+	Send(*WriteMessageResponse) error
+	Recv() (*WriteMessageRequest, error)
+	grpc.ServerStream
+}
+
+type seaweedQueueStreamWriteServer struct {
+	grpc.ServerStream
+}
+
+func (x *seaweedQueueStreamWriteServer) Send(m *WriteMessageResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *seaweedQueueStreamWriteServer) Recv() (*WriteMessageRequest, error) {
+	m := new(WriteMessageRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _SeaweedQueue_StreamRead_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(ReadMessageRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(SeaweedQueueServer).StreamRead(m, &seaweedQueueStreamReadServer{stream})
+}
+
+type SeaweedQueue_StreamReadServer interface {
+	Send(*ReadMessageResponse) error
+	grpc.ServerStream
+}
+
+type seaweedQueueStreamReadServer struct {
+	grpc.ServerStream
+}
+
+func (x *seaweedQueueStreamReadServer) Send(m *ReadMessageResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _SeaweedQueue_ConfigureTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ConfigureTopicRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SeaweedQueueServer).ConfigureTopic(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/queue_pb.SeaweedQueue/ConfigureTopic",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SeaweedQueueServer).ConfigureTopic(ctx, req.(*ConfigureTopicRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _SeaweedQueue_DeleteTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteTopicRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SeaweedQueueServer).DeleteTopic(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/queue_pb.SeaweedQueue/DeleteTopic",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SeaweedQueueServer).DeleteTopic(ctx, req.(*DeleteTopicRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _SeaweedQueue_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "queue_pb.SeaweedQueue",
+	HandlerType: (*SeaweedQueueServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "ConfigureTopic",
+			Handler:    _SeaweedQueue_ConfigureTopic_Handler,
+		},
+		{
+			MethodName: "DeleteTopic",
+			Handler:    _SeaweedQueue_DeleteTopic_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "StreamWrite",
+			Handler:       _SeaweedQueue_StreamWrite_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "StreamRead",
+			Handler:       _SeaweedQueue_StreamRead_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "queue.proto",
+}
+
+func init() { proto.RegisterFile("queue.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 429 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x53, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0xae, 0x9b, 0xa6, 0x94, 0x49, 0x28, 0x68, 0xd2, 0xa2, 0x10, 0xd1, 0x36, 0x5a, 0x0e, 0x44,
+	0x20, 0x59, 0x15, 0xbc, 0x41, 0x03, 0x27, 0x68, 0x04, 0x0e, 0x08, 0x89, 0x8b, 0xb5, 0xb5, 0xa7,
+	0x95, 0x15, 0xb3, 0xeb, 0xee, 0x8e, 0xa9, 0x7a, 0xe2, 0x2d, 0x79, 0x1e, 0xe4, 0xb5, 0x5c, 0xdb,
+	0x34, 0xb1, 0x7a, 0xf3, 0xcc, 0x78, 0xe7, 0xfb, 0xd9, 0x6f, 0x61, 0x70, 0x9d, 0x53, 0x4e, 0x7e,
+	0x66, 0x34, 0x6b, 0xdc, 0x73, 0x45, 0x98, 0x5d, 0x88, 0x3f, 0x30, 0xfa, 0x61, 0x12, 0xa6, 0x73,
+	0xb2, 0x56, 0x5e, 0x51, 0x40, 0xd7, 0x39, 0x59, 0xc6, 0x03, 0xe8, 0xb3, 0xce, 0x92, 0x68, 0xec,
+	0x4d, 0xbd, 0xd9, 0xe3, 0xa0, 0x2c, 0xf0, 0x05, 0xec, 0xd1, 0x6f, 0x52, 0x1c, 0x2a, 0x3b, 0xde,
+	0x9e, 0x7a, 0xb3, 0x5e, 0xf0, 0xc8, 0xd5, 0x0b, 0x8b, 0xaf, 0xe0, 0x49, 0x26, 0x0d, 0x27, 0x9c,
+	0x68, 0x15, 0xae, 0xe8, 0x76, 0xdc, 0x9b, 0x7a, 0xb3, 0x61, 0x30, 0xbc, 0x6b, 0x7e, 0xa2, 0x5b,
+	0x44, 0xd8, 0x89, 0x25, 0xcb, 0xf1, 0x8e, 0x9b, 0xb9, 0x6f, 0x31, 0x87, 0x83, 0x36, 0x01, 0x9b,
+	0x69, 0x65, 0xa9, 0x60, 0x40, 0xc6, 0x68, 0x53, 0x31, 0x70, 0x05, 0x1e, 0xc2, 0xae, 0x8c, 0x56,
+	0x35, 0x7e, 0x5f, 0x46, 0xab, 0x85, 0x15, 0x1f, 0x01, 0x03, 0x92, 0xf1, 0x43, 0x45, 0x58, 0x96,
+	0xa6, 0x29, 0xc2, 0xd5, 0x0b, 0x2b, 0x7e, 0xc2, 0xa8, 0xb5, 0xa6, 0x93, 0x4a, 0x87, 0x19, 0x95,
+	0xce, 0x5e, 0x43, 0xe7, 0x0d, 0x1c, 0xce, 0xb5, 0xba, 0x4c, 0xae, 0x72, 0x43, 0xdf, 0x0a, 0x22,
+	0xdd, 0x2c, 0x4f, 0x60, 0xc0, 0x9c, 0x86, 0x96, 0x22, 0xad, 0xe2, 0x0a, 0x00, 0x98, 0xd3, 0x65,
+	0xd9, 0xc1, 0xd7, 0xf0, 0xb4, 0x36, 0x3c, 0xd2, 0xb9, 0x62, 0x07, 0xd7, 0x0f, 0xf6, 0xef, 0xda,
+	0xf3, 0xa2, 0x2b, 0x7c, 0x78, 0xfe, 0x3f, 0x70, 0x97, 0x2e, 0xf1, 0x06, 0xf0, 0x03, 0xa5, 0xc4,
+	0x0f, 0x60, 0x29, 0xde, 0xc2, 0xa8, 0xf5, 0x6f, 0xd7, 0xe2, 0x77, 0x7f, 0xb7, 0x61, 0xb8, 0x24,
+	0x79, 0x43, 0x14, 0x7f, 0x2d, 0xe2, 0x87, 0x01, 0x0c, 0x96, 0x6c, 0x48, 0xfe, 0x72, 0x01, 0xc0,
+	0x23, 0xbf, 0x4a, 0xa5, 0xbf, 0x26, 0x92, 0x93, 0xe3, 0x4d, 0xe3, 0x12, 0x54, 0x6c, 0xcd, 0xbc,
+	0x53, 0x0f, 0xcf, 0x01, 0xca, 0x9d, 0xc5, 0x45, 0xe2, 0xcb, 0xfa, 0xcc, 0xfd, 0x7c, 0x4c, 0x8e,
+	0x36, 0x4c, 0xab, 0x85, 0xa7, 0x1e, 0x7e, 0x87, 0xfd, 0xb6, 0x79, 0x78, 0x52, 0x1f, 0x5a, 0x7b,
+	0x9f, 0x93, 0xe9, 0xe6, 0x1f, 0xaa, 0xc5, 0xf8, 0x19, 0x06, 0x0d, 0xdf, 0x9a, 0x34, 0xef, 0x5b,
+	0xdf, 0xa4, 0xb9, 0xc6, 0x6c, 0xb1, 0x75, 0x76, 0x0c, 0xcf, 0x6c, 0xe9, 0xeb, 0xa5, 0xf5, 0xa3,
+	0x34, 0x21, 0xc5, 0x67, 0xe0, 0x2c, 0xfe, 0x52, 0xbc, 0xf6, 0x8b, 0x5d, 0xf7, 0xe8, 0xdf, 0xff,
+	0x0b, 0x00, 0x00, 0xff, 0xff, 0x7d, 0x3e, 0x14, 0xd8, 0x03, 0x04, 0x00, 0x00,
+}
diff --git a/weed/pb/volume_info.go b/weed/pb/volume_info.go
new file mode 100644
index 000000000..c4f733f5c
--- /dev/null
+++ b/weed/pb/volume_info.go
@@ -0,0 +1,76 @@
+package pb
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+
+	_ "github.com/chrislusf/seaweedfs/weed/storage/backend/s3_backend"
+	"github.com/chrislusf/seaweedfs/weed/util"
+
+	"github.com/golang/protobuf/jsonpb"
+
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
+)
+
+// MaybeLoadVolumeInfo load the file data as *volume_server_pb.VolumeInfo, the returned volumeInfo will not be nil
+func MaybeLoadVolumeInfo(fileName string) (*volume_server_pb.VolumeInfo, bool, error) {
+
+	volumeInfo := &volume_server_pb.VolumeInfo{}
+
+	glog.V(1).Infof("maybeLoadVolumeInfo checks %s", fileName)
+	if exists, canRead, _, _, _ := util.CheckFile(fileName); !exists || !canRead {
+		if !exists {
+			return volumeInfo, false, nil
+		}
+		if !canRead {
+			glog.Warningf("can not read %s", fileName)
+			return volumeInfo, false, fmt.Errorf("can not read %s", fileName)
+		}
+		return volumeInfo, false, nil
+	}
+
+	glog.V(1).Infof("maybeLoadVolumeInfo reads %s", fileName)
+	tierData, readErr := ioutil.ReadFile(fileName)
+	if readErr != nil {
+		glog.Warningf("fail to read %s : %v", fileName, readErr)
+		return volumeInfo, false, fmt.Errorf("fail to read %s : %v", fileName, readErr)
+	}
+
+	glog.V(1).Infof("maybeLoadVolumeInfo Unmarshal volume info %v", fileName)
+	if err := jsonpb.Unmarshal(bytes.NewReader(tierData), volumeInfo); err != nil {
+		glog.Warningf("unmarshal error: %v", err)
+		return volumeInfo, false, fmt.Errorf("unmarshal error: %v", err)
+	}
+
+	if len(volumeInfo.GetFiles()) == 0 {
+		return volumeInfo, false, nil
+	}
+
+	return volumeInfo, true, nil
+}
+
+func SaveVolumeInfo(fileName string, volumeInfo *volume_server_pb.VolumeInfo) error {
+
+	if exists, _, canWrite, _, _ := util.CheckFile(fileName); exists && !canWrite {
+		return fmt.Errorf("%s not writable", fileName)
+	}
+
+	m := jsonpb.Marshaler{
+		EmitDefaults: true,
+		Indent:       "  ",
+	}
+
+	text, marshalErr := m.MarshalToString(volumeInfo)
+	if marshalErr != nil {
+		return fmt.Errorf("marshal to %s: %v", fileName, marshalErr)
+	}
+
+	writeErr := ioutil.WriteFile(fileName, []byte(text), 0755)
+	if writeErr != nil {
+		return fmt.Errorf("fail to write %s : %v", fileName, writeErr)
+	}
+
+	return nil
+}
diff --git a/weed/pb/volume_server.proto b/weed/pb/volume_server.proto
index 3a5874c02..ce53fdc96 100644
--- a/weed/pb/volume_server.proto
+++ b/weed/pb/volume_server.proto
@@ -8,6 +8,10 @@ service VolumeServer {
     //Experts only: takes multiple fid parameters. This function does not propagate deletes to replicas.
     rpc BatchDelete (BatchDeleteRequest) returns (BatchDeleteResponse) {
     }
+
+    rpc FileGet (FileGetRequest) returns (stream FileGetResponse) {
+    }
+
     rpc VacuumVolumeCheck (VacuumVolumeCheckRequest) returns (VacuumVolumeCheckResponse) {
     }
     rpc VacuumVolumeCompact (VacuumVolumeCompactRequest) returns (VacuumVolumeCompactResponse) {
@@ -35,6 +39,8 @@ service VolumeServer {
     }
     rpc VolumeMarkReadonly (VolumeMarkReadonlyRequest) returns (VolumeMarkReadonlyResponse) {
     }
+    rpc VolumeConfigure (VolumeConfigureRequest) returns (VolumeConfigureResponse) {
+    }
 
     // copy the .idx .dat files, and mount this volume
     rpc VolumeCopy (VolumeCopyRequest) returns (VolumeCopyResponse) {
@@ -66,8 +72,19 @@ service VolumeServer {
     }
     rpc VolumeEcBlobDelete (VolumeEcBlobDeleteRequest) returns (VolumeEcBlobDeleteResponse) {
     }
+    rpc VolumeEcShardsToVolume (VolumeEcShardsToVolumeRequest) returns (VolumeEcShardsToVolumeResponse) {
+    }
 
-    // query
+    // tiered storage
+    rpc VolumeTierMoveDatToRemote (VolumeTierMoveDatToRemoteRequest) returns (stream VolumeTierMoveDatToRemoteResponse) {
+    }
+    rpc VolumeTierMoveDatFromRemote (VolumeTierMoveDatFromRemoteRequest) returns (stream VolumeTierMoveDatFromRemoteResponse) {
+    }
+
+    rpc VolumeServerStatus (VolumeServerStatusRequest) returns (VolumeServerStatusResponse) {
+    }
+
+    // <experimental> query
     rpc Query (QueryRequest) returns (stream QueriedStripe) {
     }
 
@@ -90,6 +107,22 @@ message DeleteResult {
     uint32 version = 5;
 }
 
+message FileGetRequest {
+    string file_id = 1;
+    bool accept_gzip = 2;
+}
+message FileGetResponse {
+    bytes data = 1;
+    uint32 content_length = 2;
+    string content_type = 3;
+    uint64 last_modified = 4;
+    string filename = 5;
+    string etag = 6;
+    bool is_gzipped = 7;
+    map<string, string> headers = 8;
+    int32 errorCode = 9;
+}
+
 message Empty {
 }
 
@@ -181,6 +214,14 @@ message VolumeMarkReadonlyRequest {
 message VolumeMarkReadonlyResponse {
 }
 
+message VolumeConfigureRequest {
+    uint32 volume_id = 1;
+    string replication = 2;
+}
+message VolumeConfigureResponse {
+    string error = 1;
+}
+
 message VolumeCopyRequest {
     uint32 volume_id = 1;
     string collection = 2;
@@ -199,6 +240,7 @@ message CopyFileRequest {
     uint64 stop_offset = 4;
     string collection = 5;
     bool is_ec_volume = 6;
+    bool ignore_source_file_not_found = 7;
 }
 message CopyFileResponse {
     bytes file_content = 1;
@@ -245,6 +287,8 @@ message VolumeEcShardsCopyRequest {
     repeated uint32 shard_ids = 3;
     bool copy_ecx_file = 4;
     string source_data_node = 5;
+    bool copy_ecj_file = 6;
+    bool copy_vif_file = 7;
 }
 message VolumeEcShardsCopyResponse {
 }
@@ -293,6 +337,13 @@ message VolumeEcBlobDeleteRequest {
 message VolumeEcBlobDeleteResponse {
 }
 
+message VolumeEcShardsToVolumeRequest {
+    uint32 volume_id = 1;
+    string collection = 2;
+}
+message VolumeEcShardsToVolumeResponse {
+}
+
 message ReadVolumeFileStatusRequest {
     uint32 volume_id = 1;
 }
@@ -312,6 +363,8 @@ message DiskStatus {
     uint64 all = 2;
     uint64 used = 3;
     uint64 free = 4;
+    float percent_free = 5;
+    float percent_used = 6;
 }
 
 message MemStatus {
@@ -324,6 +377,52 @@ message MemStatus {
     uint64 stack = 7;
 }
 
+// tired storage on volume servers
+message RemoteFile {
+    string backend_type = 1;
+    string backend_id = 2;
+    string key = 3;
+    uint64 offset = 4;
+    uint64 file_size = 5;
+    uint64 modified_time = 6;
+    string extension = 7;
+}
+message VolumeInfo {
+    repeated RemoteFile files = 1;
+    uint32 version = 2;
+    string replication = 3;
+}
+
+message VolumeTierMoveDatToRemoteRequest {
+    uint32 volume_id = 1;
+    string collection = 2;
+    string destination_backend_name = 3;
+    bool keep_local_dat_file = 4;
+}
+message VolumeTierMoveDatToRemoteResponse {
+    int64 processed = 1;
+    float processedPercentage = 2;
+}
+
+message VolumeTierMoveDatFromRemoteRequest {
+    uint32 volume_id = 1;
+    string collection = 2;
+    bool keep_remote_dat_file = 3;
+}
+message VolumeTierMoveDatFromRemoteResponse {
+    int64 processed = 1;
+    float processedPercentage = 2;
+}
+
+message VolumeServerStatusRequest {
+
+}
+message VolumeServerStatusResponse {
+    repeated DiskStatus disk_statuses = 1;
+    MemStatus memory_status = 2;
+}
+
+// select on volume servers
 message QueryRequest {
     repeated string selections = 1;
     repeated string from_file_ids = 2;
@@ -338,17 +437,17 @@ message QueryRequest {
         // NONE | GZIP | BZIP2
         string compression_type = 1;
         message CSVInput {
-            string file_header_info = 1;  // Valid values: NONE | USE | IGNORE
-            string record_delimiter = 2;  // Default: \n
-            string field_delimiter = 3;   // Default: ,
-            string quote_charactoer = 4;  // Default: "
+            string file_header_info = 1; // Valid values: NONE | USE | IGNORE
+            string record_delimiter = 2; // Default: \n
+            string field_delimiter = 3; // Default: ,
+            string quote_charactoer = 4; // Default: "
             string quote_escape_character = 5; // Default: "
-            string comments = 6;          // Default: #
+            string comments = 6; // Default: #
             // If true, records might contain record delimiters within quote characters
-            bool   allow_quoted_record_delimiter = 7; // default False.
+            bool allow_quoted_record_delimiter = 7; // default False.
         }
         message JSONInput {
-            string type = 1;              // Valid values: DOCUMENT | LINES
+            string type = 1; // Valid values: DOCUMENT | LINES
         }
         message ParquetInput {
         }
@@ -361,10 +460,10 @@ message QueryRequest {
 
     message OutputSerialization {
         message CSVOutput {
-            string quote_fields = 1;  // Valid values: ALWAYS | ASNEEDED
-            string record_delimiter = 2;  // Default: \n
-            string field_delimiter = 3;   // Default: ,
-            string quote_charactoer = 4;  // Default: "
+            string quote_fields = 1; // Valid values: ALWAYS | ASNEEDED
+            string record_delimiter = 2; // Default: \n
+            string field_delimiter = 3; // Default: ,
+            string quote_charactoer = 4; // Default: "
             string quote_escape_character = 5; // Default: "
         }
         message JSONOutput {
diff --git a/weed/pb/volume_server_pb/volume_server.pb.go b/weed/pb/volume_server_pb/volume_server.pb.go
index 24907cdba..56baa0cf7 100644
--- a/weed/pb/volume_server_pb/volume_server.pb.go
+++ b/weed/pb/volume_server_pb/volume_server.pb.go
@@ -12,6 +12,8 @@ It has these top-level messages:
 	BatchDeleteRequest
 	BatchDeleteResponse
 	DeleteResult
+	FileGetRequest
+	FileGetResponse
 	Empty
 	VacuumVolumeCheckRequest
 	VacuumVolumeCheckResponse
@@ -37,6 +39,8 @@ It has these top-level messages:
 	VolumeDeleteResponse
 	VolumeMarkReadonlyRequest
 	VolumeMarkReadonlyResponse
+	VolumeConfigureRequest
+	VolumeConfigureResponse
 	VolumeCopyRequest
 	VolumeCopyResponse
 	CopyFileRequest
@@ -61,10 +65,20 @@ It has these top-level messages:
 	VolumeEcShardReadResponse
 	VolumeEcBlobDeleteRequest
 	VolumeEcBlobDeleteResponse
+	VolumeEcShardsToVolumeRequest
+	VolumeEcShardsToVolumeResponse
 	ReadVolumeFileStatusRequest
 	ReadVolumeFileStatusResponse
 	DiskStatus
 	MemStatus
+	RemoteFile
+	VolumeInfo
+	VolumeTierMoveDatToRemoteRequest
+	VolumeTierMoveDatToRemoteResponse
+	VolumeTierMoveDatFromRemoteRequest
+	VolumeTierMoveDatFromRemoteResponse
+	VolumeServerStatusRequest
+	VolumeServerStatusResponse
 	QueryRequest
 	QueriedStripe
 */
@@ -170,13 +184,117 @@ func (m *DeleteResult) GetVersion() uint32 {
 	return 0
 }
 
+type FileGetRequest struct {
+	FileId     string `protobuf:"bytes,1,opt,name=file_id,json=fileId" json:"file_id,omitempty"`
+	AcceptGzip bool   `protobuf:"varint,2,opt,name=accept_gzip,json=acceptGzip" json:"accept_gzip,omitempty"`
+}
+
+func (m *FileGetRequest) Reset()                    { *m = FileGetRequest{} }
+func (m *FileGetRequest) String() string            { return proto.CompactTextString(m) }
+func (*FileGetRequest) ProtoMessage()               {}
+func (*FileGetRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *FileGetRequest) GetFileId() string {
+	if m != nil {
+		return m.FileId
+	}
+	return ""
+}
+
+func (m *FileGetRequest) GetAcceptGzip() bool {
+	if m != nil {
+		return m.AcceptGzip
+	}
+	return false
+}
+
+type FileGetResponse struct {
+	Data          []byte            `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	ContentLength uint32            `protobuf:"varint,2,opt,name=content_length,json=contentLength" json:"content_length,omitempty"`
+	ContentType   string            `protobuf:"bytes,3,opt,name=content_type,json=contentType" json:"content_type,omitempty"`
+	LastModified  uint64            `protobuf:"varint,4,opt,name=last_modified,json=lastModified" json:"last_modified,omitempty"`
+	Filename      string            `protobuf:"bytes,5,opt,name=filename" json:"filename,omitempty"`
+	Etag          string            `protobuf:"bytes,6,opt,name=etag" json:"etag,omitempty"`
+	IsGzipped     bool              `protobuf:"varint,7,opt,name=is_gzipped,json=isGzipped" json:"is_gzipped,omitempty"`
+	Headers       map[string]string `protobuf:"bytes,8,rep,name=headers" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	ErrorCode     int32             `protobuf:"varint,9,opt,name=errorCode" json:"errorCode,omitempty"`
+}
+
+func (m *FileGetResponse) Reset()                    { *m = FileGetResponse{} }
+func (m *FileGetResponse) String() string            { return proto.CompactTextString(m) }
+func (*FileGetResponse) ProtoMessage()               {}
+func (*FileGetResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+func (m *FileGetResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *FileGetResponse) GetContentLength() uint32 {
+	if m != nil {
+		return m.ContentLength
+	}
+	return 0
+}
+
+func (m *FileGetResponse) GetContentType() string {
+	if m != nil {
+		return m.ContentType
+	}
+	return ""
+}
+
+func (m *FileGetResponse) GetLastModified() uint64 {
+	if m != nil {
+		return m.LastModified
+	}
+	return 0
+}
+
+func (m *FileGetResponse) GetFilename() string {
+	if m != nil {
+		return m.Filename
+	}
+	return ""
+}
+
+func (m *FileGetResponse) GetEtag() string {
+	if m != nil {
+		return m.Etag
+	}
+	return ""
+}
+
+func (m *FileGetResponse) GetIsGzipped() bool {
+	if m != nil {
+		return m.IsGzipped
+	}
+	return false
+}
+
+func (m *FileGetResponse) GetHeaders() map[string]string {
+	if m != nil {
+		return m.Headers
+	}
+	return nil
+}
+
+func (m *FileGetResponse) GetErrorCode() int32 {
+	if m != nil {
+		return m.ErrorCode
+	}
+	return 0
+}
+
 type Empty struct {
 }
 
 func (m *Empty) Reset()                    { *m = Empty{} }
 func (m *Empty) String() string            { return proto.CompactTextString(m) }
 func (*Empty) ProtoMessage()               {}
-func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 
 type VacuumVolumeCheckRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -185,7 +303,7 @@ type VacuumVolumeCheckRequest struct {
 func (m *VacuumVolumeCheckRequest) Reset()                    { *m = VacuumVolumeCheckRequest{} }
 func (m *VacuumVolumeCheckRequest) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCheckRequest) ProtoMessage()               {}
-func (*VacuumVolumeCheckRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+func (*VacuumVolumeCheckRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 
 func (m *VacuumVolumeCheckRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -201,7 +319,7 @@ type VacuumVolumeCheckResponse struct {
 func (m *VacuumVolumeCheckResponse) Reset()                    { *m = VacuumVolumeCheckResponse{} }
 func (m *VacuumVolumeCheckResponse) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCheckResponse) ProtoMessage()               {}
-func (*VacuumVolumeCheckResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+func (*VacuumVolumeCheckResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 
 func (m *VacuumVolumeCheckResponse) GetGarbageRatio() float64 {
 	if m != nil {
@@ -218,7 +336,7 @@ type VacuumVolumeCompactRequest struct {
 func (m *VacuumVolumeCompactRequest) Reset()                    { *m = VacuumVolumeCompactRequest{} }
 func (m *VacuumVolumeCompactRequest) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCompactRequest) ProtoMessage()               {}
-func (*VacuumVolumeCompactRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+func (*VacuumVolumeCompactRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 
 func (m *VacuumVolumeCompactRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -240,7 +358,7 @@ type VacuumVolumeCompactResponse struct {
 func (m *VacuumVolumeCompactResponse) Reset()                    { *m = VacuumVolumeCompactResponse{} }
 func (m *VacuumVolumeCompactResponse) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCompactResponse) ProtoMessage()               {}
-func (*VacuumVolumeCompactResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+func (*VacuumVolumeCompactResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 
 type VacuumVolumeCommitRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -249,7 +367,7 @@ type VacuumVolumeCommitRequest struct {
 func (m *VacuumVolumeCommitRequest) Reset()                    { *m = VacuumVolumeCommitRequest{} }
 func (m *VacuumVolumeCommitRequest) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCommitRequest) ProtoMessage()               {}
-func (*VacuumVolumeCommitRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+func (*VacuumVolumeCommitRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 
 func (m *VacuumVolumeCommitRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -264,7 +382,7 @@ type VacuumVolumeCommitResponse struct {
 func (m *VacuumVolumeCommitResponse) Reset()                    { *m = VacuumVolumeCommitResponse{} }
 func (m *VacuumVolumeCommitResponse) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCommitResponse) ProtoMessage()               {}
-func (*VacuumVolumeCommitResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+func (*VacuumVolumeCommitResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
 type VacuumVolumeCleanupRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -273,7 +391,7 @@ type VacuumVolumeCleanupRequest struct {
 func (m *VacuumVolumeCleanupRequest) Reset()                    { *m = VacuumVolumeCleanupRequest{} }
 func (m *VacuumVolumeCleanupRequest) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCleanupRequest) ProtoMessage()               {}
-func (*VacuumVolumeCleanupRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+func (*VacuumVolumeCleanupRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 
 func (m *VacuumVolumeCleanupRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -288,7 +406,7 @@ type VacuumVolumeCleanupResponse struct {
 func (m *VacuumVolumeCleanupResponse) Reset()                    { *m = VacuumVolumeCleanupResponse{} }
 func (m *VacuumVolumeCleanupResponse) String() string            { return proto.CompactTextString(m) }
 func (*VacuumVolumeCleanupResponse) ProtoMessage()               {}
-func (*VacuumVolumeCleanupResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+func (*VacuumVolumeCleanupResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 
 type DeleteCollectionRequest struct {
 	Collection string `protobuf:"bytes,1,opt,name=collection" json:"collection,omitempty"`
@@ -297,7 +415,7 @@ type DeleteCollectionRequest struct {
 func (m *DeleteCollectionRequest) Reset()                    { *m = DeleteCollectionRequest{} }
 func (m *DeleteCollectionRequest) String() string            { return proto.CompactTextString(m) }
 func (*DeleteCollectionRequest) ProtoMessage()               {}
-func (*DeleteCollectionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+func (*DeleteCollectionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 
 func (m *DeleteCollectionRequest) GetCollection() string {
 	if m != nil {
@@ -312,7 +430,7 @@ type DeleteCollectionResponse struct {
 func (m *DeleteCollectionResponse) Reset()                    { *m = DeleteCollectionResponse{} }
 func (m *DeleteCollectionResponse) String() string            { return proto.CompactTextString(m) }
 func (*DeleteCollectionResponse) ProtoMessage()               {}
-func (*DeleteCollectionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+func (*DeleteCollectionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
 
 type AllocateVolumeRequest struct {
 	VolumeId           uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -326,7 +444,7 @@ type AllocateVolumeRequest struct {
 func (m *AllocateVolumeRequest) Reset()                    { *m = AllocateVolumeRequest{} }
 func (m *AllocateVolumeRequest) String() string            { return proto.CompactTextString(m) }
 func (*AllocateVolumeRequest) ProtoMessage()               {}
-func (*AllocateVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
+func (*AllocateVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
 
 func (m *AllocateVolumeRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -376,7 +494,7 @@ type AllocateVolumeResponse struct {
 func (m *AllocateVolumeResponse) Reset()                    { *m = AllocateVolumeResponse{} }
 func (m *AllocateVolumeResponse) String() string            { return proto.CompactTextString(m) }
 func (*AllocateVolumeResponse) ProtoMessage()               {}
-func (*AllocateVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
+func (*AllocateVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
 
 type VolumeSyncStatusRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -385,7 +503,7 @@ type VolumeSyncStatusRequest struct {
 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 (*VolumeSyncStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
 
 func (m *VolumeSyncStatusRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -407,7 +525,7 @@ type VolumeSyncStatusResponse struct {
 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 (*VolumeSyncStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
 
 func (m *VolumeSyncStatusResponse) GetVolumeId() uint32 {
 	if m != nil {
@@ -466,7 +584,7 @@ type VolumeIncrementalCopyRequest struct {
 func (m *VolumeIncrementalCopyRequest) Reset()                    { *m = VolumeIncrementalCopyRequest{} }
 func (m *VolumeIncrementalCopyRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeIncrementalCopyRequest) ProtoMessage()               {}
-func (*VolumeIncrementalCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+func (*VolumeIncrementalCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
 
 func (m *VolumeIncrementalCopyRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -489,7 +607,7 @@ type VolumeIncrementalCopyResponse struct {
 func (m *VolumeIncrementalCopyResponse) Reset()                    { *m = VolumeIncrementalCopyResponse{} }
 func (m *VolumeIncrementalCopyResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeIncrementalCopyResponse) ProtoMessage()               {}
-func (*VolumeIncrementalCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
+func (*VolumeIncrementalCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
 
 func (m *VolumeIncrementalCopyResponse) GetFileContent() []byte {
 	if m != nil {
@@ -505,7 +623,7 @@ type VolumeMountRequest struct {
 func (m *VolumeMountRequest) Reset()                    { *m = VolumeMountRequest{} }
 func (m *VolumeMountRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeMountRequest) ProtoMessage()               {}
-func (*VolumeMountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
+func (*VolumeMountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
 
 func (m *VolumeMountRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -520,7 +638,7 @@ type VolumeMountResponse struct {
 func (m *VolumeMountResponse) Reset()                    { *m = VolumeMountResponse{} }
 func (m *VolumeMountResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeMountResponse) ProtoMessage()               {}
-func (*VolumeMountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
+func (*VolumeMountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
 
 type VolumeUnmountRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -529,7 +647,7 @@ type VolumeUnmountRequest struct {
 func (m *VolumeUnmountRequest) Reset()                    { *m = VolumeUnmountRequest{} }
 func (m *VolumeUnmountRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeUnmountRequest) ProtoMessage()               {}
-func (*VolumeUnmountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
+func (*VolumeUnmountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
 
 func (m *VolumeUnmountRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -544,7 +662,7 @@ type VolumeUnmountResponse struct {
 func (m *VolumeUnmountResponse) Reset()                    { *m = VolumeUnmountResponse{} }
 func (m *VolumeUnmountResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeUnmountResponse) ProtoMessage()               {}
-func (*VolumeUnmountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
+func (*VolumeUnmountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
 
 type VolumeDeleteRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -553,7 +671,7 @@ type VolumeDeleteRequest struct {
 func (m *VolumeDeleteRequest) Reset()                    { *m = VolumeDeleteRequest{} }
 func (m *VolumeDeleteRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeDeleteRequest) ProtoMessage()               {}
-func (*VolumeDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
+func (*VolumeDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
 
 func (m *VolumeDeleteRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -568,7 +686,7 @@ type VolumeDeleteResponse struct {
 func (m *VolumeDeleteResponse) Reset()                    { *m = VolumeDeleteResponse{} }
 func (m *VolumeDeleteResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeDeleteResponse) ProtoMessage()               {}
-func (*VolumeDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
+func (*VolumeDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
 
 type VolumeMarkReadonlyRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -577,7 +695,7 @@ type VolumeMarkReadonlyRequest struct {
 func (m *VolumeMarkReadonlyRequest) Reset()                    { *m = VolumeMarkReadonlyRequest{} }
 func (m *VolumeMarkReadonlyRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeMarkReadonlyRequest) ProtoMessage()               {}
-func (*VolumeMarkReadonlyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
+func (*VolumeMarkReadonlyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
 
 func (m *VolumeMarkReadonlyRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -592,7 +710,47 @@ type VolumeMarkReadonlyResponse struct {
 func (m *VolumeMarkReadonlyResponse) Reset()                    { *m = VolumeMarkReadonlyResponse{} }
 func (m *VolumeMarkReadonlyResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeMarkReadonlyResponse) ProtoMessage()               {}
-func (*VolumeMarkReadonlyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
+func (*VolumeMarkReadonlyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+
+type VolumeConfigureRequest struct {
+	VolumeId    uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
+	Replication string `protobuf:"bytes,2,opt,name=replication" json:"replication,omitempty"`
+}
+
+func (m *VolumeConfigureRequest) Reset()                    { *m = VolumeConfigureRequest{} }
+func (m *VolumeConfigureRequest) String() string            { return proto.CompactTextString(m) }
+func (*VolumeConfigureRequest) ProtoMessage()               {}
+func (*VolumeConfigureRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+
+func (m *VolumeConfigureRequest) GetVolumeId() uint32 {
+	if m != nil {
+		return m.VolumeId
+	}
+	return 0
+}
+
+func (m *VolumeConfigureRequest) GetReplication() string {
+	if m != nil {
+		return m.Replication
+	}
+	return ""
+}
+
+type VolumeConfigureResponse struct {
+	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
+}
+
+func (m *VolumeConfigureResponse) Reset()                    { *m = VolumeConfigureResponse{} }
+func (m *VolumeConfigureResponse) String() string            { return proto.CompactTextString(m) }
+func (*VolumeConfigureResponse) ProtoMessage()               {}
+func (*VolumeConfigureResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+
+func (m *VolumeConfigureResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
 
 type VolumeCopyRequest struct {
 	VolumeId       uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -605,7 +763,7 @@ type VolumeCopyRequest struct {
 func (m *VolumeCopyRequest) Reset()                    { *m = VolumeCopyRequest{} }
 func (m *VolumeCopyRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeCopyRequest) ProtoMessage()               {}
-func (*VolumeCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
+func (*VolumeCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
 
 func (m *VolumeCopyRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -649,7 +807,7 @@ type VolumeCopyResponse struct {
 func (m *VolumeCopyResponse) Reset()                    { *m = VolumeCopyResponse{} }
 func (m *VolumeCopyResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeCopyResponse) ProtoMessage()               {}
-func (*VolumeCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
+func (*VolumeCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
 
 func (m *VolumeCopyResponse) GetLastAppendAtNs() uint64 {
 	if m != nil {
@@ -659,18 +817,19 @@ func (m *VolumeCopyResponse) GetLastAppendAtNs() uint64 {
 }
 
 type CopyFileRequest struct {
-	VolumeId           uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
-	Ext                string `protobuf:"bytes,2,opt,name=ext" json:"ext,omitempty"`
-	CompactionRevision uint32 `protobuf:"varint,3,opt,name=compaction_revision,json=compactionRevision" json:"compaction_revision,omitempty"`
-	StopOffset         uint64 `protobuf:"varint,4,opt,name=stop_offset,json=stopOffset" json:"stop_offset,omitempty"`
-	Collection         string `protobuf:"bytes,5,opt,name=collection" json:"collection,omitempty"`
-	IsEcVolume         bool   `protobuf:"varint,6,opt,name=is_ec_volume,json=isEcVolume" json:"is_ec_volume,omitempty"`
+	VolumeId                 uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
+	Ext                      string `protobuf:"bytes,2,opt,name=ext" json:"ext,omitempty"`
+	CompactionRevision       uint32 `protobuf:"varint,3,opt,name=compaction_revision,json=compactionRevision" json:"compaction_revision,omitempty"`
+	StopOffset               uint64 `protobuf:"varint,4,opt,name=stop_offset,json=stopOffset" json:"stop_offset,omitempty"`
+	Collection               string `protobuf:"bytes,5,opt,name=collection" json:"collection,omitempty"`
+	IsEcVolume               bool   `protobuf:"varint,6,opt,name=is_ec_volume,json=isEcVolume" json:"is_ec_volume,omitempty"`
+	IgnoreSourceFileNotFound bool   `protobuf:"varint,7,opt,name=ignore_source_file_not_found,json=ignoreSourceFileNotFound" json:"ignore_source_file_not_found,omitempty"`
 }
 
 func (m *CopyFileRequest) Reset()                    { *m = CopyFileRequest{} }
 func (m *CopyFileRequest) String() string            { return proto.CompactTextString(m) }
 func (*CopyFileRequest) ProtoMessage()               {}
-func (*CopyFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+func (*CopyFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
 
 func (m *CopyFileRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -714,6 +873,13 @@ func (m *CopyFileRequest) GetIsEcVolume() bool {
 	return false
 }
 
+func (m *CopyFileRequest) GetIgnoreSourceFileNotFound() bool {
+	if m != nil {
+		return m.IgnoreSourceFileNotFound
+	}
+	return false
+}
+
 type CopyFileResponse struct {
 	FileContent []byte `protobuf:"bytes,1,opt,name=file_content,json=fileContent,proto3" json:"file_content,omitempty"`
 }
@@ -721,7 +887,7 @@ type CopyFileResponse struct {
 func (m *CopyFileResponse) Reset()                    { *m = CopyFileResponse{} }
 func (m *CopyFileResponse) String() string            { return proto.CompactTextString(m) }
 func (*CopyFileResponse) ProtoMessage()               {}
-func (*CopyFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+func (*CopyFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }
 
 func (m *CopyFileResponse) GetFileContent() []byte {
 	if m != nil {
@@ -739,7 +905,7 @@ type VolumeTailSenderRequest struct {
 func (m *VolumeTailSenderRequest) Reset()                    { *m = VolumeTailSenderRequest{} }
 func (m *VolumeTailSenderRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeTailSenderRequest) ProtoMessage()               {}
-func (*VolumeTailSenderRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
+func (*VolumeTailSenderRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }
 
 func (m *VolumeTailSenderRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -771,7 +937,7 @@ type VolumeTailSenderResponse struct {
 func (m *VolumeTailSenderResponse) Reset()                    { *m = VolumeTailSenderResponse{} }
 func (m *VolumeTailSenderResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeTailSenderResponse) ProtoMessage()               {}
-func (*VolumeTailSenderResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
+func (*VolumeTailSenderResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }
 
 func (m *VolumeTailSenderResponse) GetNeedleHeader() []byte {
 	if m != nil {
@@ -804,7 +970,7 @@ type VolumeTailReceiverRequest struct {
 func (m *VolumeTailReceiverRequest) Reset()                    { *m = VolumeTailReceiverRequest{} }
 func (m *VolumeTailReceiverRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeTailReceiverRequest) ProtoMessage()               {}
-func (*VolumeTailReceiverRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
+func (*VolumeTailReceiverRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} }
 
 func (m *VolumeTailReceiverRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -840,7 +1006,7 @@ type VolumeTailReceiverResponse struct {
 func (m *VolumeTailReceiverResponse) Reset()                    { *m = VolumeTailReceiverResponse{} }
 func (m *VolumeTailReceiverResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeTailReceiverResponse) ProtoMessage()               {}
-func (*VolumeTailReceiverResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }
+func (*VolumeTailReceiverResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} }
 
 type VolumeEcShardsGenerateRequest struct {
 	VolumeId   uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -850,7 +1016,7 @@ type VolumeEcShardsGenerateRequest struct {
 func (m *VolumeEcShardsGenerateRequest) Reset()                    { *m = VolumeEcShardsGenerateRequest{} }
 func (m *VolumeEcShardsGenerateRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsGenerateRequest) ProtoMessage()               {}
-func (*VolumeEcShardsGenerateRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }
+func (*VolumeEcShardsGenerateRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} }
 
 func (m *VolumeEcShardsGenerateRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -872,7 +1038,7 @@ type VolumeEcShardsGenerateResponse struct {
 func (m *VolumeEcShardsGenerateResponse) Reset()                    { *m = VolumeEcShardsGenerateResponse{} }
 func (m *VolumeEcShardsGenerateResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsGenerateResponse) ProtoMessage()               {}
-func (*VolumeEcShardsGenerateResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }
+func (*VolumeEcShardsGenerateResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} }
 
 type VolumeEcShardsRebuildRequest struct {
 	VolumeId   uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -882,7 +1048,7 @@ type VolumeEcShardsRebuildRequest struct {
 func (m *VolumeEcShardsRebuildRequest) Reset()                    { *m = VolumeEcShardsRebuildRequest{} }
 func (m *VolumeEcShardsRebuildRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsRebuildRequest) ProtoMessage()               {}
-func (*VolumeEcShardsRebuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} }
+func (*VolumeEcShardsRebuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} }
 
 func (m *VolumeEcShardsRebuildRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -905,7 +1071,7 @@ type VolumeEcShardsRebuildResponse struct {
 func (m *VolumeEcShardsRebuildResponse) Reset()                    { *m = VolumeEcShardsRebuildResponse{} }
 func (m *VolumeEcShardsRebuildResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsRebuildResponse) ProtoMessage()               {}
-func (*VolumeEcShardsRebuildResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} }
+func (*VolumeEcShardsRebuildResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{43} }
 
 func (m *VolumeEcShardsRebuildResponse) GetRebuiltShardIds() []uint32 {
 	if m != nil {
@@ -920,12 +1086,14 @@ type VolumeEcShardsCopyRequest struct {
 	ShardIds       []uint32 `protobuf:"varint,3,rep,packed,name=shard_ids,json=shardIds" json:"shard_ids,omitempty"`
 	CopyEcxFile    bool     `protobuf:"varint,4,opt,name=copy_ecx_file,json=copyEcxFile" json:"copy_ecx_file,omitempty"`
 	SourceDataNode string   `protobuf:"bytes,5,opt,name=source_data_node,json=sourceDataNode" json:"source_data_node,omitempty"`
+	CopyEcjFile    bool     `protobuf:"varint,6,opt,name=copy_ecj_file,json=copyEcjFile" json:"copy_ecj_file,omitempty"`
+	CopyVifFile    bool     `protobuf:"varint,7,opt,name=copy_vif_file,json=copyVifFile" json:"copy_vif_file,omitempty"`
 }
 
 func (m *VolumeEcShardsCopyRequest) Reset()                    { *m = VolumeEcShardsCopyRequest{} }
 func (m *VolumeEcShardsCopyRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsCopyRequest) ProtoMessage()               {}
-func (*VolumeEcShardsCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} }
+func (*VolumeEcShardsCopyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{44} }
 
 func (m *VolumeEcShardsCopyRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -962,13 +1130,27 @@ func (m *VolumeEcShardsCopyRequest) GetSourceDataNode() string {
 	return ""
 }
 
+func (m *VolumeEcShardsCopyRequest) GetCopyEcjFile() bool {
+	if m != nil {
+		return m.CopyEcjFile
+	}
+	return false
+}
+
+func (m *VolumeEcShardsCopyRequest) GetCopyVifFile() bool {
+	if m != nil {
+		return m.CopyVifFile
+	}
+	return false
+}
+
 type VolumeEcShardsCopyResponse struct {
 }
 
 func (m *VolumeEcShardsCopyResponse) Reset()                    { *m = VolumeEcShardsCopyResponse{} }
 func (m *VolumeEcShardsCopyResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsCopyResponse) ProtoMessage()               {}
-func (*VolumeEcShardsCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} }
+func (*VolumeEcShardsCopyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{45} }
 
 type VolumeEcShardsDeleteRequest struct {
 	VolumeId   uint32   `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -979,7 +1161,7 @@ type VolumeEcShardsDeleteRequest struct {
 func (m *VolumeEcShardsDeleteRequest) Reset()                    { *m = VolumeEcShardsDeleteRequest{} }
 func (m *VolumeEcShardsDeleteRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsDeleteRequest) ProtoMessage()               {}
-func (*VolumeEcShardsDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} }
+func (*VolumeEcShardsDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{46} }
 
 func (m *VolumeEcShardsDeleteRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -1008,7 +1190,7 @@ type VolumeEcShardsDeleteResponse struct {
 func (m *VolumeEcShardsDeleteResponse) Reset()                    { *m = VolumeEcShardsDeleteResponse{} }
 func (m *VolumeEcShardsDeleteResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsDeleteResponse) ProtoMessage()               {}
-func (*VolumeEcShardsDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{43} }
+func (*VolumeEcShardsDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{47} }
 
 type VolumeEcShardsMountRequest struct {
 	VolumeId   uint32   `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -1019,7 +1201,7 @@ type VolumeEcShardsMountRequest struct {
 func (m *VolumeEcShardsMountRequest) Reset()                    { *m = VolumeEcShardsMountRequest{} }
 func (m *VolumeEcShardsMountRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsMountRequest) ProtoMessage()               {}
-func (*VolumeEcShardsMountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{44} }
+func (*VolumeEcShardsMountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{48} }
 
 func (m *VolumeEcShardsMountRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -1048,7 +1230,7 @@ type VolumeEcShardsMountResponse struct {
 func (m *VolumeEcShardsMountResponse) Reset()                    { *m = VolumeEcShardsMountResponse{} }
 func (m *VolumeEcShardsMountResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsMountResponse) ProtoMessage()               {}
-func (*VolumeEcShardsMountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{45} }
+func (*VolumeEcShardsMountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{49} }
 
 type VolumeEcShardsUnmountRequest struct {
 	VolumeId uint32   `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -1058,7 +1240,7 @@ type VolumeEcShardsUnmountRequest struct {
 func (m *VolumeEcShardsUnmountRequest) Reset()                    { *m = VolumeEcShardsUnmountRequest{} }
 func (m *VolumeEcShardsUnmountRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsUnmountRequest) ProtoMessage()               {}
-func (*VolumeEcShardsUnmountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{46} }
+func (*VolumeEcShardsUnmountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{50} }
 
 func (m *VolumeEcShardsUnmountRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -1080,7 +1262,7 @@ type VolumeEcShardsUnmountResponse struct {
 func (m *VolumeEcShardsUnmountResponse) Reset()                    { *m = VolumeEcShardsUnmountResponse{} }
 func (m *VolumeEcShardsUnmountResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardsUnmountResponse) ProtoMessage()               {}
-func (*VolumeEcShardsUnmountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{47} }
+func (*VolumeEcShardsUnmountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{51} }
 
 type VolumeEcShardReadRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -1093,7 +1275,7 @@ type VolumeEcShardReadRequest struct {
 func (m *VolumeEcShardReadRequest) Reset()                    { *m = VolumeEcShardReadRequest{} }
 func (m *VolumeEcShardReadRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardReadRequest) ProtoMessage()               {}
-func (*VolumeEcShardReadRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{48} }
+func (*VolumeEcShardReadRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{52} }
 
 func (m *VolumeEcShardReadRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -1138,7 +1320,7 @@ type VolumeEcShardReadResponse struct {
 func (m *VolumeEcShardReadResponse) Reset()                    { *m = VolumeEcShardReadResponse{} }
 func (m *VolumeEcShardReadResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcShardReadResponse) ProtoMessage()               {}
-func (*VolumeEcShardReadResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{49} }
+func (*VolumeEcShardReadResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{53} }
 
 func (m *VolumeEcShardReadResponse) GetData() []byte {
 	if m != nil {
@@ -1164,7 +1346,7 @@ type VolumeEcBlobDeleteRequest struct {
 func (m *VolumeEcBlobDeleteRequest) Reset()                    { *m = VolumeEcBlobDeleteRequest{} }
 func (m *VolumeEcBlobDeleteRequest) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcBlobDeleteRequest) ProtoMessage()               {}
-func (*VolumeEcBlobDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{50} }
+func (*VolumeEcBlobDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{54} }
 
 func (m *VolumeEcBlobDeleteRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -1200,7 +1382,39 @@ type VolumeEcBlobDeleteResponse struct {
 func (m *VolumeEcBlobDeleteResponse) Reset()                    { *m = VolumeEcBlobDeleteResponse{} }
 func (m *VolumeEcBlobDeleteResponse) String() string            { return proto.CompactTextString(m) }
 func (*VolumeEcBlobDeleteResponse) ProtoMessage()               {}
-func (*VolumeEcBlobDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{51} }
+func (*VolumeEcBlobDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{55} }
+
+type VolumeEcShardsToVolumeRequest struct {
+	VolumeId   uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
+	Collection string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
+}
+
+func (m *VolumeEcShardsToVolumeRequest) Reset()                    { *m = VolumeEcShardsToVolumeRequest{} }
+func (m *VolumeEcShardsToVolumeRequest) String() string            { return proto.CompactTextString(m) }
+func (*VolumeEcShardsToVolumeRequest) ProtoMessage()               {}
+func (*VolumeEcShardsToVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56} }
+
+func (m *VolumeEcShardsToVolumeRequest) GetVolumeId() uint32 {
+	if m != nil {
+		return m.VolumeId
+	}
+	return 0
+}
+
+func (m *VolumeEcShardsToVolumeRequest) GetCollection() string {
+	if m != nil {
+		return m.Collection
+	}
+	return ""
+}
+
+type VolumeEcShardsToVolumeResponse struct {
+}
+
+func (m *VolumeEcShardsToVolumeResponse) Reset()                    { *m = VolumeEcShardsToVolumeResponse{} }
+func (m *VolumeEcShardsToVolumeResponse) String() string            { return proto.CompactTextString(m) }
+func (*VolumeEcShardsToVolumeResponse) ProtoMessage()               {}
+func (*VolumeEcShardsToVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{57} }
 
 type ReadVolumeFileStatusRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
@@ -1209,7 +1423,7 @@ type ReadVolumeFileStatusRequest struct {
 func (m *ReadVolumeFileStatusRequest) Reset()                    { *m = ReadVolumeFileStatusRequest{} }
 func (m *ReadVolumeFileStatusRequest) String() string            { return proto.CompactTextString(m) }
 func (*ReadVolumeFileStatusRequest) ProtoMessage()               {}
-func (*ReadVolumeFileStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{52} }
+func (*ReadVolumeFileStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{58} }
 
 func (m *ReadVolumeFileStatusRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -1232,7 +1446,7 @@ type ReadVolumeFileStatusResponse struct {
 func (m *ReadVolumeFileStatusResponse) Reset()                    { *m = ReadVolumeFileStatusResponse{} }
 func (m *ReadVolumeFileStatusResponse) String() string            { return proto.CompactTextString(m) }
 func (*ReadVolumeFileStatusResponse) ProtoMessage()               {}
-func (*ReadVolumeFileStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{53} }
+func (*ReadVolumeFileStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{59} }
 
 func (m *ReadVolumeFileStatusResponse) GetVolumeId() uint32 {
 	if m != nil {
@@ -1291,16 +1505,18 @@ func (m *ReadVolumeFileStatusResponse) GetCollection() string {
 }
 
 type DiskStatus struct {
-	Dir  string `protobuf:"bytes,1,opt,name=dir" json:"dir,omitempty"`
-	All  uint64 `protobuf:"varint,2,opt,name=all" json:"all,omitempty"`
-	Used uint64 `protobuf:"varint,3,opt,name=used" json:"used,omitempty"`
-	Free uint64 `protobuf:"varint,4,opt,name=free" json:"free,omitempty"`
+	Dir         string  `protobuf:"bytes,1,opt,name=dir" json:"dir,omitempty"`
+	All         uint64  `protobuf:"varint,2,opt,name=all" json:"all,omitempty"`
+	Used        uint64  `protobuf:"varint,3,opt,name=used" json:"used,omitempty"`
+	Free        uint64  `protobuf:"varint,4,opt,name=free" json:"free,omitempty"`
+	PercentFree float32 `protobuf:"fixed32,5,opt,name=percent_free,json=percentFree" json:"percent_free,omitempty"`
+	PercentUsed float32 `protobuf:"fixed32,6,opt,name=percent_used,json=percentUsed" json:"percent_used,omitempty"`
 }
 
 func (m *DiskStatus) Reset()                    { *m = DiskStatus{} }
 func (m *DiskStatus) String() string            { return proto.CompactTextString(m) }
 func (*DiskStatus) ProtoMessage()               {}
-func (*DiskStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{54} }
+func (*DiskStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{60} }
 
 func (m *DiskStatus) GetDir() string {
 	if m != nil {
@@ -1330,6 +1546,20 @@ func (m *DiskStatus) GetFree() uint64 {
 	return 0
 }
 
+func (m *DiskStatus) GetPercentFree() float32 {
+	if m != nil {
+		return m.PercentFree
+	}
+	return 0
+}
+
+func (m *DiskStatus) GetPercentUsed() float32 {
+	if m != nil {
+		return m.PercentUsed
+	}
+	return 0
+}
+
 type MemStatus struct {
 	Goroutines int32  `protobuf:"varint,1,opt,name=goroutines" json:"goroutines,omitempty"`
 	All        uint64 `protobuf:"varint,2,opt,name=all" json:"all,omitempty"`
@@ -1343,7 +1573,7 @@ type MemStatus struct {
 func (m *MemStatus) Reset()                    { *m = MemStatus{} }
 func (m *MemStatus) String() string            { return proto.CompactTextString(m) }
 func (*MemStatus) ProtoMessage()               {}
-func (*MemStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{55} }
+func (*MemStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{61} }
 
 func (m *MemStatus) GetGoroutines() int32 {
 	if m != nil {
@@ -1394,6 +1624,264 @@ func (m *MemStatus) GetStack() uint64 {
 	return 0
 }
 
+// tired storage on volume servers
+type RemoteFile struct {
+	BackendType  string `protobuf:"bytes,1,opt,name=backend_type,json=backendType" json:"backend_type,omitempty"`
+	BackendId    string `protobuf:"bytes,2,opt,name=backend_id,json=backendId" json:"backend_id,omitempty"`
+	Key          string `protobuf:"bytes,3,opt,name=key" json:"key,omitempty"`
+	Offset       uint64 `protobuf:"varint,4,opt,name=offset" json:"offset,omitempty"`
+	FileSize     uint64 `protobuf:"varint,5,opt,name=file_size,json=fileSize" json:"file_size,omitempty"`
+	ModifiedTime uint64 `protobuf:"varint,6,opt,name=modified_time,json=modifiedTime" json:"modified_time,omitempty"`
+	Extension    string `protobuf:"bytes,7,opt,name=extension" json:"extension,omitempty"`
+}
+
+func (m *RemoteFile) Reset()                    { *m = RemoteFile{} }
+func (m *RemoteFile) String() string            { return proto.CompactTextString(m) }
+func (*RemoteFile) ProtoMessage()               {}
+func (*RemoteFile) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{62} }
+
+func (m *RemoteFile) GetBackendType() string {
+	if m != nil {
+		return m.BackendType
+	}
+	return ""
+}
+
+func (m *RemoteFile) GetBackendId() string {
+	if m != nil {
+		return m.BackendId
+	}
+	return ""
+}
+
+func (m *RemoteFile) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *RemoteFile) GetOffset() uint64 {
+	if m != nil {
+		return m.Offset
+	}
+	return 0
+}
+
+func (m *RemoteFile) GetFileSize() uint64 {
+	if m != nil {
+		return m.FileSize
+	}
+	return 0
+}
+
+func (m *RemoteFile) GetModifiedTime() uint64 {
+	if m != nil {
+		return m.ModifiedTime
+	}
+	return 0
+}
+
+func (m *RemoteFile) GetExtension() string {
+	if m != nil {
+		return m.Extension
+	}
+	return ""
+}
+
+type VolumeInfo struct {
+	Files       []*RemoteFile `protobuf:"bytes,1,rep,name=files" json:"files,omitempty"`
+	Version     uint32        `protobuf:"varint,2,opt,name=version" json:"version,omitempty"`
+	Replication string        `protobuf:"bytes,3,opt,name=replication" json:"replication,omitempty"`
+}
+
+func (m *VolumeInfo) Reset()                    { *m = VolumeInfo{} }
+func (m *VolumeInfo) String() string            { return proto.CompactTextString(m) }
+func (*VolumeInfo) ProtoMessage()               {}
+func (*VolumeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{63} }
+
+func (m *VolumeInfo) GetFiles() []*RemoteFile {
+	if m != nil {
+		return m.Files
+	}
+	return nil
+}
+
+func (m *VolumeInfo) GetVersion() uint32 {
+	if m != nil {
+		return m.Version
+	}
+	return 0
+}
+
+func (m *VolumeInfo) GetReplication() string {
+	if m != nil {
+		return m.Replication
+	}
+	return ""
+}
+
+type VolumeTierMoveDatToRemoteRequest struct {
+	VolumeId               uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
+	Collection             string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
+	DestinationBackendName string `protobuf:"bytes,3,opt,name=destination_backend_name,json=destinationBackendName" json:"destination_backend_name,omitempty"`
+	KeepLocalDatFile       bool   `protobuf:"varint,4,opt,name=keep_local_dat_file,json=keepLocalDatFile" json:"keep_local_dat_file,omitempty"`
+}
+
+func (m *VolumeTierMoveDatToRemoteRequest) Reset()         { *m = VolumeTierMoveDatToRemoteRequest{} }
+func (m *VolumeTierMoveDatToRemoteRequest) String() string { return proto.CompactTextString(m) }
+func (*VolumeTierMoveDatToRemoteRequest) ProtoMessage()    {}
+func (*VolumeTierMoveDatToRemoteRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{64}
+}
+
+func (m *VolumeTierMoveDatToRemoteRequest) GetVolumeId() uint32 {
+	if m != nil {
+		return m.VolumeId
+	}
+	return 0
+}
+
+func (m *VolumeTierMoveDatToRemoteRequest) GetCollection() string {
+	if m != nil {
+		return m.Collection
+	}
+	return ""
+}
+
+func (m *VolumeTierMoveDatToRemoteRequest) GetDestinationBackendName() string {
+	if m != nil {
+		return m.DestinationBackendName
+	}
+	return ""
+}
+
+func (m *VolumeTierMoveDatToRemoteRequest) GetKeepLocalDatFile() bool {
+	if m != nil {
+		return m.KeepLocalDatFile
+	}
+	return false
+}
+
+type VolumeTierMoveDatToRemoteResponse struct {
+	Processed           int64   `protobuf:"varint,1,opt,name=processed" json:"processed,omitempty"`
+	ProcessedPercentage float32 `protobuf:"fixed32,2,opt,name=processedPercentage" json:"processedPercentage,omitempty"`
+}
+
+func (m *VolumeTierMoveDatToRemoteResponse) Reset()         { *m = VolumeTierMoveDatToRemoteResponse{} }
+func (m *VolumeTierMoveDatToRemoteResponse) String() string { return proto.CompactTextString(m) }
+func (*VolumeTierMoveDatToRemoteResponse) ProtoMessage()    {}
+func (*VolumeTierMoveDatToRemoteResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{65}
+}
+
+func (m *VolumeTierMoveDatToRemoteResponse) GetProcessed() int64 {
+	if m != nil {
+		return m.Processed
+	}
+	return 0
+}
+
+func (m *VolumeTierMoveDatToRemoteResponse) GetProcessedPercentage() float32 {
+	if m != nil {
+		return m.ProcessedPercentage
+	}
+	return 0
+}
+
+type VolumeTierMoveDatFromRemoteRequest struct {
+	VolumeId          uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
+	Collection        string `protobuf:"bytes,2,opt,name=collection" json:"collection,omitempty"`
+	KeepRemoteDatFile bool   `protobuf:"varint,3,opt,name=keep_remote_dat_file,json=keepRemoteDatFile" json:"keep_remote_dat_file,omitempty"`
+}
+
+func (m *VolumeTierMoveDatFromRemoteRequest) Reset()         { *m = VolumeTierMoveDatFromRemoteRequest{} }
+func (m *VolumeTierMoveDatFromRemoteRequest) String() string { return proto.CompactTextString(m) }
+func (*VolumeTierMoveDatFromRemoteRequest) ProtoMessage()    {}
+func (*VolumeTierMoveDatFromRemoteRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{66}
+}
+
+func (m *VolumeTierMoveDatFromRemoteRequest) GetVolumeId() uint32 {
+	if m != nil {
+		return m.VolumeId
+	}
+	return 0
+}
+
+func (m *VolumeTierMoveDatFromRemoteRequest) GetCollection() string {
+	if m != nil {
+		return m.Collection
+	}
+	return ""
+}
+
+func (m *VolumeTierMoveDatFromRemoteRequest) GetKeepRemoteDatFile() bool {
+	if m != nil {
+		return m.KeepRemoteDatFile
+	}
+	return false
+}
+
+type VolumeTierMoveDatFromRemoteResponse struct {
+	Processed           int64   `protobuf:"varint,1,opt,name=processed" json:"processed,omitempty"`
+	ProcessedPercentage float32 `protobuf:"fixed32,2,opt,name=processedPercentage" json:"processedPercentage,omitempty"`
+}
+
+func (m *VolumeTierMoveDatFromRemoteResponse) Reset()         { *m = VolumeTierMoveDatFromRemoteResponse{} }
+func (m *VolumeTierMoveDatFromRemoteResponse) String() string { return proto.CompactTextString(m) }
+func (*VolumeTierMoveDatFromRemoteResponse) ProtoMessage()    {}
+func (*VolumeTierMoveDatFromRemoteResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{67}
+}
+
+func (m *VolumeTierMoveDatFromRemoteResponse) GetProcessed() int64 {
+	if m != nil {
+		return m.Processed
+	}
+	return 0
+}
+
+func (m *VolumeTierMoveDatFromRemoteResponse) GetProcessedPercentage() float32 {
+	if m != nil {
+		return m.ProcessedPercentage
+	}
+	return 0
+}
+
+type VolumeServerStatusRequest struct {
+}
+
+func (m *VolumeServerStatusRequest) Reset()                    { *m = VolumeServerStatusRequest{} }
+func (m *VolumeServerStatusRequest) String() string            { return proto.CompactTextString(m) }
+func (*VolumeServerStatusRequest) ProtoMessage()               {}
+func (*VolumeServerStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{68} }
+
+type VolumeServerStatusResponse struct {
+	DiskStatuses []*DiskStatus `protobuf:"bytes,1,rep,name=disk_statuses,json=diskStatuses" json:"disk_statuses,omitempty"`
+	MemoryStatus *MemStatus    `protobuf:"bytes,2,opt,name=memory_status,json=memoryStatus" json:"memory_status,omitempty"`
+}
+
+func (m *VolumeServerStatusResponse) Reset()                    { *m = VolumeServerStatusResponse{} }
+func (m *VolumeServerStatusResponse) String() string            { return proto.CompactTextString(m) }
+func (*VolumeServerStatusResponse) ProtoMessage()               {}
+func (*VolumeServerStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{69} }
+
+func (m *VolumeServerStatusResponse) GetDiskStatuses() []*DiskStatus {
+	if m != nil {
+		return m.DiskStatuses
+	}
+	return nil
+}
+
+func (m *VolumeServerStatusResponse) GetMemoryStatus() *MemStatus {
+	if m != nil {
+		return m.MemoryStatus
+	}
+	return nil
+}
+
+// select on volume servers
 type QueryRequest struct {
 	Selections          []string                          `protobuf:"bytes,1,rep,name=selections" json:"selections,omitempty"`
 	FromFileIds         []string                          `protobuf:"bytes,2,rep,name=from_file_ids,json=fromFileIds" json:"from_file_ids,omitempty"`
@@ -1405,7 +1893,7 @@ type QueryRequest struct {
 func (m *QueryRequest) Reset()                    { *m = QueryRequest{} }
 func (m *QueryRequest) String() string            { return proto.CompactTextString(m) }
 func (*QueryRequest) ProtoMessage()               {}
-func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56} }
+func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{70} }
 
 func (m *QueryRequest) GetSelections() []string {
 	if m != nil {
@@ -1451,7 +1939,7 @@ type QueryRequest_Filter struct {
 func (m *QueryRequest_Filter) Reset()                    { *m = QueryRequest_Filter{} }
 func (m *QueryRequest_Filter) String() string            { return proto.CompactTextString(m) }
 func (*QueryRequest_Filter) ProtoMessage()               {}
-func (*QueryRequest_Filter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{56, 0} }
+func (*QueryRequest_Filter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{70, 0} }
 
 func (m *QueryRequest_Filter) GetField() string {
 	if m != nil {
@@ -1486,7 +1974,7 @@ func (m *QueryRequest_InputSerialization) Reset()         { *m = QueryRequest_In
 func (m *QueryRequest_InputSerialization) String() string { return proto.CompactTextString(m) }
 func (*QueryRequest_InputSerialization) ProtoMessage()    {}
 func (*QueryRequest_InputSerialization) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{56, 1}
+	return fileDescriptor0, []int{70, 1}
 }
 
 func (m *QueryRequest_InputSerialization) GetCompressionType() string {
@@ -1534,7 +2022,7 @@ func (m *QueryRequest_InputSerialization_CSVInput) Reset() {
 func (m *QueryRequest_InputSerialization_CSVInput) String() string { return proto.CompactTextString(m) }
 func (*QueryRequest_InputSerialization_CSVInput) ProtoMessage()    {}
 func (*QueryRequest_InputSerialization_CSVInput) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{56, 1, 0}
+	return fileDescriptor0, []int{70, 1, 0}
 }
 
 func (m *QueryRequest_InputSerialization_CSVInput) GetFileHeaderInfo() string {
@@ -1596,7 +2084,7 @@ func (m *QueryRequest_InputSerialization_JSONInput) Reset() {
 func (m *QueryRequest_InputSerialization_JSONInput) String() string { return proto.CompactTextString(m) }
 func (*QueryRequest_InputSerialization_JSONInput) ProtoMessage()    {}
 func (*QueryRequest_InputSerialization_JSONInput) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{56, 1, 1}
+	return fileDescriptor0, []int{70, 1, 1}
 }
 
 func (m *QueryRequest_InputSerialization_JSONInput) GetType() string {
@@ -1617,7 +2105,7 @@ func (m *QueryRequest_InputSerialization_ParquetInput) String() string {
 }
 func (*QueryRequest_InputSerialization_ParquetInput) ProtoMessage() {}
 func (*QueryRequest_InputSerialization_ParquetInput) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{56, 1, 2}
+	return fileDescriptor0, []int{70, 1, 2}
 }
 
 type QueryRequest_OutputSerialization struct {
@@ -1629,7 +2117,7 @@ func (m *QueryRequest_OutputSerialization) Reset()         { *m = QueryRequest_O
 func (m *QueryRequest_OutputSerialization) String() string { return proto.CompactTextString(m) }
 func (*QueryRequest_OutputSerialization) ProtoMessage()    {}
 func (*QueryRequest_OutputSerialization) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{56, 2}
+	return fileDescriptor0, []int{70, 2}
 }
 
 func (m *QueryRequest_OutputSerialization) GetCsvOutput() *QueryRequest_OutputSerialization_CSVOutput {
@@ -1662,7 +2150,7 @@ func (m *QueryRequest_OutputSerialization_CSVOutput) String() string {
 }
 func (*QueryRequest_OutputSerialization_CSVOutput) ProtoMessage() {}
 func (*QueryRequest_OutputSerialization_CSVOutput) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{56, 2, 0}
+	return fileDescriptor0, []int{70, 2, 0}
 }
 
 func (m *QueryRequest_OutputSerialization_CSVOutput) GetQuoteFields() string {
@@ -1712,7 +2200,7 @@ func (m *QueryRequest_OutputSerialization_JSONOutput) String() string {
 }
 func (*QueryRequest_OutputSerialization_JSONOutput) ProtoMessage() {}
 func (*QueryRequest_OutputSerialization_JSONOutput) Descriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{56, 2, 1}
+	return fileDescriptor0, []int{70, 2, 1}
 }
 
 func (m *QueryRequest_OutputSerialization_JSONOutput) GetRecordDelimiter() string {
@@ -1729,7 +2217,7 @@ type QueriedStripe struct {
 func (m *QueriedStripe) Reset()                    { *m = QueriedStripe{} }
 func (m *QueriedStripe) String() string            { return proto.CompactTextString(m) }
 func (*QueriedStripe) ProtoMessage()               {}
-func (*QueriedStripe) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{57} }
+func (*QueriedStripe) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{71} }
 
 func (m *QueriedStripe) GetRecords() []byte {
 	if m != nil {
@@ -1742,6 +2230,8 @@ func init() {
 	proto.RegisterType((*BatchDeleteRequest)(nil), "volume_server_pb.BatchDeleteRequest")
 	proto.RegisterType((*BatchDeleteResponse)(nil), "volume_server_pb.BatchDeleteResponse")
 	proto.RegisterType((*DeleteResult)(nil), "volume_server_pb.DeleteResult")
+	proto.RegisterType((*FileGetRequest)(nil), "volume_server_pb.FileGetRequest")
+	proto.RegisterType((*FileGetResponse)(nil), "volume_server_pb.FileGetResponse")
 	proto.RegisterType((*Empty)(nil), "volume_server_pb.Empty")
 	proto.RegisterType((*VacuumVolumeCheckRequest)(nil), "volume_server_pb.VacuumVolumeCheckRequest")
 	proto.RegisterType((*VacuumVolumeCheckResponse)(nil), "volume_server_pb.VacuumVolumeCheckResponse")
@@ -1767,6 +2257,8 @@ func init() {
 	proto.RegisterType((*VolumeDeleteResponse)(nil), "volume_server_pb.VolumeDeleteResponse")
 	proto.RegisterType((*VolumeMarkReadonlyRequest)(nil), "volume_server_pb.VolumeMarkReadonlyRequest")
 	proto.RegisterType((*VolumeMarkReadonlyResponse)(nil), "volume_server_pb.VolumeMarkReadonlyResponse")
+	proto.RegisterType((*VolumeConfigureRequest)(nil), "volume_server_pb.VolumeConfigureRequest")
+	proto.RegisterType((*VolumeConfigureResponse)(nil), "volume_server_pb.VolumeConfigureResponse")
 	proto.RegisterType((*VolumeCopyRequest)(nil), "volume_server_pb.VolumeCopyRequest")
 	proto.RegisterType((*VolumeCopyResponse)(nil), "volume_server_pb.VolumeCopyResponse")
 	proto.RegisterType((*CopyFileRequest)(nil), "volume_server_pb.CopyFileRequest")
@@ -1791,10 +2283,20 @@ func init() {
 	proto.RegisterType((*VolumeEcShardReadResponse)(nil), "volume_server_pb.VolumeEcShardReadResponse")
 	proto.RegisterType((*VolumeEcBlobDeleteRequest)(nil), "volume_server_pb.VolumeEcBlobDeleteRequest")
 	proto.RegisterType((*VolumeEcBlobDeleteResponse)(nil), "volume_server_pb.VolumeEcBlobDeleteResponse")
+	proto.RegisterType((*VolumeEcShardsToVolumeRequest)(nil), "volume_server_pb.VolumeEcShardsToVolumeRequest")
+	proto.RegisterType((*VolumeEcShardsToVolumeResponse)(nil), "volume_server_pb.VolumeEcShardsToVolumeResponse")
 	proto.RegisterType((*ReadVolumeFileStatusRequest)(nil), "volume_server_pb.ReadVolumeFileStatusRequest")
 	proto.RegisterType((*ReadVolumeFileStatusResponse)(nil), "volume_server_pb.ReadVolumeFileStatusResponse")
 	proto.RegisterType((*DiskStatus)(nil), "volume_server_pb.DiskStatus")
 	proto.RegisterType((*MemStatus)(nil), "volume_server_pb.MemStatus")
+	proto.RegisterType((*RemoteFile)(nil), "volume_server_pb.RemoteFile")
+	proto.RegisterType((*VolumeInfo)(nil), "volume_server_pb.VolumeInfo")
+	proto.RegisterType((*VolumeTierMoveDatToRemoteRequest)(nil), "volume_server_pb.VolumeTierMoveDatToRemoteRequest")
+	proto.RegisterType((*VolumeTierMoveDatToRemoteResponse)(nil), "volume_server_pb.VolumeTierMoveDatToRemoteResponse")
+	proto.RegisterType((*VolumeTierMoveDatFromRemoteRequest)(nil), "volume_server_pb.VolumeTierMoveDatFromRemoteRequest")
+	proto.RegisterType((*VolumeTierMoveDatFromRemoteResponse)(nil), "volume_server_pb.VolumeTierMoveDatFromRemoteResponse")
+	proto.RegisterType((*VolumeServerStatusRequest)(nil), "volume_server_pb.VolumeServerStatusRequest")
+	proto.RegisterType((*VolumeServerStatusResponse)(nil), "volume_server_pb.VolumeServerStatusResponse")
 	proto.RegisterType((*QueryRequest)(nil), "volume_server_pb.QueryRequest")
 	proto.RegisterType((*QueryRequest_Filter)(nil), "volume_server_pb.QueryRequest.Filter")
 	proto.RegisterType((*QueryRequest_InputSerialization)(nil), "volume_server_pb.QueryRequest.InputSerialization")
@@ -1820,6 +2322,7 @@ const _ = grpc.SupportPackageIsVersion4
 type VolumeServerClient interface {
 	// Experts only: takes multiple fid parameters. This function does not propagate deletes to replicas.
 	BatchDelete(ctx context.Context, in *BatchDeleteRequest, opts ...grpc.CallOption) (*BatchDeleteResponse, error)
+	FileGet(ctx context.Context, in *FileGetRequest, opts ...grpc.CallOption) (VolumeServer_FileGetClient, error)
 	VacuumVolumeCheck(ctx context.Context, in *VacuumVolumeCheckRequest, opts ...grpc.CallOption) (*VacuumVolumeCheckResponse, error)
 	VacuumVolumeCompact(ctx context.Context, in *VacuumVolumeCompactRequest, opts ...grpc.CallOption) (*VacuumVolumeCompactResponse, error)
 	VacuumVolumeCommit(ctx context.Context, in *VacuumVolumeCommitRequest, opts ...grpc.CallOption) (*VacuumVolumeCommitResponse, error)
@@ -1832,6 +2335,7 @@ type VolumeServerClient interface {
 	VolumeUnmount(ctx context.Context, in *VolumeUnmountRequest, opts ...grpc.CallOption) (*VolumeUnmountResponse, error)
 	VolumeDelete(ctx context.Context, in *VolumeDeleteRequest, opts ...grpc.CallOption) (*VolumeDeleteResponse, error)
 	VolumeMarkReadonly(ctx context.Context, in *VolumeMarkReadonlyRequest, opts ...grpc.CallOption) (*VolumeMarkReadonlyResponse, error)
+	VolumeConfigure(ctx context.Context, in *VolumeConfigureRequest, opts ...grpc.CallOption) (*VolumeConfigureResponse, error)
 	// copy the .idx .dat files, and mount this volume
 	VolumeCopy(ctx context.Context, in *VolumeCopyRequest, opts ...grpc.CallOption) (*VolumeCopyResponse, error)
 	ReadVolumeFileStatus(ctx context.Context, in *ReadVolumeFileStatusRequest, opts ...grpc.CallOption) (*ReadVolumeFileStatusResponse, error)
@@ -1847,7 +2351,12 @@ type VolumeServerClient interface {
 	VolumeEcShardsUnmount(ctx context.Context, in *VolumeEcShardsUnmountRequest, opts ...grpc.CallOption) (*VolumeEcShardsUnmountResponse, error)
 	VolumeEcShardRead(ctx context.Context, in *VolumeEcShardReadRequest, opts ...grpc.CallOption) (VolumeServer_VolumeEcShardReadClient, error)
 	VolumeEcBlobDelete(ctx context.Context, in *VolumeEcBlobDeleteRequest, opts ...grpc.CallOption) (*VolumeEcBlobDeleteResponse, error)
-	// query
+	VolumeEcShardsToVolume(ctx context.Context, in *VolumeEcShardsToVolumeRequest, opts ...grpc.CallOption) (*VolumeEcShardsToVolumeResponse, error)
+	// tiered storage
+	VolumeTierMoveDatToRemote(ctx context.Context, in *VolumeTierMoveDatToRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatToRemoteClient, error)
+	VolumeTierMoveDatFromRemote(ctx context.Context, in *VolumeTierMoveDatFromRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatFromRemoteClient, error)
+	VolumeServerStatus(ctx context.Context, in *VolumeServerStatusRequest, opts ...grpc.CallOption) (*VolumeServerStatusResponse, error)
+	// <experimental> query
 	Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (VolumeServer_QueryClient, error)
 }
 
@@ -1868,6 +2377,38 @@ func (c *volumeServerClient) BatchDelete(ctx context.Context, in *BatchDeleteReq
 	return out, nil
 }
 
+func (c *volumeServerClient) FileGet(ctx context.Context, in *FileGetRequest, opts ...grpc.CallOption) (VolumeServer_FileGetClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[0], c.cc, "/volume_server_pb.VolumeServer/FileGet", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &volumeServerFileGetClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type VolumeServer_FileGetClient interface {
+	Recv() (*FileGetResponse, error)
+	grpc.ClientStream
+}
+
+type volumeServerFileGetClient struct {
+	grpc.ClientStream
+}
+
+func (x *volumeServerFileGetClient) Recv() (*FileGetResponse, error) {
+	m := new(FileGetResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func (c *volumeServerClient) VacuumVolumeCheck(ctx context.Context, in *VacuumVolumeCheckRequest, opts ...grpc.CallOption) (*VacuumVolumeCheckResponse, error) {
 	out := new(VacuumVolumeCheckResponse)
 	err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VacuumVolumeCheck", in, out, c.cc, opts...)
@@ -1932,7 +2473,7 @@ func (c *volumeServerClient) VolumeSyncStatus(ctx context.Context, in *VolumeSyn
 }
 
 func (c *volumeServerClient) VolumeIncrementalCopy(ctx context.Context, in *VolumeIncrementalCopyRequest, opts ...grpc.CallOption) (VolumeServer_VolumeIncrementalCopyClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[0], c.cc, "/volume_server_pb.VolumeServer/VolumeIncrementalCopy", opts...)
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[1], c.cc, "/volume_server_pb.VolumeServer/VolumeIncrementalCopy", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -1999,6 +2540,15 @@ func (c *volumeServerClient) VolumeMarkReadonly(ctx context.Context, in *VolumeM
 	return out, nil
 }
 
+func (c *volumeServerClient) VolumeConfigure(ctx context.Context, in *VolumeConfigureRequest, opts ...grpc.CallOption) (*VolumeConfigureResponse, error) {
+	out := new(VolumeConfigureResponse)
+	err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VolumeConfigure", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *volumeServerClient) VolumeCopy(ctx context.Context, in *VolumeCopyRequest, opts ...grpc.CallOption) (*VolumeCopyResponse, error) {
 	out := new(VolumeCopyResponse)
 	err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VolumeCopy", in, out, c.cc, opts...)
@@ -2018,7 +2568,7 @@ func (c *volumeServerClient) ReadVolumeFileStatus(ctx context.Context, in *ReadV
 }
 
 func (c *volumeServerClient) CopyFile(ctx context.Context, in *CopyFileRequest, opts ...grpc.CallOption) (VolumeServer_CopyFileClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[1], c.cc, "/volume_server_pb.VolumeServer/CopyFile", opts...)
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[2], c.cc, "/volume_server_pb.VolumeServer/CopyFile", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -2050,7 +2600,7 @@ func (x *volumeServerCopyFileClient) Recv() (*CopyFileResponse, error) {
 }
 
 func (c *volumeServerClient) VolumeTailSender(ctx context.Context, in *VolumeTailSenderRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTailSenderClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[2], c.cc, "/volume_server_pb.VolumeServer/VolumeTailSender", opts...)
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[3], c.cc, "/volume_server_pb.VolumeServer/VolumeTailSender", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -2145,7 +2695,7 @@ func (c *volumeServerClient) VolumeEcShardsUnmount(ctx context.Context, in *Volu
 }
 
 func (c *volumeServerClient) VolumeEcShardRead(ctx context.Context, in *VolumeEcShardReadRequest, opts ...grpc.CallOption) (VolumeServer_VolumeEcShardReadClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[3], c.cc, "/volume_server_pb.VolumeServer/VolumeEcShardRead", opts...)
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[4], c.cc, "/volume_server_pb.VolumeServer/VolumeEcShardRead", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -2185,8 +2735,90 @@ func (c *volumeServerClient) VolumeEcBlobDelete(ctx context.Context, in *VolumeE
 	return out, nil
 }
 
+func (c *volumeServerClient) VolumeEcShardsToVolume(ctx context.Context, in *VolumeEcShardsToVolumeRequest, opts ...grpc.CallOption) (*VolumeEcShardsToVolumeResponse, error) {
+	out := new(VolumeEcShardsToVolumeResponse)
+	err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VolumeEcShardsToVolume", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *volumeServerClient) VolumeTierMoveDatToRemote(ctx context.Context, in *VolumeTierMoveDatToRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatToRemoteClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[5], c.cc, "/volume_server_pb.VolumeServer/VolumeTierMoveDatToRemote", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &volumeServerVolumeTierMoveDatToRemoteClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type VolumeServer_VolumeTierMoveDatToRemoteClient interface {
+	Recv() (*VolumeTierMoveDatToRemoteResponse, error)
+	grpc.ClientStream
+}
+
+type volumeServerVolumeTierMoveDatToRemoteClient struct {
+	grpc.ClientStream
+}
+
+func (x *volumeServerVolumeTierMoveDatToRemoteClient) Recv() (*VolumeTierMoveDatToRemoteResponse, error) {
+	m := new(VolumeTierMoveDatToRemoteResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *volumeServerClient) VolumeTierMoveDatFromRemote(ctx context.Context, in *VolumeTierMoveDatFromRemoteRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTierMoveDatFromRemoteClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[6], c.cc, "/volume_server_pb.VolumeServer/VolumeTierMoveDatFromRemote", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &volumeServerVolumeTierMoveDatFromRemoteClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type VolumeServer_VolumeTierMoveDatFromRemoteClient interface {
+	Recv() (*VolumeTierMoveDatFromRemoteResponse, error)
+	grpc.ClientStream
+}
+
+type volumeServerVolumeTierMoveDatFromRemoteClient struct {
+	grpc.ClientStream
+}
+
+func (x *volumeServerVolumeTierMoveDatFromRemoteClient) Recv() (*VolumeTierMoveDatFromRemoteResponse, error) {
+	m := new(VolumeTierMoveDatFromRemoteResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *volumeServerClient) VolumeServerStatus(ctx context.Context, in *VolumeServerStatusRequest, opts ...grpc.CallOption) (*VolumeServerStatusResponse, error) {
+	out := new(VolumeServerStatusResponse)
+	err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VolumeServerStatus", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *volumeServerClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (VolumeServer_QueryClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[4], c.cc, "/volume_server_pb.VolumeServer/Query", opts...)
+	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[7], c.cc, "/volume_server_pb.VolumeServer/Query", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -2222,6 +2854,7 @@ func (x *volumeServerQueryClient) Recv() (*QueriedStripe, error) {
 type VolumeServerServer interface {
 	// Experts only: takes multiple fid parameters. This function does not propagate deletes to replicas.
 	BatchDelete(context.Context, *BatchDeleteRequest) (*BatchDeleteResponse, error)
+	FileGet(*FileGetRequest, VolumeServer_FileGetServer) error
 	VacuumVolumeCheck(context.Context, *VacuumVolumeCheckRequest) (*VacuumVolumeCheckResponse, error)
 	VacuumVolumeCompact(context.Context, *VacuumVolumeCompactRequest) (*VacuumVolumeCompactResponse, error)
 	VacuumVolumeCommit(context.Context, *VacuumVolumeCommitRequest) (*VacuumVolumeCommitResponse, error)
@@ -2234,6 +2867,7 @@ type VolumeServerServer interface {
 	VolumeUnmount(context.Context, *VolumeUnmountRequest) (*VolumeUnmountResponse, error)
 	VolumeDelete(context.Context, *VolumeDeleteRequest) (*VolumeDeleteResponse, error)
 	VolumeMarkReadonly(context.Context, *VolumeMarkReadonlyRequest) (*VolumeMarkReadonlyResponse, error)
+	VolumeConfigure(context.Context, *VolumeConfigureRequest) (*VolumeConfigureResponse, error)
 	// copy the .idx .dat files, and mount this volume
 	VolumeCopy(context.Context, *VolumeCopyRequest) (*VolumeCopyResponse, error)
 	ReadVolumeFileStatus(context.Context, *ReadVolumeFileStatusRequest) (*ReadVolumeFileStatusResponse, error)
@@ -2249,7 +2883,12 @@ type VolumeServerServer interface {
 	VolumeEcShardsUnmount(context.Context, *VolumeEcShardsUnmountRequest) (*VolumeEcShardsUnmountResponse, error)
 	VolumeEcShardRead(*VolumeEcShardReadRequest, VolumeServer_VolumeEcShardReadServer) error
 	VolumeEcBlobDelete(context.Context, *VolumeEcBlobDeleteRequest) (*VolumeEcBlobDeleteResponse, error)
-	// query
+	VolumeEcShardsToVolume(context.Context, *VolumeEcShardsToVolumeRequest) (*VolumeEcShardsToVolumeResponse, error)
+	// tiered storage
+	VolumeTierMoveDatToRemote(*VolumeTierMoveDatToRemoteRequest, VolumeServer_VolumeTierMoveDatToRemoteServer) error
+	VolumeTierMoveDatFromRemote(*VolumeTierMoveDatFromRemoteRequest, VolumeServer_VolumeTierMoveDatFromRemoteServer) error
+	VolumeServerStatus(context.Context, *VolumeServerStatusRequest) (*VolumeServerStatusResponse, error)
+	// <experimental> query
 	Query(*QueryRequest, VolumeServer_QueryServer) error
 }
 
@@ -2275,6 +2914,27 @@ func _VolumeServer_BatchDelete_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
+func _VolumeServer_FileGet_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(FileGetRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(VolumeServerServer).FileGet(m, &volumeServerFileGetServer{stream})
+}
+
+type VolumeServer_FileGetServer interface {
+	Send(*FileGetResponse) error
+	grpc.ServerStream
+}
+
+type volumeServerFileGetServer struct {
+	grpc.ServerStream
+}
+
+func (x *volumeServerFileGetServer) Send(m *FileGetResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 func _VolumeServer_VacuumVolumeCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(VacuumVolumeCheckRequest)
 	if err := dec(in); err != nil {
@@ -2494,6 +3154,24 @@ func _VolumeServer_VolumeMarkReadonly_Handler(srv interface{}, ctx context.Conte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _VolumeServer_VolumeConfigure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(VolumeConfigureRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolumeServerServer).VolumeConfigure(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/volume_server_pb.VolumeServer/VolumeConfigure",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolumeServerServer).VolumeConfigure(ctx, req.(*VolumeConfigureRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _VolumeServer_VolumeCopy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(VolumeCopyRequest)
 	if err := dec(in); err != nil {
@@ -2737,6 +3415,84 @@ func _VolumeServer_VolumeEcBlobDelete_Handler(srv interface{}, ctx context.Conte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _VolumeServer_VolumeEcShardsToVolume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(VolumeEcShardsToVolumeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolumeServerServer).VolumeEcShardsToVolume(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/volume_server_pb.VolumeServer/VolumeEcShardsToVolume",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolumeServerServer).VolumeEcShardsToVolume(ctx, req.(*VolumeEcShardsToVolumeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _VolumeServer_VolumeTierMoveDatToRemote_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(VolumeTierMoveDatToRemoteRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(VolumeServerServer).VolumeTierMoveDatToRemote(m, &volumeServerVolumeTierMoveDatToRemoteServer{stream})
+}
+
+type VolumeServer_VolumeTierMoveDatToRemoteServer interface {
+	Send(*VolumeTierMoveDatToRemoteResponse) error
+	grpc.ServerStream
+}
+
+type volumeServerVolumeTierMoveDatToRemoteServer struct {
+	grpc.ServerStream
+}
+
+func (x *volumeServerVolumeTierMoveDatToRemoteServer) Send(m *VolumeTierMoveDatToRemoteResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _VolumeServer_VolumeTierMoveDatFromRemote_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(VolumeTierMoveDatFromRemoteRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(VolumeServerServer).VolumeTierMoveDatFromRemote(m, &volumeServerVolumeTierMoveDatFromRemoteServer{stream})
+}
+
+type VolumeServer_VolumeTierMoveDatFromRemoteServer interface {
+	Send(*VolumeTierMoveDatFromRemoteResponse) error
+	grpc.ServerStream
+}
+
+type volumeServerVolumeTierMoveDatFromRemoteServer struct {
+	grpc.ServerStream
+}
+
+func (x *volumeServerVolumeTierMoveDatFromRemoteServer) Send(m *VolumeTierMoveDatFromRemoteResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _VolumeServer_VolumeServerStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(VolumeServerStatusRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolumeServerServer).VolumeServerStatus(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/volume_server_pb.VolumeServer/VolumeServerStatus",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolumeServerServer).VolumeServerStatus(ctx, req.(*VolumeServerStatusRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _VolumeServer_Query_Handler(srv interface{}, stream grpc.ServerStream) error {
 	m := new(QueryRequest)
 	if err := stream.RecvMsg(m); err != nil {
@@ -2811,6 +3567,10 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 			Handler:    _VolumeServer_VolumeMarkReadonly_Handler,
 		},
 		{
+			MethodName: "VolumeConfigure",
+			Handler:    _VolumeServer_VolumeConfigure_Handler,
+		},
+		{
 			MethodName: "VolumeCopy",
 			Handler:    _VolumeServer_VolumeCopy_Handler,
 		},
@@ -2850,9 +3610,22 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 			MethodName: "VolumeEcBlobDelete",
 			Handler:    _VolumeServer_VolumeEcBlobDelete_Handler,
 		},
+		{
+			MethodName: "VolumeEcShardsToVolume",
+			Handler:    _VolumeServer_VolumeEcShardsToVolume_Handler,
+		},
+		{
+			MethodName: "VolumeServerStatus",
+			Handler:    _VolumeServer_VolumeServerStatus_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
+			StreamName:    "FileGet",
+			Handler:       _VolumeServer_FileGet_Handler,
+			ServerStreams: true,
+		},
+		{
 			StreamName:    "VolumeIncrementalCopy",
 			Handler:       _VolumeServer_VolumeIncrementalCopy_Handler,
 			ServerStreams: true,
@@ -2873,6 +3646,16 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 			ServerStreams: true,
 		},
 		{
+			StreamName:    "VolumeTierMoveDatToRemote",
+			Handler:       _VolumeServer_VolumeTierMoveDatToRemote_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "VolumeTierMoveDatFromRemote",
+			Handler:       _VolumeServer_VolumeTierMoveDatFromRemote_Handler,
+			ServerStreams: true,
+		},
+		{
 			StreamName:    "Query",
 			Handler:       _VolumeServer_Query_Handler,
 			ServerStreams: true,
@@ -2884,162 +3667,210 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 2503 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x1a, 0x4d, 0x77, 0x1c, 0x47,
-	0x51, 0xeb, 0x5d, 0x49, 0xbb, 0xb5, 0x2b, 0x4b, 0x6e, 0xc9, 0xd2, 0x7a, 0x6c, 0xc9, 0xca, 0xe4,
-	0xc3, 0xb2, 0x9d, 0xc8, 0x8e, 0x02, 0x24, 0x24, 0x04, 0xb0, 0x65, 0x1b, 0x4c, 0x62, 0x99, 0x8c,
-	0x1c, 0x13, 0x70, 0x1e, 0xf3, 0x5a, 0x33, 0x2d, 0x6b, 0xd0, 0xcc, 0xf4, 0x78, 0xa6, 0x47, 0xd6,
-	0xfa, 0xc1, 0x29, 0x5c, 0xf9, 0x01, 0x9c, 0x39, 0x71, 0xe1, 0xca, 0x0f, 0xe0, 0xc2, 0x0f, 0x80,
-	0x2b, 0x17, 0xce, 0x1c, 0xb8, 0xf1, 0x1e, 0x17, 0x5e, 0x7f, 0xcc, 0xec, 0x7c, 0x6a, 0x47, 0xb1,
-	0xdf, 0xe3, 0xe5, 0xd6, 0x53, 0x5d, 0x1f, 0x5d, 0xd5, 0x55, 0xd5, 0xd5, 0xd5, 0x03, 0x8b, 0x47,
-	0xd4, 0x8d, 0x3d, 0x62, 0x46, 0x24, 0x3c, 0x22, 0xe1, 0x66, 0x10, 0x52, 0x46, 0xd1, 0x42, 0x0e,
-	0x68, 0x06, 0x7b, 0xfa, 0x0d, 0x40, 0xb7, 0x31, 0xb3, 0x0e, 0xee, 0x10, 0x97, 0x30, 0x62, 0x90,
-	0x67, 0x31, 0x89, 0x18, 0xba, 0x00, 0xdd, 0x7d, 0xc7, 0x25, 0xa6, 0x63, 0x47, 0xc3, 0xd6, 0x7a,
-	0x7b, 0xa3, 0x67, 0xcc, 0xf2, 0xef, 0xfb, 0x76, 0xa4, 0x3f, 0x84, 0xc5, 0x1c, 0x41, 0x14, 0x50,
-	0x3f, 0x22, 0xe8, 0x03, 0x98, 0x0d, 0x49, 0x14, 0xbb, 0x4c, 0x12, 0xf4, 0xb7, 0xd6, 0x36, 0x8b,
-	0xb2, 0x36, 0x53, 0x92, 0xd8, 0x65, 0x46, 0x82, 0xae, 0x7f, 0xd5, 0x82, 0x41, 0x76, 0x06, 0xad,
-	0xc0, 0xac, 0x12, 0x3e, 0x6c, 0xad, 0xb7, 0x36, 0x7a, 0xc6, 0x8c, 0x94, 0x8d, 0x96, 0x61, 0x26,
-	0x62, 0x98, 0xc5, 0xd1, 0xf0, 0xcc, 0x7a, 0x6b, 0x63, 0xda, 0x50, 0x5f, 0x68, 0x09, 0xa6, 0x49,
-	0x18, 0xd2, 0x70, 0xd8, 0x16, 0xe8, 0xf2, 0x03, 0x21, 0xe8, 0x44, 0xce, 0x0b, 0x32, 0xec, 0xac,
-	0xb7, 0x36, 0xe6, 0x0c, 0x31, 0x46, 0x43, 0x98, 0x3d, 0x22, 0x61, 0xe4, 0x50, 0x7f, 0x38, 0x2d,
-	0xc0, 0xc9, 0xa7, 0x3e, 0x0b, 0xd3, 0x77, 0xbd, 0x80, 0x8d, 0xf4, 0xf7, 0x61, 0xf8, 0x18, 0x5b,
-	0x71, 0xec, 0x3d, 0x16, 0xcb, 0xdf, 0x3e, 0x20, 0xd6, 0x61, 0x62, 0x96, 0x8b, 0xd0, 0x53, 0x4a,
-	0xa9, 0xb5, 0xcd, 0x19, 0x5d, 0x09, 0xb8, 0x6f, 0xeb, 0x3f, 0x84, 0x0b, 0x15, 0x84, 0xca, 0x3c,
-	0xaf, 0xc3, 0xdc, 0x53, 0x1c, 0xee, 0xe1, 0xa7, 0xc4, 0x0c, 0x31, 0x73, 0xa8, 0xa0, 0x6e, 0x19,
-	0x03, 0x05, 0x34, 0x38, 0x4c, 0x7f, 0x02, 0x5a, 0x8e, 0x03, 0xf5, 0x02, 0x6c, 0xb1, 0x26, 0xc2,
-	0xd1, 0x3a, 0xf4, 0x83, 0x90, 0x60, 0xd7, 0xa5, 0x16, 0x66, 0x44, 0xd8, 0xa7, 0x6d, 0x64, 0x41,
-	0xfa, 0x2a, 0x5c, 0xac, 0x64, 0x2e, 0x17, 0xa8, 0x7f, 0x50, 0x58, 0x3d, 0xf5, 0x3c, 0xa7, 0x91,
-	0x68, 0xfd, 0x52, 0x69, 0xd5, 0x82, 0x52, 0xf1, 0xfd, 0x6e, 0x61, 0xd6, 0x25, 0xd8, 0x8f, 0x83,
-	0x46, 0x8c, 0x8b, 0x2b, 0x4e, 0x48, 0x53, 0xce, 0x2b, 0xd2, 0x6d, 0xb6, 0xa9, 0xeb, 0x12, 0x8b,
-	0x39, 0xd4, 0x4f, 0xd8, 0xae, 0x01, 0x58, 0x29, 0x50, 0x39, 0x51, 0x06, 0xa2, 0x6b, 0x30, 0x2c,
-	0x93, 0x2a, 0xb6, 0xff, 0x68, 0xc1, 0xf9, 0x5b, 0xca, 0x68, 0x52, 0x70, 0xa3, 0x0d, 0xc8, 0x8b,
-	0x3c, 0x53, 0x14, 0x59, 0xdc, 0xa0, 0x76, 0x69, 0x83, 0x38, 0x46, 0x48, 0x02, 0xd7, 0xb1, 0xb0,
-	0x60, 0xd1, 0x11, 0x2c, 0xb2, 0x20, 0xb4, 0x00, 0x6d, 0xc6, 0x5c, 0xe1, 0xb9, 0x3d, 0x83, 0x0f,
-	0xd1, 0x16, 0x2c, 0x7b, 0xc4, 0xa3, 0xe1, 0xc8, 0xf4, 0x70, 0x60, 0x7a, 0xf8, 0xd8, 0xe4, 0x6e,
-	0x6e, 0x7a, 0x7b, 0xc3, 0x19, 0xb1, 0x3e, 0x24, 0x67, 0x1f, 0xe0, 0xe0, 0x01, 0x3e, 0xde, 0x75,
-	0x5e, 0x90, 0x07, 0x7b, 0xfa, 0x10, 0x96, 0x8b, 0xfa, 0x29, 0xd5, 0xbf, 0x03, 0x2b, 0x12, 0xb2,
-	0x3b, 0xf2, 0xad, 0x5d, 0x11, 0x5b, 0x8d, 0x36, 0xea, 0xbf, 0x2d, 0x18, 0x96, 0x09, 0x95, 0xe7,
-	0xbf, 0xac, 0xd5, 0x4e, 0x6d, 0x93, 0xcb, 0xd0, 0x67, 0xd8, 0x71, 0x4d, 0xba, 0xbf, 0x1f, 0x11,
-	0x26, 0x0c, 0xd1, 0x31, 0x80, 0x83, 0x1e, 0x0a, 0x08, 0xba, 0x0a, 0x0b, 0x96, 0xf4, 0x7e, 0x33,
-	0x24, 0x47, 0x8e, 0xc8, 0x06, 0xb3, 0x62, 0x61, 0xf3, 0x56, 0x12, 0x15, 0x12, 0x8c, 0x74, 0x98,
-	0x73, 0xec, 0x63, 0x53, 0xa4, 0x23, 0x91, 0x4c, 0xba, 0x82, 0x5b, 0xdf, 0xb1, 0x8f, 0xef, 0x39,
-	0x2e, 0xe1, 0x16, 0xd5, 0x1f, 0xc3, 0x25, 0xa9, 0xfc, 0x7d, 0xdf, 0x0a, 0x89, 0x47, 0x7c, 0x86,
-	0xdd, 0x6d, 0x1a, 0x8c, 0x1a, 0xb9, 0xcd, 0x05, 0xe8, 0x46, 0x8e, 0x6f, 0x11, 0xd3, 0x97, 0x49,
-	0xad, 0x63, 0xcc, 0x8a, 0xef, 0x9d, 0x48, 0xbf, 0x0d, 0xab, 0x35, 0x7c, 0x95, 0x65, 0x5f, 0x83,
-	0x81, 0x58, 0x98, 0x45, 0x7d, 0x46, 0x7c, 0x26, 0x78, 0x0f, 0x8c, 0x3e, 0x87, 0x6d, 0x4b, 0x90,
-	0xfe, 0x2e, 0x20, 0xc9, 0xe3, 0x01, 0x8d, 0xfd, 0x66, 0xe1, 0x7c, 0x1e, 0x16, 0x73, 0x24, 0xca,
-	0x37, 0xde, 0x83, 0x25, 0x09, 0xfe, 0xdc, 0xf7, 0x1a, 0xf3, 0x5a, 0x81, 0xf3, 0x05, 0x22, 0xc5,
-	0x6d, 0x2b, 0x11, 0x92, 0x3f, 0x76, 0x4e, 0x64, 0xb6, 0x9c, 0xac, 0x20, 0x7f, 0xf2, 0x88, 0xcc,
-	0x25, 0x17, 0x8c, 0xc3, 0x43, 0x83, 0x60, 0x9b, 0xfa, 0xee, 0xa8, 0x71, 0xe6, 0xaa, 0xa0, 0x54,
-	0x7c, 0xff, 0xd4, 0x82, 0x73, 0x49, 0x4a, 0x6b, 0xb8, 0x9b, 0xa7, 0x74, 0xe7, 0x76, 0xad, 0x3b,
-	0x77, 0xc6, 0xee, 0xbc, 0x01, 0x0b, 0x11, 0x8d, 0x43, 0x8b, 0x98, 0x36, 0x66, 0xd8, 0xf4, 0xa9,
-	0x4d, 0x94, 0xb7, 0x9f, 0x95, 0xf0, 0x3b, 0x98, 0xe1, 0x1d, 0x6a, 0x13, 0xfd, 0x07, 0xc9, 0x66,
-	0xe7, 0xbc, 0xe4, 0x2a, 0x9c, 0x73, 0x71, 0xc4, 0x4c, 0x1c, 0x04, 0xc4, 0xb7, 0x4d, 0xcc, 0xb8,
-	0xab, 0xb5, 0x84, 0xab, 0x9d, 0xe5, 0x13, 0xb7, 0x04, 0xfc, 0x16, 0xdb, 0x89, 0xf4, 0xbf, 0xb5,
-	0x60, 0x9e, 0xd3, 0x72, 0xd7, 0x6e, 0xa4, 0xef, 0x02, 0xb4, 0xc9, 0x31, 0x53, 0x8a, 0xf2, 0x21,
-	0xba, 0x01, 0x8b, 0x2a, 0x86, 0x1c, 0xea, 0x8f, 0xc3, 0xab, 0x2d, 0xb3, 0xd1, 0x78, 0x2a, 0x8d,
-	0xb0, 0xcb, 0xd0, 0x8f, 0x18, 0x0d, 0x92, 0x68, 0xed, 0xc8, 0x68, 0xe5, 0x20, 0x15, 0xad, 0x79,
-	0x9b, 0x4e, 0x57, 0xd8, 0x74, 0xe0, 0x44, 0x26, 0xb1, 0x4c, 0xb9, 0x2a, 0x11, 0xef, 0x5d, 0x03,
-	0x9c, 0xe8, 0xae, 0x25, 0xad, 0xa1, 0x7f, 0x1b, 0x16, 0xc6, 0x5a, 0x35, 0x8f, 0x9d, 0xaf, 0x5a,
-	0x49, 0x3a, 0x7c, 0x84, 0x1d, 0x77, 0x97, 0xf8, 0x36, 0x09, 0x5f, 0x32, 0xa6, 0xd1, 0x4d, 0x58,
-	0x72, 0x6c, 0x97, 0x98, 0xcc, 0xf1, 0x08, 0x8d, 0x99, 0x19, 0x11, 0x8b, 0xfa, 0x76, 0x94, 0xd8,
-	0x87, 0xcf, 0x3d, 0x92, 0x53, 0xbb, 0x72, 0x46, 0xff, 0x6d, 0x9a, 0x5b, 0xb3, 0xab, 0x18, 0x57,
-	0x15, 0x3e, 0x21, 0x9c, 0xe1, 0x01, 0xc1, 0x36, 0x09, 0x95, 0x1a, 0x03, 0x09, 0xfc, 0xb1, 0x80,
-	0x71, 0x0b, 0x2b, 0xa4, 0x3d, 0x6a, 0x8f, 0xc4, 0x8a, 0x06, 0x06, 0x48, 0xd0, 0x6d, 0x6a, 0x8f,
-	0x44, 0x92, 0x8b, 0x4c, 0xe1, 0x24, 0xd6, 0x41, 0xec, 0x1f, 0x8a, 0xd5, 0x74, 0x8d, 0xbe, 0x13,
-	0x7d, 0x8a, 0x23, 0xb6, 0xcd, 0x41, 0xfa, 0x9f, 0x5b, 0x49, 0x94, 0xf1, 0x65, 0x18, 0xc4, 0x22,
-	0xce, 0xd1, 0xff, 0xc1, 0x1c, 0x9c, 0x42, 0x45, 0x43, 0xae, 0xba, 0x54, 0x01, 0x83, 0xe4, 0x9c,
-	0x3a, 0x8b, 0xc4, 0xcc, 0x38, 0xc8, 0xf3, 0x0b, 0x57, 0x41, 0xfe, 0x65, 0x92, 0x64, 0xef, 0x5a,
-	0xbb, 0x07, 0x38, 0xb4, 0xa3, 0x1f, 0x11, 0x9f, 0x84, 0x98, 0xbd, 0x92, 0x43, 0x5f, 0x5f, 0x87,
-	0xb5, 0x3a, 0xee, 0x4a, 0xfe, 0x93, 0xe4, 0xf0, 0x48, 0x30, 0x0c, 0xb2, 0x17, 0x3b, 0xae, 0xfd,
-	0x4a, 0xc4, 0x7f, 0x52, 0x54, 0x2e, 0x65, 0xae, 0xfc, 0xe7, 0x1a, 0x9c, 0x0b, 0x05, 0x88, 0x99,
-	0x11, 0x47, 0x48, 0xeb, 0xfd, 0x39, 0x63, 0x5e, 0x4d, 0x08, 0x42, 0x5e, 0xf7, 0xff, 0x25, 0xf5,
-	0x80, 0x84, 0xdb, 0x2b, 0x4b, 0x8b, 0x17, 0xa1, 0x37, 0x16, 0xdf, 0x16, 0xe2, 0xbb, 0x91, 0x92,
-	0xcb, 0xbd, 0xd3, 0xa2, 0xc1, 0xc8, 0x24, 0x96, 0x3c, 0x87, 0xc5, 0x56, 0x77, 0x8d, 0x3e, 0x07,
-	0xde, 0xb5, 0xc4, 0x31, 0x7c, 0x8a, 0x1c, 0x99, 0x7a, 0x43, 0x5e, 0x09, 0xb5, 0x1b, 0xcf, 0xe1,
-	0x62, 0x7e, 0xb6, 0xf9, 0xf1, 0xf4, 0x52, 0x4a, 0xea, 0x6b, 0x45, 0x37, 0x28, 0x9c, 0x71, 0x47,
-	0xc5, 0x65, 0x37, 0x3e, 0xcf, 0x5f, 0x6e, 0x5d, 0xab, 0x45, 0x83, 0xe4, 0x8b, 0x82, 0x2f, 0x8a,
-	0xcb, 0x3e, 0x45, 0x71, 0x70, 0xb2, 0xe0, 0xcb, 0x45, 0xd7, 0x2d, 0x56, 0x10, 0xbf, 0x4f, 0xf3,
-	0xa2, 0xc2, 0xe0, 0xe7, 0x77, 0xe3, 0x7c, 0xa4, 0xe4, 0x0a, 0x73, 0xcc, 0x19, 0xb3, 0x4a, 0x2c,
-	0xbf, 0x60, 0xaa, 0x73, 0x48, 0xd6, 0xe7, 0xea, 0x2b, 0x77, 0x95, 0x6c, 0xab, 0xab, 0x64, 0x72,
-	0x45, 0x3e, 0x24, 0x23, 0xe1, 0x6b, 0x1d, 0x79, 0x45, 0xfe, 0x84, 0x8c, 0xf4, 0x9d, 0x42, 0xa4,
-	0xc8, 0xa5, 0xa9, 0x98, 0x43, 0xd0, 0xe1, 0x4e, 0xaa, 0x52, 0xb5, 0x18, 0xa3, 0x55, 0x00, 0x27,
-	0x32, 0x6d, 0xb1, 0xe7, 0x72, 0x51, 0x5d, 0xa3, 0xe7, 0x28, 0x27, 0xb0, 0xf5, 0xdf, 0x65, 0x42,
-	0xef, 0xb6, 0x4b, 0xf7, 0x5e, 0xa1, 0x57, 0x66, 0xb5, 0x68, 0xe7, 0xb4, 0xc8, 0xde, 0x95, 0x3b,
-	0xf9, 0xbb, 0x72, 0x26, 0x88, 0xb2, 0xcb, 0x51, 0x3b, 0xf3, 0x21, 0x5c, 0xe4, 0x0a, 0x4b, 0x0c,
-	0x51, 0x25, 0x37, 0xbf, 0x49, 0xfc, 0xeb, 0x0c, 0x5c, 0xaa, 0x26, 0x6e, 0x72, 0x9b, 0xf8, 0x08,
-	0xb4, 0xb4, 0x5a, 0xe7, 0x47, 0x4a, 0xc4, 0xb0, 0x17, 0xa4, 0x87, 0x8a, 0x3c, 0x7b, 0x56, 0x54,
-	0xe9, 0xfe, 0x28, 0x99, 0x4f, 0x4e, 0x96, 0x52, 0xa9, 0xdf, 0x2e, 0x95, 0xfa, 0x5c, 0x80, 0x8d,
-	0x59, 0x9d, 0x00, 0x59, 0xbb, 0xac, 0xd8, 0x98, 0xd5, 0x09, 0x48, 0x89, 0x85, 0x00, 0xe9, 0x35,
-	0x7d, 0x85, 0x2f, 0x04, 0xac, 0x02, 0xa8, 0xb2, 0x24, 0xf6, 0x93, 0xab, 0x4b, 0x4f, 0x16, 0x25,
-	0xb1, 0x5f, 0x5b, 0x5d, 0xcd, 0xd6, 0x56, 0x57, 0xf9, 0xed, 0xef, 0x96, 0x4e, 0x88, 0x2f, 0x00,
-	0xee, 0x38, 0xd1, 0xa1, 0x34, 0x32, 0x2f, 0xe7, 0x6c, 0x27, 0x54, 0xf7, 0x65, 0x3e, 0xe4, 0x10,
-	0xec, 0xba, 0xca, 0x74, 0x7c, 0xc8, 0xdd, 0x37, 0x8e, 0x88, 0xad, 0xac, 0x23, 0xc6, 0x1c, 0xb6,
-	0x1f, 0x12, 0xa2, 0x0c, 0x20, 0xc6, 0xfa, 0x1f, 0x5a, 0xd0, 0x7b, 0x40, 0x3c, 0xc5, 0x79, 0x0d,
-	0xe0, 0x29, 0x0d, 0x69, 0xcc, 0x1c, 0x9f, 0xc8, 0xea, 0x73, 0xda, 0xc8, 0x40, 0xbe, 0xbe, 0x1c,
-	0x11, 0x9a, 0xc4, 0xdd, 0x57, 0xc6, 0x14, 0x63, 0x0e, 0x3b, 0x20, 0x38, 0x50, 0xf6, 0x13, 0x63,
-	0xb4, 0x04, 0xd3, 0x11, 0xc3, 0xd6, 0xa1, 0x30, 0x56, 0xc7, 0x90, 0x1f, 0xfa, 0x7f, 0x06, 0x30,
-	0xf8, 0x2c, 0x26, 0xe1, 0x28, 0xd3, 0x39, 0x88, 0x88, 0xb2, 0x4e, 0xd2, 0xfa, 0xca, 0x40, 0xf8,
-	0x26, 0xee, 0x87, 0xd4, 0x33, 0xd3, 0xee, 0xd8, 0x19, 0x81, 0xd2, 0xe7, 0xc0, 0x7b, 0xb2, 0x43,
-	0x86, 0x3e, 0x86, 0x99, 0x7d, 0xc7, 0x65, 0x44, 0xf6, 0xa3, 0xfa, 0x5b, 0x6f, 0x96, 0x3b, 0x61,
-	0x59, 0x99, 0x9b, 0xf7, 0x04, 0xb2, 0xa1, 0x88, 0xd0, 0x1e, 0x2c, 0x3a, 0x7e, 0x20, 0xaa, 0xa1,
-	0xd0, 0xc1, 0xae, 0xf3, 0x62, 0x7c, 0xf7, 0xed, 0x6f, 0xbd, 0x3b, 0x81, 0xd7, 0x7d, 0x4e, 0xb9,
-	0x9b, 0x25, 0x34, 0x90, 0x53, 0x82, 0x21, 0x02, 0x4b, 0x34, 0x66, 0x65, 0x21, 0xd3, 0x42, 0xc8,
-	0xd6, 0x04, 0x21, 0x0f, 0x05, 0x69, 0x5e, 0xca, 0x22, 0x2d, 0x03, 0xb5, 0x1d, 0x98, 0x91, 0xca,
-	0x71, 0xf3, 0xef, 0x3b, 0xc4, 0x4d, 0x3a, 0x7a, 0xf2, 0x83, 0xa7, 0x18, 0x1a, 0x90, 0x10, 0xfb,
-	0xb6, 0x4a, 0x4d, 0xc9, 0x27, 0xc7, 0x3f, 0xc2, 0x6e, 0x4c, 0x92, 0x96, 0x9e, 0xf8, 0xd0, 0xfe,
-	0x3e, 0x0d, 0xa8, 0xac, 0x61, 0x72, 0xa1, 0x0f, 0x49, 0xc4, 0x9d, 0xde, 0x64, 0xa3, 0x80, 0x28,
-	0x39, 0xf3, 0x19, 0xf8, 0xa3, 0x51, 0x40, 0xd0, 0xcf, 0xa0, 0x67, 0x45, 0x47, 0xa6, 0x30, 0x89,
-	0x90, 0xd9, 0xdf, 0xfa, 0xf0, 0xd4, 0x26, 0xdd, 0xdc, 0xde, 0x7d, 0x2c, 0xa0, 0x46, 0xd7, 0x8a,
-	0x8e, 0xc4, 0x08, 0xfd, 0x02, 0xe0, 0x57, 0x11, 0xf5, 0x15, 0x67, 0xb9, 0xf1, 0x1f, 0x9d, 0x9e,
-	0xf3, 0x4f, 0x76, 0x1f, 0xee, 0x48, 0xd6, 0x3d, 0xce, 0x4e, 0xf2, 0xb6, 0x60, 0x2e, 0xc0, 0xe1,
-	0xb3, 0x98, 0x30, 0xc5, 0x5e, 0xfa, 0xc2, 0xf7, 0x4f, 0xcf, 0xfe, 0xa7, 0x92, 0x8d, 0x94, 0x30,
-	0x08, 0x32, 0x5f, 0xda, 0x5f, 0xcf, 0x40, 0x37, 0xd1, 0x8b, 0x17, 0x54, 0xc2, 0xc3, 0xe5, 0xb5,
-	0xc2, 0x74, 0xfc, 0x7d, 0xaa, 0x2c, 0x7a, 0x96, 0xc3, 0xe5, 0xcd, 0xe2, 0xbe, 0xbf, 0x4f, 0xb9,
-	0xed, 0x43, 0x62, 0xd1, 0xd0, 0xe6, 0xc7, 0x97, 0xe3, 0x39, 0xdc, 0xed, 0xe5, 0x5e, 0xce, 0x4b,
-	0xf8, 0x9d, 0x04, 0x8c, 0xae, 0xc0, 0xbc, 0xd8, 0xf6, 0x0c, 0x66, 0x3b, 0xe1, 0x49, 0xdc, 0x0c,
-	0xe2, 0x55, 0x58, 0x78, 0x16, 0x53, 0x46, 0x4c, 0xeb, 0x00, 0x87, 0xd8, 0x62, 0x34, 0x2d, 0xf0,
-	0xe7, 0x05, 0x7c, 0x3b, 0x05, 0xa3, 0x6f, 0xc1, 0xb2, 0x44, 0x25, 0x91, 0x85, 0x83, 0x94, 0x82,
-	0x84, 0xaa, 0xfe, 0x5b, 0x12, 0xb3, 0x77, 0xc5, 0xe4, 0x76, 0x32, 0x87, 0x34, 0xe8, 0x5a, 0xd4,
-	0xf3, 0x88, 0xcf, 0x22, 0x91, 0x24, 0x7a, 0x46, 0xfa, 0x8d, 0x6e, 0xc1, 0x2a, 0x76, 0x5d, 0xfa,
-	0xdc, 0x14, 0x94, 0xb6, 0x59, 0xd2, 0x6e, 0x56, 0x1c, 0xcf, 0x9a, 0x40, 0xfa, 0x4c, 0xe0, 0x18,
-	0x79, 0x45, 0xb5, 0xcb, 0xd0, 0x4b, 0xf7, 0x91, 0x27, 0xa3, 0x8c, 0x43, 0x8a, 0xb1, 0x76, 0x16,
-	0x06, 0xd9, 0x9d, 0xd0, 0xfe, 0xdd, 0x86, 0xc5, 0x8a, 0xa0, 0x42, 0x4f, 0x00, 0xb8, 0xb7, 0xca,
-	0xd0, 0x52, 0xee, 0xfa, 0xbd, 0xd3, 0x07, 0x27, 0xf7, 0x57, 0x09, 0x36, 0xb8, 0xf7, 0xcb, 0x21,
-	0xfa, 0x25, 0xf4, 0x85, 0xc7, 0x2a, 0xee, 0xd2, 0x65, 0x3f, 0xfe, 0x1a, 0xdc, 0xb9, 0xae, 0x8a,
-	0xbd, 0x88, 0x01, 0x39, 0xd6, 0xfe, 0xd9, 0x82, 0x5e, 0x2a, 0x98, 0x5f, 0xb8, 0xe5, 0x46, 0x89,
-	0xbd, 0x8e, 0x94, 0x39, 0xfa, 0x02, 0x76, 0x4f, 0x80, 0xbe, 0x91, 0xae, 0xa4, 0xbd, 0x0f, 0x30,
-	0xd6, 0xbf, 0x52, 0x85, 0x56, 0xa5, 0x0a, 0xfa, 0x55, 0x98, 0xe3, 0x96, 0x75, 0x88, 0xbd, 0xcb,
-	0x42, 0x27, 0x10, 0x6f, 0x13, 0x12, 0x27, 0x52, 0xb5, 0x61, 0xf2, 0xb9, 0xf5, 0xc7, 0x15, 0x18,
-	0x64, 0xef, 0xb4, 0xe8, 0x4b, 0xe8, 0x67, 0xde, 0x60, 0xd0, 0x1b, 0xe5, 0x4d, 0x2b, 0xbf, 0xe9,
-	0x68, 0x6f, 0x4e, 0xc0, 0x52, 0xe5, 0xdb, 0x14, 0xf2, 0xe1, 0x5c, 0xe9, 0x21, 0x03, 0x5d, 0x2b,
-	0x53, 0xd7, 0x3d, 0x93, 0x68, 0xd7, 0x1b, 0xe1, 0xa6, 0xf2, 0x18, 0x2c, 0x56, 0xbc, 0x4c, 0xa0,
-	0xb7, 0x27, 0x70, 0xc9, 0xbd, 0x8e, 0x68, 0xef, 0x34, 0xc4, 0x4e, 0xa5, 0x3e, 0x03, 0x54, 0x7e,
-	0xb6, 0x40, 0xd7, 0x27, 0xb2, 0x19, 0x3f, 0x8b, 0x68, 0x6f, 0x37, 0x43, 0xae, 0x55, 0x54, 0x3e,
-	0x68, 0x4c, 0x54, 0x34, 0xf7, 0x64, 0x32, 0x51, 0xd1, 0xc2, 0x2b, 0xc9, 0x14, 0x3a, 0x84, 0x85,
-	0xe2, 0x63, 0x07, 0xba, 0x5a, 0xf7, 0x38, 0x57, 0x7a, 0x4b, 0xd1, 0xae, 0x35, 0x41, 0x4d, 0x85,
-	0x11, 0x38, 0x9b, 0x7f, 0x5c, 0x40, 0x57, 0xca, 0xf4, 0x95, 0xcf, 0x2b, 0xda, 0xc6, 0x64, 0xc4,
-	0xac, 0x4e, 0xc5, 0x07, 0x87, 0x2a, 0x9d, 0x6a, 0x5e, 0x33, 0xaa, 0x74, 0xaa, 0x7b, 0xbf, 0xd0,
-	0xa7, 0xd0, 0xaf, 0x93, 0x2e, 0x76, 0xa1, 0x11, 0x8f, 0x36, 0xeb, 0xd8, 0x54, 0xbf, 0x04, 0x68,
-	0x37, 0x1a, 0xe3, 0x27, 0xb2, 0x6f, 0xb6, 0x78, 0xac, 0x67, 0xfa, 0xf1, 0x55, 0xb1, 0x5e, 0xee,
-	0xf0, 0x57, 0xc5, 0x7a, 0x55, 0x53, 0x7f, 0x0a, 0xed, 0xc1, 0x5c, 0xae, 0x43, 0x8f, 0xde, 0xaa,
-	0xa3, 0xcc, 0x5f, 0xed, 0xb5, 0x2b, 0x13, 0xf1, 0x52, 0x19, 0x66, 0x92, 0xbd, 0x54, 0xba, 0xaa,
-	0x5d, 0x5c, 0x3e, 0x5f, 0xbd, 0x35, 0x09, 0x2d, 0x17, 0xca, 0xa5, 0x3e, 0x7e, 0x65, 0x28, 0xd7,
-	0xbd, 0x13, 0x54, 0x86, 0x72, 0xfd, 0xd3, 0xc0, 0x14, 0xfa, 0x39, 0xc0, 0xb8, 0xd7, 0x8e, 0x5e,
-	0xaf, 0xa3, 0xce, 0xee, 0xfe, 0x1b, 0x27, 0x23, 0xa5, 0xac, 0x9f, 0xc3, 0x52, 0xd5, 0x15, 0x18,
-	0x55, 0x04, 0xfe, 0x09, 0xf7, 0x6c, 0x6d, 0xb3, 0x29, 0x7a, 0x2a, 0xf8, 0x73, 0xe8, 0x26, 0x7d,
-	0x72, 0xf4, 0x5a, 0x99, 0xba, 0xf0, 0x32, 0xa0, 0xe9, 0x27, 0xa1, 0x64, 0x1c, 0xd8, 0x4b, 0x62,
-	0x75, 0xdc, 0xc0, 0xae, 0x8f, 0xd5, 0x52, 0xab, 0xbd, 0x3e, 0x56, 0xcb, 0xfd, 0x70, 0x21, 0x2e,
-	0x75, 0x86, 0x6c, 0xbf, 0xb7, 0xde, 0x19, 0x2a, 0xda, 0xd9, 0xf5, 0xce, 0x50, 0xd9, 0x42, 0x9e,
-	0x42, 0xbf, 0x81, 0xe5, 0xea, 0x36, 0x2f, 0xaa, 0x8d, 0xf8, 0x9a, 0x76, 0xb3, 0x76, 0xb3, 0x39,
-	0x41, 0x2a, 0xfe, 0x45, 0x92, 0x9f, 0x0a, 0x6d, 0xde, 0xfa, 0xfc, 0x54, 0xdd, 0x6c, 0xd6, 0x6e,
-	0x34, 0xc6, 0x2f, 0x87, 0x5e, 0xb6, 0x9f, 0x5a, 0x6f, 0xed, 0x8a, 0xd6, 0x71, 0xbd, 0xb5, 0x2b,
-	0x5b, 0xb4, 0x22, 0x3e, 0xaa, 0x7a, 0xa5, 0x55, 0xf1, 0x71, 0x42, 0x33, 0x57, 0xdb, 0x6c, 0x8a,
-	0x9e, 0x3b, 0xbe, 0xcb, 0xcd, 0x50, 0x34, 0x71, 0xfd, 0xb9, 0xcc, 0xfc, 0x4e, 0x43, 0xec, 0xfa,
-	0xdd, 0x4d, 0x32, 0xf5, 0x44, 0x05, 0x0a, 0x19, 0xfb, 0x46, 0x63, 0xfc, 0x54, 0x76, 0x90, 0xbc,
-	0x80, 0x66, 0x1a, 0x99, 0xe8, 0xda, 0x04, 0x3e, 0x99, 0x46, 0xac, 0x76, 0xbd, 0x11, 0x6e, 0x55,
-	0xf4, 0x66, 0x5b, 0x8b, 0x27, 0xf9, 0x53, 0xa9, 0x1f, 0x7a, 0x92, 0x3f, 0x55, 0x74, 0x2b, 0xa7,
-	0xd0, 0xa7, 0x30, 0x2d, 0xae, 0x38, 0x68, 0xed, 0xe4, 0xbb, 0x8f, 0x76, 0xb9, 0x7a, 0x3e, 0xad,
-	0xe0, 0xb9, 0x02, 0x7b, 0x33, 0xe2, 0x47, 0xab, 0xf7, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0x02,
-	0xd4, 0xce, 0xae, 0x7f, 0x25, 0x00, 0x00,
+	// 3280 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x3b, 0x4d, 0x6f, 0x1c, 0xc7,
+	0xb1, 0x1c, 0x2e, 0x3f, 0x76, 0x6b, 0x77, 0x45, 0xaa, 0x49, 0x53, 0xeb, 0x21, 0x29, 0x51, 0x23,
+	0x7f, 0x90, 0xb2, 0x45, 0xca, 0xb4, 0xfd, 0xac, 0x27, 0x3f, 0xfb, 0x59, 0xa2, 0x44, 0x59, 0xb6,
+	0x48, 0xd9, 0x43, 0x59, 0x7e, 0x2f, 0x36, 0x32, 0x18, 0xce, 0xf4, 0x92, 0x63, 0xce, 0xce, 0x8c,
+	0x66, 0x7a, 0x69, 0xad, 0xe0, 0x9c, 0x1c, 0x20, 0x01, 0x82, 0xe4, 0x10, 0xe4, 0x92, 0x4b, 0x80,
+	0x20, 0xf7, 0x5c, 0xf3, 0x17, 0xfc, 0x07, 0x02, 0xe4, 0x94, 0x4b, 0xce, 0x39, 0xe4, 0x10, 0x20,
+	0x40, 0x2e, 0x41, 0x7f, 0xcd, 0xce, 0x27, 0x77, 0x18, 0x31, 0x08, 0x72, 0x9b, 0xae, 0xae, 0xae,
+	0xea, 0xaa, 0xae, 0xaa, 0xae, 0xae, 0xda, 0x85, 0xb9, 0x63, 0xdf, 0xed, 0xf7, 0xb0, 0x11, 0xe1,
+	0xf0, 0x18, 0x87, 0xeb, 0x41, 0xe8, 0x13, 0x1f, 0xcd, 0xa6, 0x80, 0x46, 0xb0, 0xaf, 0x6d, 0x00,
+	0xba, 0x6d, 0x12, 0xeb, 0xf0, 0x0e, 0x76, 0x31, 0xc1, 0x3a, 0x7e, 0xd2, 0xc7, 0x11, 0x41, 0x2f,
+	0x42, 0xbd, 0xeb, 0xb8, 0xd8, 0x70, 0xec, 0xa8, 0xa3, 0xac, 0xd4, 0x56, 0x1b, 0xfa, 0x34, 0x1d,
+	0xdf, 0xb7, 0x23, 0xed, 0x21, 0xcc, 0xa5, 0x16, 0x44, 0x81, 0xef, 0x45, 0x18, 0xdd, 0x80, 0xe9,
+	0x10, 0x47, 0x7d, 0x97, 0xf0, 0x05, 0xcd, 0xcd, 0x8b, 0xeb, 0x59, 0x5e, 0xeb, 0xf1, 0x92, 0xbe,
+	0x4b, 0x74, 0x89, 0xae, 0x7d, 0xab, 0x40, 0x2b, 0x39, 0x83, 0x2e, 0xc0, 0xb4, 0x60, 0xde, 0x51,
+	0x56, 0x94, 0xd5, 0x86, 0x3e, 0xc5, 0x79, 0xa3, 0x05, 0x98, 0x8a, 0x88, 0x49, 0xfa, 0x51, 0x67,
+	0x7c, 0x45, 0x59, 0x9d, 0xd4, 0xc5, 0x08, 0xcd, 0xc3, 0x24, 0x0e, 0x43, 0x3f, 0xec, 0xd4, 0x18,
+	0x3a, 0x1f, 0x20, 0x04, 0x13, 0x91, 0xf3, 0x0c, 0x77, 0x26, 0x56, 0x94, 0xd5, 0xb6, 0xce, 0xbe,
+	0x51, 0x07, 0xa6, 0x8f, 0x71, 0x18, 0x39, 0xbe, 0xd7, 0x99, 0x64, 0x60, 0x39, 0xd4, 0x3e, 0x82,
+	0x73, 0xdb, 0x8e, 0x8b, 0xef, 0x61, 0x22, 0x75, 0x50, 0xba, 0x8d, 0x4b, 0xd0, 0x34, 0x2d, 0x0b,
+	0x07, 0xc4, 0x38, 0x78, 0xe6, 0x04, 0x6c, 0x2f, 0x75, 0x1d, 0x38, 0xe8, 0xde, 0x33, 0x27, 0xd0,
+	0x7e, 0x54, 0x83, 0x99, 0x98, 0x98, 0xd0, 0x0f, 0x82, 0x09, 0xdb, 0x24, 0x26, 0x23, 0xd5, 0xd2,
+	0xd9, 0x37, 0x7a, 0x19, 0xce, 0x59, 0xbe, 0x47, 0xb0, 0x47, 0x0c, 0x17, 0x7b, 0x07, 0xe4, 0x90,
+	0xd1, 0x6a, 0xeb, 0x6d, 0x01, 0x7d, 0xc0, 0x80, 0xe8, 0x32, 0xb4, 0x24, 0x1a, 0x19, 0x04, 0x58,
+	0x48, 0xd9, 0x14, 0xb0, 0x47, 0x83, 0x00, 0xa3, 0x2b, 0xd0, 0x76, 0xcd, 0x88, 0x18, 0x3d, 0xdf,
+	0x76, 0xba, 0x0e, 0xb6, 0x99, 0xd0, 0x13, 0x7a, 0x8b, 0x02, 0x77, 0x04, 0x0c, 0xa9, 0xfc, 0x50,
+	0x3d, 0xb3, 0x87, 0x99, 0xf4, 0x0d, 0x3d, 0x1e, 0xd3, 0xed, 0x61, 0x62, 0x1e, 0x74, 0xa6, 0x18,
+	0x9c, 0x7d, 0xa3, 0x65, 0x00, 0x27, 0x62, 0x32, 0x06, 0xd8, 0xee, 0x4c, 0x33, 0x31, 0x1b, 0x4e,
+	0x74, 0x8f, 0x03, 0xd0, 0x87, 0x30, 0x7d, 0x88, 0x4d, 0x1b, 0x87, 0x51, 0xa7, 0xce, 0x4e, 0x7c,
+	0x3d, 0x7f, 0xe2, 0x19, 0x2d, 0xac, 0x7f, 0xc8, 0x17, 0xdc, 0xf5, 0x48, 0x38, 0xd0, 0xe5, 0x72,
+	0xb4, 0x04, 0x0d, 0x76, 0x64, 0x5b, 0xbe, 0x8d, 0x3b, 0x0d, 0x76, 0xb4, 0x43, 0x80, 0x7a, 0x13,
+	0x5a, 0xc9, 0x65, 0x68, 0x16, 0x6a, 0x47, 0x78, 0x20, 0xce, 0x84, 0x7e, 0xd2, 0xf3, 0x3f, 0x36,
+	0xdd, 0x3e, 0x66, 0xea, 0x6b, 0xe8, 0x7c, 0x70, 0x73, 0xfc, 0x86, 0xa2, 0x4d, 0xc3, 0xe4, 0xdd,
+	0x5e, 0x40, 0x06, 0xda, 0x3b, 0xd0, 0x79, 0x6c, 0x5a, 0xfd, 0x7e, 0xef, 0x31, 0xdb, 0xe2, 0xd6,
+	0x21, 0xb6, 0x8e, 0xe4, 0x41, 0x2f, 0x42, 0x43, 0x6c, 0x5c, 0x1c, 0x75, 0x5b, 0xaf, 0x73, 0xc0,
+	0x7d, 0x5b, 0xfb, 0x00, 0x5e, 0x2c, 0x58, 0x28, 0x0e, 0xf5, 0x0a, 0xb4, 0x0f, 0xcc, 0x70, 0xdf,
+	0x3c, 0xc0, 0x46, 0x68, 0x12, 0xc7, 0x67, 0xab, 0x15, 0xbd, 0x25, 0x80, 0x3a, 0x85, 0x69, 0x5f,
+	0x80, 0x9a, 0xa2, 0xe0, 0xf7, 0x02, 0xd3, 0x22, 0x55, 0x98, 0xa3, 0x15, 0x68, 0x06, 0x21, 0x36,
+	0x5d, 0xd7, 0xb7, 0x4c, 0xc2, 0xc5, 0xab, 0xe9, 0x49, 0x90, 0xb6, 0x0c, 0x8b, 0x85, 0xc4, 0xf9,
+	0x06, 0xb5, 0x1b, 0x99, 0xdd, 0xfb, 0xbd, 0x9e, 0x53, 0x89, 0xb5, 0xb6, 0x94, 0xdb, 0x35, 0x5b,
+	0x29, 0xe8, 0xfe, 0x77, 0x66, 0xd6, 0xc5, 0xa6, 0xd7, 0x0f, 0x2a, 0x11, 0xce, 0xee, 0x58, 0x2e,
+	0x8d, 0x29, 0x5f, 0xe0, 0xc1, 0x60, 0xcb, 0x77, 0x5d, 0x6c, 0x11, 0xc7, 0xf7, 0x24, 0xd9, 0x8b,
+	0x00, 0x56, 0x0c, 0x14, 0xe7, 0x9f, 0x80, 0x68, 0x2a, 0x74, 0xf2, 0x4b, 0x05, 0xd9, 0x3f, 0x2a,
+	0xf0, 0xc2, 0x2d, 0xa1, 0x34, 0xce, 0xb8, 0xd2, 0x01, 0xa4, 0x59, 0x8e, 0x67, 0x59, 0x66, 0x0f,
+	0xa8, 0x96, 0x3b, 0x20, 0x8a, 0x11, 0xe2, 0xc0, 0x75, 0x2c, 0x93, 0x91, 0x98, 0xe0, 0xbe, 0x9b,
+	0x00, 0x51, 0x7b, 0x26, 0xc4, 0x15, 0x1e, 0x49, 0x3f, 0xd1, 0x26, 0x2c, 0xf4, 0x70, 0xcf, 0x0f,
+	0x07, 0x46, 0xcf, 0x0c, 0x8c, 0x9e, 0xf9, 0xd4, 0xa0, 0xc1, 0xcb, 0xe8, 0xed, 0x33, 0xf7, 0x6c,
+	0xeb, 0x88, 0xcf, 0xee, 0x98, 0xc1, 0x8e, 0xf9, 0x74, 0xcf, 0x79, 0x86, 0x77, 0xf6, 0xb5, 0x0e,
+	0x2c, 0x64, 0xe5, 0x13, 0xa2, 0xff, 0x17, 0x5c, 0xe0, 0x90, 0xbd, 0x81, 0x67, 0xed, 0xb1, 0x88,
+	0x59, 0xe9, 0xa0, 0xfe, 0xae, 0x40, 0x27, 0xbf, 0x50, 0x58, 0xfe, 0xf3, 0x6a, 0xed, 0xd4, 0x3a,
+	0xb9, 0x04, 0x4d, 0x62, 0x3a, 0xae, 0xe1, 0x77, 0xbb, 0x11, 0x26, 0x4c, 0x11, 0x13, 0x3a, 0x50,
+	0xd0, 0x43, 0x06, 0x41, 0x6b, 0x30, 0x6b, 0x71, 0xeb, 0x37, 0x42, 0x7c, 0xec, 0xb0, 0x18, 0x3f,
+	0xcd, 0x36, 0x36, 0x63, 0x49, 0xaf, 0xe0, 0x60, 0xa4, 0x41, 0xdb, 0xb1, 0x9f, 0x1a, 0x2c, 0xba,
+	0xb3, 0x2b, 0xa2, 0xce, 0xa8, 0x35, 0x1d, 0xfb, 0x29, 0x0d, 0x58, 0x54, 0xa3, 0xda, 0x63, 0x58,
+	0xe2, 0xc2, 0xdf, 0xf7, 0xac, 0x10, 0xf7, 0xb0, 0x47, 0x4c, 0x77, 0xcb, 0x0f, 0x06, 0x95, 0xcc,
+	0xe6, 0x45, 0xa8, 0x47, 0x8e, 0x67, 0x61, 0xc3, 0xe3, 0x57, 0xd5, 0x84, 0x3e, 0xcd, 0xc6, 0xbb,
+	0x91, 0x76, 0x1b, 0x96, 0x4b, 0xe8, 0x0a, 0xcd, 0x5e, 0x86, 0x16, 0xdb, 0x98, 0x08, 0xef, 0xe2,
+	0xc2, 0x68, 0x52, 0xd8, 0x16, 0x07, 0x69, 0x6f, 0x00, 0xe2, 0x34, 0x76, 0xfc, 0xbe, 0x57, 0xcd,
+	0x9d, 0x5f, 0x80, 0xb9, 0xd4, 0x12, 0x61, 0x1b, 0x6f, 0xc2, 0x3c, 0x07, 0x7f, 0xe6, 0xf5, 0x2a,
+	0xd3, 0xba, 0x00, 0x2f, 0x64, 0x16, 0x09, 0x6a, 0x9b, 0x92, 0x49, 0x3a, 0x99, 0x38, 0x91, 0xd8,
+	0x82, 0xdc, 0x41, 0x3a, 0x9f, 0x60, 0x91, 0x8b, 0x6f, 0xd8, 0x0c, 0x8f, 0x74, 0x6c, 0xda, 0xbe,
+	0xe7, 0x0e, 0x2a, 0x47, 0xae, 0x82, 0x95, 0x82, 0xee, 0xe7, 0xb0, 0x20, 0x23, 0x9a, 0xd7, 0x75,
+	0x0e, 0xfa, 0x21, 0xae, 0x1a, 0x89, 0x93, 0x26, 0x3b, 0x9e, 0x33, 0x59, 0x6d, 0x43, 0xba, 0x59,
+	0x82, 0xb0, 0x38, 0xd2, 0x38, 0x3f, 0x51, 0x12, 0xf9, 0x89, 0xf6, 0x5b, 0x05, 0xce, 0xcb, 0x15,
+	0x15, 0xed, 0xea, 0x94, 0x8e, 0x55, 0x2b, 0x75, 0xac, 0x89, 0xa1, 0x63, 0xad, 0xc2, 0x6c, 0xe4,
+	0xf7, 0x43, 0x0b, 0x1b, 0x34, 0x27, 0x31, 0x3c, 0x7a, 0x07, 0x73, 0xbf, 0x3b, 0xc7, 0xe1, 0x77,
+	0x4c, 0x62, 0xee, 0xfa, 0x36, 0xd6, 0xfe, 0x57, 0x9a, 0x5d, 0xca, 0x5e, 0xd7, 0xe0, 0x3c, 0x4b,
+	0x3d, 0xcc, 0x20, 0xc0, 0x9e, 0x6d, 0x98, 0x84, 0x1a, 0xbd, 0xc2, 0x8c, 0xfe, 0x1c, 0x9d, 0xb8,
+	0xc5, 0xe0, 0xb7, 0xc8, 0x6e, 0xa4, 0xfd, 0x62, 0x1c, 0x66, 0xe8, 0x5a, 0xea, 0x64, 0x95, 0xe4,
+	0x9d, 0x85, 0x1a, 0x7e, 0x4a, 0x84, 0xa0, 0xf4, 0x13, 0x6d, 0xc0, 0x9c, 0xf0, 0x66, 0xc7, 0xf7,
+	0x86, 0x8e, 0x5e, 0xe3, 0x71, 0x71, 0x38, 0x15, 0xfb, 0xfa, 0x25, 0x68, 0x46, 0xc4, 0x0f, 0x64,
+	0xdc, 0xe0, 0x79, 0x11, 0x50, 0x90, 0x88, 0x1b, 0x69, 0x9d, 0x4e, 0x16, 0xe8, 0xb4, 0xe5, 0x44,
+	0x06, 0xb6, 0x0c, 0xbe, 0x2b, 0x16, 0x79, 0xea, 0x3a, 0x38, 0xd1, 0x5d, 0x8b, 0x6b, 0x03, 0xbd,
+	0x0f, 0x4b, 0xce, 0x81, 0xe7, 0x87, 0xd8, 0x10, 0x8a, 0x64, 0xfe, 0xeb, 0xf9, 0xc4, 0xe8, 0xfa,
+	0x7d, 0x4f, 0x66, 0x4e, 0x1d, 0x8e, 0xb3, 0xc7, 0x50, 0xa8, 0x06, 0x76, 0x7d, 0xb2, 0x4d, 0xe7,
+	0xb5, 0xb7, 0x61, 0x76, 0xa8, 0x95, 0xea, 0x51, 0xe0, 0x5b, 0x45, 0x5a, 0xdc, 0x23, 0xd3, 0x71,
+	0xf7, 0xb0, 0x67, 0xe3, 0xf0, 0x39, 0xa3, 0x13, 0xba, 0x0e, 0xf3, 0x8e, 0xed, 0x62, 0x83, 0x38,
+	0x3d, 0xec, 0xf7, 0x89, 0x11, 0x61, 0xcb, 0xf7, 0xec, 0x48, 0xea, 0x97, 0xce, 0x3d, 0xe2, 0x53,
+	0x7b, 0x7c, 0x46, 0xfb, 0x61, 0x7c, 0x4b, 0x24, 0x77, 0x31, 0xcc, 0x8f, 0x3c, 0x8c, 0x29, 0x41,
+	0x9e, 0xea, 0x09, 0x31, 0x5a, 0x1c, 0xc8, 0xb3, 0x3a, 0x7a, 0x42, 0x02, 0x69, 0xdf, 0xb7, 0x07,
+	0x6c, 0x47, 0x2d, 0x1d, 0x38, 0xe8, 0xb6, 0x6f, 0x0f, 0x58, 0xb8, 0x8e, 0x0c, 0x66, 0x64, 0xd6,
+	0x61, 0xdf, 0x3b, 0x62, 0xbb, 0xa9, 0xeb, 0x4d, 0x27, 0x7a, 0x60, 0x46, 0x64, 0x8b, 0x82, 0xb4,
+	0xdf, 0x29, 0x32, 0x5e, 0xd0, 0x6d, 0xe8, 0xd8, 0xc2, 0xce, 0xf1, 0xbf, 0x41, 0x1d, 0x74, 0x85,
+	0x30, 0x82, 0x54, 0x2e, 0x2c, 0x1c, 0x0e, 0xf1, 0x39, 0x71, 0xab, 0xb2, 0x99, 0x61, 0xb8, 0x4a,
+	0x6f, 0x5c, 0x84, 0xab, 0x2f, 0xe5, 0x75, 0x71, 0xd7, 0xda, 0x3b, 0x34, 0x43, 0x3b, 0xba, 0x87,
+	0x3d, 0x1c, 0x9a, 0xe4, 0x4c, 0xd2, 0x17, 0x6d, 0x05, 0x2e, 0x96, 0x51, 0x17, 0xfc, 0xbf, 0x90,
+	0xd7, 0xa0, 0xc4, 0xd0, 0xf1, 0x7e, 0xdf, 0x71, 0xed, 0x33, 0x61, 0xff, 0x71, 0x56, 0xb8, 0x98,
+	0xb8, 0xb0, 0x9f, 0xab, 0x70, 0x3e, 0x64, 0x20, 0x62, 0x44, 0x14, 0x21, 0x7e, 0x8f, 0xb6, 0xf5,
+	0x19, 0x31, 0xc1, 0x16, 0xd2, 0x77, 0xe9, 0x4f, 0xc6, 0xa5, 0x05, 0x48, 0x6a, 0x67, 0x16, 0x56,
+	0x17, 0xa1, 0x31, 0x64, 0x5f, 0x63, 0xec, 0xeb, 0x91, 0xe0, 0x4b, 0xad, 0xd3, 0xf2, 0x83, 0x81,
+	0x81, 0x2d, 0x9e, 0x51, 0xb0, 0xa3, 0xae, 0xd3, 0xe7, 0x59, 0x30, 0xb8, 0x6b, 0xb1, 0x84, 0xa2,
+	0x7a, 0x8c, 0x4d, 0x50, 0xfb, 0x8a, 0x53, 0x9b, 0x4a, 0x52, 0xfb, 0x8a, 0x51, 0x93, 0x38, 0xc7,
+	0x4e, 0x97, 0xe3, 0x4c, 0x0f, 0x71, 0x1e, 0x3b, 0x5d, 0x8a, 0x33, 0xb4, 0xaa, 0xb4, 0x32, 0xc4,
+	0xa9, 0x7e, 0x0d, 0x8b, 0xe9, 0xd9, 0xea, 0x17, 0xf6, 0x73, 0x29, 0x4b, 0xbb, 0x98, 0x35, 0xa7,
+	0xcc, 0xad, 0x7f, 0x9c, 0xdd, 0x76, 0xe5, 0x0c, 0xe7, 0xf9, 0xf6, 0xb5, 0x9c, 0x55, 0x48, 0x3a,
+	0x4d, 0xfa, 0xbf, 0xec, 0xb6, 0x4f, 0x91, 0x2e, 0x9d, 0xcc, 0xf8, 0x52, 0xd6, 0x05, 0xb2, 0x39,
+	0xd5, 0x2f, 0xe3, 0xf8, 0x2a, 0x30, 0x68, 0x46, 0x53, 0x39, 0xae, 0x09, 0xbe, 0xa2, 0xae, 0x30,
+	0x2d, 0xd8, 0xa2, 0x05, 0x98, 0x12, 0xf7, 0x21, 0x7f, 0xb1, 0x88, 0x51, 0xaa, 0x64, 0x52, 0x13,
+	0x25, 0x13, 0x59, 0x0a, 0xa2, 0x6f, 0xee, 0x49, 0x1e, 0x1e, 0xe9, 0xf8, 0x63, 0x3c, 0xd0, 0x76,
+	0x33, 0x1e, 0xc7, 0xb7, 0x76, 0x42, 0xc1, 0x83, 0x57, 0x14, 0x6c, 0x76, 0xe6, 0xb6, 0x28, 0x9c,
+	0x34, 0x1c, 0x61, 0x04, 0xb6, 0xf6, 0x53, 0x65, 0x48, 0xf0, 0xb6, 0xeb, 0xef, 0x9f, 0xa1, 0x55,
+	0x26, 0xa5, 0xa8, 0xa5, 0xa4, 0x48, 0xd6, 0x84, 0x26, 0xd2, 0x35, 0xa1, 0x84, 0x13, 0x25, 0xb7,
+	0x53, 0x16, 0x9a, 0x1f, 0xf9, 0x67, 0xf7, 0xb2, 0xcc, 0x87, 0xe6, 0x21, 0x75, 0xc1, 0xff, 0x26,
+	0x2c, 0x52, 0x85, 0x73, 0x28, 0x7b, 0xb7, 0x54, 0x7f, 0xdb, 0xfd, 0x79, 0x1c, 0x96, 0x8a, 0x17,
+	0x57, 0x79, 0xdf, 0xbd, 0x0b, 0x6a, 0xfc, 0x7e, 0xa2, 0x57, 0x63, 0x44, 0xcc, 0x5e, 0x10, 0x5f,
+	0x8e, 0xfc, 0x0e, 0xbd, 0x20, 0x1e, 0x53, 0x8f, 0xe4, 0xbc, 0xbc, 0x21, 0x73, 0x8f, 0xaf, 0x5a,
+	0xee, 0xf1, 0x45, 0x19, 0xd8, 0x26, 0x29, 0x63, 0xc0, 0x73, 0xb8, 0x0b, 0xb6, 0x49, 0xca, 0x18,
+	0xc4, 0x8b, 0x19, 0x03, 0x6e, 0xb5, 0x4d, 0x81, 0xcf, 0x18, 0x2c, 0x03, 0x88, 0xf4, 0xaa, 0xef,
+	0xc9, 0xc7, 0x64, 0x83, 0x27, 0x57, 0x7d, 0xaf, 0x34, 0xcb, 0x9c, 0x2e, 0xcd, 0x32, 0xd3, 0xa7,
+	0x59, 0xcf, 0x9d, 0xe6, 0xaf, 0x14, 0x80, 0x3b, 0x4e, 0x74, 0xc4, 0xb5, 0x4c, 0xf3, 0x5a, 0xdb,
+	0x91, 0xcf, 0x01, 0xfa, 0x49, 0x21, 0xa6, 0xeb, 0x0a, 0xdd, 0xd1, 0x4f, 0xea, 0x3f, 0xfd, 0x08,
+	0xdb, 0x42, 0x3d, 0xec, 0x9b, 0xc2, 0xba, 0x21, 0xc6, 0x42, 0x03, 0xec, 0x9b, 0x66, 0x8a, 0x01,
+	0x0e, 0x2d, 0xec, 0x11, 0x83, 0xcd, 0x51, 0x69, 0xc7, 0xf5, 0xa6, 0x80, 0x6d, 0x67, 0x50, 0x18,
+	0xc9, 0xa9, 0x14, 0xca, 0x67, 0x11, 0xb6, 0xb5, 0xdf, 0x28, 0xd0, 0xd8, 0xc1, 0x3d, 0xb1, 0xbf,
+	0x8b, 0x00, 0x07, 0x7e, 0xe8, 0xf7, 0x89, 0xe3, 0x61, 0x9e, 0xcc, 0x4f, 0xea, 0x09, 0xc8, 0x73,
+	0xec, 0x96, 0x46, 0x18, 0xec, 0x76, 0xc5, 0x99, 0xb0, 0x6f, 0x0a, 0x3b, 0xc4, 0x66, 0x20, 0x8e,
+	0x81, 0x7d, 0xd3, 0x27, 0x53, 0x44, 0x4c, 0xeb, 0x88, 0xe9, 0x7c, 0x42, 0xe7, 0x03, 0xed, 0x0f,
+	0x0a, 0x80, 0x8e, 0x7b, 0x3e, 0x61, 0x26, 0x4b, 0xe5, 0xda, 0x37, 0xad, 0x23, 0xfa, 0xec, 0x60,
+	0x85, 0x51, 0xae, 0xcf, 0xa6, 0x80, 0xb1, 0xc2, 0xe8, 0x32, 0x80, 0x44, 0x11, 0x61, 0xb0, 0xa1,
+	0x37, 0x04, 0x84, 0x3f, 0x30, 0x64, 0x44, 0x10, 0xb5, 0xc4, 0x61, 0x68, 0xe4, 0xdb, 0x96, 0xa1,
+	0x71, 0x11, 0x1a, 0x59, 0x8b, 0x62, 0x11, 0x85, 0x99, 0xd3, 0x15, 0x68, 0xcb, 0xca, 0x2b, 0xb3,
+	0x57, 0x21, 0x4a, 0x4b, 0x02, 0xa9, 0x8d, 0xb2, 0x2a, 0xe7, 0x53, 0x82, 0xbd, 0xd8, 0x94, 0x1a,
+	0xfa, 0x10, 0xa0, 0x7d, 0x03, 0x20, 0xeb, 0x02, 0x5d, 0x1f, 0x6d, 0xc2, 0x24, 0x25, 0x2e, 0x6b,
+	0xe9, 0x4b, 0xf9, 0xca, 0xea, 0x50, 0x0d, 0x3a, 0x47, 0x4d, 0xc6, 0xb1, 0xf1, 0x54, 0x1c, 0x1b,
+	0xfd, 0x2c, 0xd4, 0xbe, 0x53, 0x60, 0x45, 0x64, 0xa1, 0x0e, 0x0e, 0x77, 0xfc, 0x63, 0x9a, 0x91,
+	0x3c, 0xf2, 0x39, 0x93, 0x33, 0x09, 0xc0, 0x37, 0xa0, 0x63, 0xe3, 0x88, 0x38, 0x1e, 0x63, 0x68,
+	0xc8, 0x43, 0x61, 0xc5, 0x68, 0xbe, 0xa1, 0x85, 0xc4, 0xfc, 0x6d, 0x3e, 0xbd, 0x6b, 0xf6, 0x30,
+	0xba, 0x06, 0x73, 0x47, 0x18, 0x07, 0x86, 0xeb, 0x5b, 0xa6, 0x6b, 0x48, 0xd7, 0x16, 0x69, 0xd6,
+	0x2c, 0x9d, 0x7a, 0x40, 0x67, 0xee, 0x70, 0xf7, 0xd6, 0x22, 0xb8, 0x7c, 0x82, 0x24, 0x22, 0xbc,
+	0x2d, 0x41, 0x23, 0x08, 0x7d, 0x0b, 0x47, 0xd4, 0x66, 0x15, 0x76, 0xdb, 0x0d, 0x01, 0xe8, 0x3a,
+	0xcc, 0xc5, 0x83, 0x4f, 0xb8, 0x93, 0x98, 0x07, 0xbc, 0xfc, 0x3a, 0xae, 0x17, 0x4d, 0x69, 0x3f,
+	0x57, 0x40, 0xcb, 0x71, 0xdd, 0x0e, 0xfd, 0xde, 0x19, 0x6a, 0x70, 0x03, 0xe6, 0x99, 0x1e, 0x42,
+	0x46, 0x72, 0xa8, 0x08, 0xfe, 0x1a, 0x3a, 0x4f, 0xe7, 0x38, 0x37, 0xa9, 0x89, 0x3e, 0x5c, 0x39,
+	0x71, 0x4f, 0xff, 0x22, 0x5d, 0x2c, 0xca, 0x4b, 0x9c, 0x3f, 0x70, 0x52, 0xb7, 0x92, 0xf6, 0x6b,
+	0x45, 0xde, 0xa9, 0xe9, 0x59, 0xb1, 0x97, 0x5b, 0xd0, 0xb6, 0x9d, 0xe8, 0xc8, 0xe0, 0x8d, 0x9d,
+	0x93, 0xec, 0x7f, 0x18, 0x4d, 0xf5, 0x96, 0x1d, 0x7f, 0xe3, 0x08, 0x7d, 0x00, 0x6d, 0x51, 0x3c,
+	0x4d, 0xf4, 0x8a, 0x9a, 0x9b, 0x8b, 0x79, 0x12, 0x71, 0xbc, 0xd3, 0x5b, 0x7c, 0x05, 0x1f, 0x69,
+	0x7f, 0x6b, 0x41, 0xeb, 0xd3, 0x3e, 0x0e, 0x07, 0x89, 0xc2, 0x73, 0x84, 0xc5, 0x31, 0xc8, 0x7e,
+	0x58, 0x02, 0x42, 0x6f, 0x9c, 0x6e, 0xe8, 0xf7, 0x8c, 0xb8, 0x65, 0x36, 0xce, 0x50, 0x9a, 0x14,
+	0xb8, 0xcd, 0xdb, 0x66, 0xe8, 0x3d, 0x98, 0xea, 0x3a, 0x2e, 0xc1, 0xbc, 0x49, 0xd5, 0xdc, 0x7c,
+	0x39, 0xbf, 0x9f, 0x24, 0xcf, 0xf5, 0x6d, 0x86, 0xac, 0x8b, 0x45, 0x68, 0x1f, 0xe6, 0x1c, 0x2f,
+	0x60, 0x4f, 0xd0, 0xd0, 0x31, 0x5d, 0xe7, 0xd9, 0xb0, 0x74, 0xda, 0xdc, 0x7c, 0x63, 0x04, 0xad,
+	0xfb, 0x74, 0xe5, 0x5e, 0x72, 0xa1, 0x8e, 0x9c, 0x1c, 0x0c, 0x61, 0x98, 0xf7, 0xfb, 0x24, 0xcf,
+	0x64, 0x92, 0x31, 0xd9, 0x1c, 0xc1, 0xe4, 0x21, 0x5b, 0x9a, 0xe6, 0x32, 0xe7, 0xe7, 0x81, 0xea,
+	0x2e, 0x4c, 0x71, 0xe1, 0x68, 0x90, 0xef, 0x3a, 0xd8, 0x95, 0xfd, 0x35, 0x3e, 0xa0, 0x71, 0xcc,
+	0x0f, 0x70, 0x68, 0x7a, 0x32, 0x5e, 0xcb, 0xe1, 0xb0, 0xcf, 0x53, 0x4b, 0xf4, 0x79, 0xd4, 0xdf,
+	0x4f, 0x02, 0xca, 0x4b, 0x28, 0xeb, 0xc1, 0x21, 0x8e, 0x68, 0x0c, 0x4c, 0x5e, 0x10, 0x33, 0x09,
+	0x38, 0xbb, 0x24, 0x3e, 0x87, 0x86, 0x15, 0x1d, 0x1b, 0x4c, 0x25, 0xc2, 0x5c, 0x6e, 0x9e, 0x5a,
+	0xa5, 0xeb, 0x5b, 0x7b, 0x8f, 0x19, 0x54, 0xaf, 0x5b, 0xd1, 0x31, 0xfb, 0x42, 0xdf, 0x03, 0xf8,
+	0x2a, 0xf2, 0x3d, 0x41, 0x99, 0x1f, 0xfc, 0xbb, 0xa7, 0xa7, 0xfc, 0xd1, 0xde, 0xc3, 0x5d, 0x4e,
+	0xba, 0x41, 0xc9, 0x71, 0xda, 0x16, 0xb4, 0x03, 0x33, 0x7c, 0xd2, 0xc7, 0x44, 0x90, 0xe7, 0xb6,
+	0xf0, 0xfe, 0xe9, 0xc9, 0x7f, 0xc2, 0xc9, 0x70, 0x0e, 0xad, 0x20, 0x31, 0x52, 0xbf, 0x1b, 0x87,
+	0xba, 0x94, 0x8b, 0xbe, 0x62, 0x99, 0x85, 0xf3, 0x5a, 0x8e, 0xe1, 0x78, 0x5d, 0x5f, 0x68, 0xf4,
+	0x1c, 0x85, 0xf3, 0x72, 0x0e, 0xbb, 0xbe, 0xd6, 0x60, 0x36, 0xc4, 0x96, 0x1f, 0xda, 0x34, 0xd7,
+	0x77, 0x7a, 0x0e, 0x35, 0x7b, 0x7e, 0x96, 0x33, 0x1c, 0x7e, 0x47, 0x82, 0xd1, 0xab, 0x30, 0xc3,
+	0x8e, 0x3d, 0x81, 0x59, 0x93, 0x34, 0xb1, 0x9b, 0x40, 0x5c, 0x83, 0xd9, 0x27, 0x7d, 0x1a, 0xf8,
+	0xac, 0x43, 0x33, 0x34, 0x2d, 0xe2, 0xc7, 0x55, 0x95, 0x19, 0x06, 0xdf, 0x8a, 0xc1, 0xe8, 0x2d,
+	0x58, 0xe0, 0xa8, 0x38, 0xb2, 0xcc, 0x20, 0x5e, 0x81, 0x43, 0xf1, 0xe8, 0x9e, 0x67, 0xb3, 0x77,
+	0xd9, 0xe4, 0x96, 0x9c, 0x43, 0x2a, 0xd4, 0x2d, 0xbf, 0xd7, 0xc3, 0x1e, 0x89, 0x44, 0x1b, 0x34,
+	0x1e, 0xa3, 0x5b, 0xb0, 0x6c, 0xba, 0xae, 0xff, 0xb5, 0xc1, 0x56, 0xda, 0x46, 0x4e, 0x3a, 0xfe,
+	0x04, 0x57, 0x19, 0xd2, 0xa7, 0x0c, 0x47, 0x4f, 0x0b, 0xaa, 0x5e, 0x82, 0x46, 0x7c, 0x8e, 0x34,
+	0xe5, 0x49, 0x18, 0x24, 0xfb, 0x56, 0xcf, 0x41, 0x2b, 0x79, 0x12, 0xea, 0x5f, 0x6a, 0x30, 0x57,
+	0xe0, 0x54, 0xe8, 0x0b, 0x00, 0x6a, 0xad, 0xdc, 0xb5, 0x84, 0xb9, 0xfe, 0xcf, 0xe9, 0x9d, 0x93,
+	0xda, 0x2b, 0x07, 0xeb, 0xd4, 0xfa, 0xf9, 0x27, 0xfa, 0x3e, 0x34, 0x99, 0xc5, 0x0a, 0xea, 0xdc,
+	0x64, 0xdf, 0xfb, 0x27, 0xa8, 0x53, 0x59, 0x05, 0x79, 0xe6, 0x03, 0xfc, 0x5b, 0xfd, 0x93, 0x02,
+	0x8d, 0x98, 0x31, 0x4d, 0xe0, 0xf8, 0x41, 0xb1, 0xb3, 0x8e, 0x64, 0x02, 0xc7, 0x60, 0xdb, 0x0c,
+	0xf4, 0x1f, 0x69, 0x4a, 0xea, 0x3b, 0x00, 0x43, 0xf9, 0x0b, 0x45, 0x50, 0x0a, 0x45, 0xd0, 0xd6,
+	0xa0, 0x4d, 0x35, 0xeb, 0x60, 0x7b, 0x8f, 0x84, 0x4e, 0xc0, 0x7e, 0xb0, 0xc0, 0x71, 0x22, 0xf1,
+	0x90, 0x96, 0xc3, 0xcd, 0xbf, 0x2e, 0x41, 0x2b, 0x79, 0x93, 0xa2, 0x2f, 0xa1, 0x99, 0xf8, 0x61,
+	0x06, 0x7a, 0x29, 0x7f, 0x68, 0xf9, 0x1f, 0x7a, 0xa8, 0x2f, 0x8f, 0xc0, 0x12, 0x6f, 0xcd, 0x31,
+	0xa4, 0xc3, 0xb4, 0x68, 0xe6, 0xa3, 0x95, 0x13, 0xfa, 0xfc, 0x9c, 0xea, 0xe5, 0x91, 0xbf, 0x04,
+	0xd0, 0xc6, 0xae, 0x2b, 0xc8, 0x83, 0xf3, 0xb9, 0xde, 0x3a, 0xba, 0x9a, 0x5f, 0x5b, 0xd6, 0xb9,
+	0x57, 0x5f, 0xab, 0x84, 0x1b, 0xcb, 0x40, 0x60, 0xae, 0xa0, 0x59, 0x8e, 0x5e, 0x1f, 0x41, 0x25,
+	0xd5, 0xb0, 0x57, 0xaf, 0x55, 0xc4, 0x8e, 0xb9, 0x3e, 0x01, 0x94, 0xef, 0xa4, 0xa3, 0xd7, 0x46,
+	0x92, 0x19, 0x76, 0xea, 0xd5, 0xd7, 0xab, 0x21, 0x97, 0x0a, 0xca, 0x7b, 0xec, 0x23, 0x05, 0x4d,
+	0x75, 0xf1, 0x47, 0x0a, 0x9a, 0x69, 0xdc, 0x8f, 0xa1, 0x23, 0x98, 0xcd, 0xf6, 0xdf, 0xd1, 0x5a,
+	0xd9, 0xaf, 0x80, 0x72, 0xed, 0x7d, 0xf5, 0x6a, 0x15, 0xd4, 0x98, 0x19, 0x86, 0x73, 0xe9, 0x7e,
+	0x37, 0x7a, 0x35, 0xbf, 0xbe, 0xb0, 0xe3, 0xaf, 0xae, 0x8e, 0x46, 0x4c, 0xca, 0x94, 0xed, 0x81,
+	0x17, 0xc9, 0x54, 0xd2, 0x60, 0x2f, 0x92, 0xa9, 0xac, 0xa5, 0xae, 0x8d, 0xa1, 0x6f, 0x64, 0x63,
+	0x35, 0xd3, 0x1b, 0x46, 0xeb, 0x65, 0x64, 0x8a, 0x9b, 0xd3, 0xea, 0x46, 0x65, 0xfc, 0x84, 0x37,
+	0x7e, 0x09, 0xcd, 0x44, 0x8b, 0xb8, 0x28, 0x7e, 0xe4, 0x9b, 0xce, 0x45, 0xf1, 0xa3, 0xa8, 0xcf,
+	0x3c, 0x86, 0xf6, 0xa1, 0x9d, 0x6a, 0x1a, 0xa3, 0x57, 0xca, 0x56, 0xa6, 0x6b, 0xab, 0xea, 0xab,
+	0x23, 0xf1, 0x62, 0x1e, 0x86, 0x8c, 0x88, 0x22, 0x04, 0x96, 0x6e, 0x2e, 0x1d, 0x03, 0x5f, 0x19,
+	0x85, 0x96, 0x72, 0xe5, 0x5c, 0x6b, 0xb9, 0xd0, 0x95, 0xcb, 0x5a, 0xd7, 0x85, 0xae, 0x5c, 0xde,
+	0xad, 0x1e, 0x43, 0x87, 0x30, 0x93, 0x69, 0x2b, 0xa3, 0xd5, 0x32, 0x12, 0xd9, 0x96, 0xb6, 0xba,
+	0x56, 0x01, 0x33, 0xe6, 0xf4, 0xff, 0xb2, 0x02, 0xc1, 0x4c, 0xee, 0x4a, 0xf9, 0xd2, 0xa1, 0x9d,
+	0xbd, 0x74, 0x32, 0x52, 0x4c, 0xfa, 0x6b, 0x98, 0x2f, 0xaa, 0x36, 0xa2, 0x6b, 0x45, 0x75, 0x8d,
+	0xd2, 0x92, 0xa6, 0xba, 0x5e, 0x15, 0x3d, 0x66, 0xfc, 0x19, 0xd4, 0x65, 0x6b, 0x15, 0x15, 0x5c,
+	0x4a, 0x99, 0x66, 0xb4, 0xaa, 0x9d, 0x84, 0x92, 0x70, 0x95, 0x9e, 0x8c, 0x0a, 0xc3, 0x9e, 0x67,
+	0x79, 0x54, 0xc8, 0x75, 0x67, 0xcb, 0xa3, 0x42, 0xbe, 0x85, 0xca, 0xd8, 0xc5, 0x66, 0x97, 0x6c,
+	0x11, 0x96, 0x9b, 0x5d, 0x41, 0x07, 0xb4, 0xdc, 0xec, 0x0a, 0xbb, 0x8e, 0x63, 0xe8, 0x07, 0xf2,
+	0x67, 0x12, 0xd9, 0xce, 0x20, 0x2a, 0x8d, 0x2d, 0x25, 0x1d, 0x4a, 0xf5, 0x7a, 0xf5, 0x05, 0x31,
+	0xfb, 0x67, 0x32, 0x12, 0x66, 0x3a, 0x83, 0xe5, 0x91, 0xb0, 0xb8, 0x3f, 0xa9, 0x6e, 0x54, 0xc6,
+	0xcf, 0x3b, 0x79, 0xb2, 0x75, 0x56, 0xae, 0xed, 0x82, 0x6e, 0x63, 0xb9, 0xb6, 0x0b, 0xbb, 0x71,
+	0xcc, 0x3f, 0x8a, 0xda, 0x62, 0x45, 0xfe, 0x71, 0x42, 0xdf, 0x4e, 0x5d, 0xaf, 0x8a, 0x9e, 0x4a,
+	0x14, 0xf2, 0x7d, 0x2f, 0x34, 0x72, 0xff, 0xa9, 0x3b, 0xe0, 0x5a, 0x45, 0xec, 0xf2, 0xd3, 0x95,
+	0x77, 0xc2, 0x48, 0x01, 0x32, 0x77, 0xc3, 0x46, 0x65, 0xfc, 0x98, 0x77, 0x20, 0x7f, 0x74, 0x93,
+	0xe8, 0x59, 0xa1, 0xab, 0x23, 0xe8, 0x24, 0x7a, 0x6e, 0xea, 0x6b, 0x95, 0x70, 0x8b, 0xbc, 0x37,
+	0xd9, 0x45, 0x3a, 0xc9, 0x9e, 0x72, 0xad, 0xaf, 0x93, 0xec, 0xa9, 0xa0, 0x31, 0x55, 0xe0, 0xbd,
+	0xb2, 0x79, 0x34, 0xda, 0x7b, 0x33, 0x4d, 0xac, 0xd1, 0xde, 0x9b, 0xeb, 0x4b, 0x8d, 0xa1, 0x1f,
+	0x0f, 0x7f, 0x8c, 0x91, 0xaf, 0xc1, 0xa2, 0xcd, 0xd2, 0x50, 0x54, 0x5a, 0x7a, 0x56, 0xdf, 0x3c,
+	0xd5, 0x9a, 0x84, 0xf2, 0x7f, 0xa6, 0xc8, 0xce, 0x6e, 0x61, 0x11, 0x14, 0xbd, 0x55, 0x81, 0x70,
+	0xae, 0x8e, 0xab, 0xbe, 0x7d, 0xca, 0x55, 0x45, 0xd6, 0x90, 0xac, 0x7f, 0x96, 0x5b, 0x43, 0x41,
+	0x0d, 0xb5, 0xdc, 0x1a, 0x8a, 0x4a, 0xaa, 0xda, 0x18, 0x7a, 0x00, 0x93, 0xec, 0xb9, 0x8e, 0x2e,
+	0x9e, 0xfc, 0x8e, 0x57, 0x2f, 0x15, 0xcf, 0xc7, 0xaf, 0x51, 0x2a, 0xc0, 0xfe, 0x14, 0xfb, 0x27,
+	0xc1, 0x9b, 0xff, 0x08, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x4b, 0x03, 0xaa, 0x60, 0x30, 0x00, 0x00,
 }
diff --git a/weed/pb/volume_server_pb/volume_server_helper.go b/weed/pb/volume_server_pb/volume_server_helper.go
new file mode 100644
index 000000000..356be27ff
--- /dev/null
+++ b/weed/pb/volume_server_pb/volume_server_helper.go
@@ -0,0 +1,5 @@
+package volume_server_pb
+
+func (m *RemoteFile) BackendName() string {
+	return m.BackendType + "." + m.BackendId
+}