shell: add command volume.move

unmaintained/volume_tailer/volume_tailer.go

@@ -65,7 +65,7 @@ func main() {
 	})
 
 	if err != nil {
-		log.Printf("Error VolumeTail volume %d: %v", vid, err)
+		log.Printf("Error VolumeTailSender volume %d: %v", vid, err)
 	}
 
 }

weed/operation/tail_volume.go

@@ -22,9 +22,13 @@ func TailVolume(master string, grpcDialOption grpc.DialOption, vid needle.Volume
 
 	volumeServer := lookup.Locations[0].Url
 
+	return TailVolumeFromServer(volumeServer, grpcDialOption, vid, sinceNs, timeoutSeconds, fn)
+}
+
+func TailVolumeFromServer(volumeServer string, grpcDialOption grpc.DialOption, vid needle.VolumeId, sinceNs uint64, timeoutSeconds int, fn func(n *needle.Needle) error) error {
 	return WithVolumeServerClient(volumeServer, grpcDialOption, func(client volume_server_pb.VolumeServerClient) error {
 
-		stream, err := client.VolumeTail(context.Background(), &volume_server_pb.VolumeTailRequest{
+		stream, err := client.VolumeTailSender(context.Background(), &volume_server_pb.VolumeTailSenderRequest{
 			VolumeId:        uint32(vid),
 			SinceNs:         sinceNs,
 			DrainingSeconds: uint32(timeoutSeconds),

weed/pb/master.proto

@@ -35,9 +35,9 @@ message Heartbeat {
     string rack = 7;
     uint32 admin_port = 8;
     repeated VolumeInformationMessage volumes = 9;
-    // delta volume ids
-    repeated uint32 new_vids = 10;
-    repeated uint32 deleted_vids = 11;
+    // delta volumes
+    repeated VolumeShortInformationMessage new_volumes = 10;
+    repeated VolumeShortInformationMessage deleted_volumes = 11;
 }
 
 message HeartbeatResponse {
@@ -59,6 +59,13 @@ message VolumeInformationMessage {
     uint32 compact_revision = 11;
 }
 
+message VolumeShortInformationMessage {
+    uint32 id = 1;
+    string collection = 3;
+    uint32 replica_placement = 8;
+    uint32 ttl = 10;
+}
+
 message Empty {
 }
 

weed/pb/master_pb/master.pb.go

@@ -12,6 +12,7 @@ It has these top-level messages:
 	Heartbeat
 	HeartbeatResponse
 	VolumeInformationMessage
+	VolumeShortInformationMessage
 	Empty
 	SuperBlockExtra
 	ClientListenRequest
@@ -68,9 +69,9 @@ type Heartbeat struct {
 	Rack           string                      `protobuf:"bytes,7,opt,name=rack" json:"rack,omitempty"`
 	AdminPort      uint32                      `protobuf:"varint,8,opt,name=admin_port,json=adminPort" json:"admin_port,omitempty"`
 	Volumes        []*VolumeInformationMessage `protobuf:"bytes,9,rep,name=volumes" json:"volumes,omitempty"`
-	// delta volume ids
-	NewVids     []uint32 `protobuf:"varint,10,rep,packed,name=new_vids,json=newVids" json:"new_vids,omitempty"`
-	DeletedVids []uint32 `protobuf:"varint,11,rep,packed,name=deleted_vids,json=deletedVids" json:"deleted_vids,omitempty"`
+	// delta volumes
+	NewVolumes     []*VolumeShortInformationMessage `protobuf:"bytes,10,rep,name=new_volumes,json=newVolumes" json:"new_volumes,omitempty"`
+	DeletedVolumes []*VolumeShortInformationMessage `protobuf:"bytes,11,rep,name=deleted_volumes,json=deletedVolumes" json:"deleted_volumes,omitempty"`
 }
 
 func (m *Heartbeat) Reset()                    { *m = Heartbeat{} }
@@ -141,16 +142,16 @@ func (m *Heartbeat) GetVolumes() []*VolumeInformationMessage {
 	return nil
 }
 
-func (m *Heartbeat) GetNewVids() []uint32 {
+func (m *Heartbeat) GetNewVolumes() []*VolumeShortInformationMessage {
 	if m != nil {
-		return m.NewVids
+		return m.NewVolumes
 	}
 	return nil
 }
 
-func (m *Heartbeat) GetDeletedVids() []uint32 {
+func (m *Heartbeat) GetDeletedVolumes() []*VolumeShortInformationMessage {
 	if m != nil {
-		return m.DeletedVids
+		return m.DeletedVolumes
 	}
 	return nil
 }
@@ -275,13 +276,53 @@ func (m *VolumeInformationMessage) GetCompactRevision() uint32 {
 	return 0
 }
 
+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"`
+	ReplicaPlacement uint32 `protobuf:"varint,8,opt,name=replica_placement,json=replicaPlacement" json:"replica_placement,omitempty"`
+	Ttl              uint32 `protobuf:"varint,10,opt,name=ttl" json:"ttl,omitempty"`
+}
+
+func (m *VolumeShortInformationMessage) Reset()                    { *m = VolumeShortInformationMessage{} }
+func (m *VolumeShortInformationMessage) String() string            { return proto.CompactTextString(m) }
+func (*VolumeShortInformationMessage) ProtoMessage()               {}
+func (*VolumeShortInformationMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+func (m *VolumeShortInformationMessage) GetId() uint32 {
+	if m != nil {
+		return m.Id
+	}
+	return 0
+}
+
+func (m *VolumeShortInformationMessage) GetCollection() string {
+	if m != nil {
+		return m.Collection
+	}
+	return ""
+}
+
+func (m *VolumeShortInformationMessage) GetReplicaPlacement() uint32 {
+	if m != nil {
+		return m.ReplicaPlacement
+	}
+	return 0
+}
+
+func (m *VolumeShortInformationMessage) GetTtl() uint32 {
+	if m != nil {
+		return m.Ttl
+	}
+	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{4} }
 
 type SuperBlockExtra struct {
 	ErasureCoding *SuperBlockExtra_ErasureCoding `protobuf:"bytes,1,opt,name=erasure_coding,json=erasureCoding" json:"erasure_coding,omitempty"`
@@ -290,7 +331,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{4} }
+func (*SuperBlockExtra) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 
 func (m *SuperBlockExtra) GetErasureCoding() *SuperBlockExtra_ErasureCoding {
 	if m != nil {
@@ -309,7 +350,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{4, 0}
+	return fileDescriptor0, []int{5, 0}
 }
 
 func (m *SuperBlockExtra_ErasureCoding) GetData() uint32 {
@@ -340,7 +381,7 @@ type ClientListenRequest struct {
 func (m *ClientListenRequest) Reset()                    { *m = ClientListenRequest{} }
 func (m *ClientListenRequest) String() string            { return proto.CompactTextString(m) }
 func (*ClientListenRequest) ProtoMessage()               {}
-func (*ClientListenRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+func (*ClientListenRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 
 func (m *ClientListenRequest) GetName() string {
 	if m != nil {
@@ -359,7 +400,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{6} }
+func (*VolumeLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 
 func (m *VolumeLocation) GetUrl() string {
 	if m != nil {
@@ -397,7 +438,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{7} }
+func (*LookupVolumeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 
 func (m *LookupVolumeRequest) GetVolumeIds() []string {
 	if m != nil {
@@ -420,7 +461,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{8} }
+func (*LookupVolumeResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 
 func (m *LookupVolumeResponse) GetVolumeIdLocations() []*LookupVolumeResponse_VolumeIdLocation {
 	if m != nil {
@@ -439,7 +480,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{8, 0}
+	return fileDescriptor0, []int{9, 0}
 }
 
 func (m *LookupVolumeResponse_VolumeIdLocation) GetVolumeId() string {
@@ -471,7 +512,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{9} }
+func (*Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 
 func (m *Location) GetUrl() string {
 	if m != nil {
@@ -500,7 +541,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{10} }
+func (*AssignRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
 func (m *AssignRequest) GetCount() uint64 {
 	if m != nil {
@@ -563,7 +604,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{11} }
+func (*AssignResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 
 func (m *AssignResponse) GetFid() string {
 	if m != nil {
@@ -616,7 +657,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{12} }
+func (*StatisticsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 
 func (m *StatisticsRequest) GetReplication() string {
 	if m != nil {
@@ -651,7 +692,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{13} }
+func (*StatisticsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 
 func (m *StatisticsResponse) GetReplication() string {
 	if m != nil {
@@ -703,7 +744,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{14} }
+func (*StorageType) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
 
 func (m *StorageType) GetReplication() string {
 	if m != nil {
@@ -726,7 +767,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{15} }
+func (*Collection) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
 
 func (m *Collection) GetName() string {
 	if m != nil {
@@ -741,7 +782,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{16} }
+func (*CollectionListRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
 
 type CollectionListResponse struct {
 	Collections []*Collection `protobuf:"bytes,1,rep,name=collections" json:"collections,omitempty"`
@@ -750,7 +791,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{17} }
+func (*CollectionListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
 
 func (m *CollectionListResponse) GetCollections() []*Collection {
 	if m != nil {
@@ -766,7 +807,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{18} }
+func (*CollectionDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
 
 func (m *CollectionDeleteRequest) GetName() string {
 	if m != nil {
@@ -781,7 +822,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{19} }
+func (*CollectionDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
 
 //
 // volume related
@@ -798,7 +839,7 @@ type DataNodeInfo struct {
 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{20} }
+func (*DataNodeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
 
 func (m *DataNodeInfo) GetId() string {
 	if m != nil {
@@ -854,7 +895,7 @@ type RackInfo struct {
 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{21} }
+func (*RackInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
 
 func (m *RackInfo) GetId() string {
 	if m != nil {
@@ -910,7 +951,7 @@ type DataCenterInfo struct {
 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{22} }
+func (*DataCenterInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
 
 func (m *DataCenterInfo) GetId() string {
 	if m != nil {
@@ -966,7 +1007,7 @@ type TopologyInfo struct {
 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{23} }
+func (*TopologyInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
 
 func (m *TopologyInfo) GetId() string {
 	if m != nil {
@@ -1016,7 +1057,7 @@ 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{24} }
+func (*VolumeListRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
 
 type VolumeListResponse struct {
 	TopologyInfo *TopologyInfo `protobuf:"bytes,1,opt,name=topology_info,json=topologyInfo" json:"topology_info,omitempty"`
@@ -1025,7 +1066,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{25} }
+func (*VolumeListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
 
 func (m *VolumeListResponse) GetTopologyInfo() *TopologyInfo {
 	if m != nil {
@@ -1038,6 +1079,7 @@ 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((*Empty)(nil), "master_pb.Empty")
 	proto.RegisterType((*SuperBlockExtra)(nil), "master_pb.SuperBlockExtra")
 	proto.RegisterType((*SuperBlockExtra_ErasureCoding)(nil), "master_pb.SuperBlockExtra.ErasureCoding")
@@ -1436,94 +1478,97 @@ var _Seaweed_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("master.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 1416 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x58, 0xcd, 0x6f, 0xdc, 0x44,
-	0x14, 0x8f, 0xbd, 0x1f, 0x59, 0xbf, 0xfd, 0xc8, 0xee, 0x24, 0x6d, 0xdd, 0x2d, 0x6d, 0xb7, 0xee,
-	0x65, 0xcb, 0x47, 0x54, 0xc2, 0x81, 0x03, 0xa0, 0xaa, 0x4d, 0x53, 0x51, 0x35, 0xd0, 0xd6, 0x69,
-	0x8b, 0x84, 0x84, 0xcc, 0xc4, 0x7e, 0x09, 0x56, 0xbc, 0xb6, 0xb1, 0x67, 0xb7, 0xd9, 0x5e, 0xb8,
-	0x70, 0x44, 0x70, 0xe0, 0xff, 0xe1, 0xc2, 0x91, 0x3f, 0x85, 0x03, 0x12, 0x77, 0x24, 0x34, 0xe3,
-	0xb1, 0x77, 0xec, 0xdd, 0xa4, 0x15, 0x12, 0x87, 0xde, 0x3c, 0xbf, 0xf7, 0x66, 0xe6, 0xcd, 0xef,
-	0x7d, 0xee, 0x42, 0x67, 0x42, 0x53, 0x86, 0xc9, 0x76, 0x9c, 0x44, 0x2c, 0x22, 0x46, 0xb6, 0x72,
-	0xe2, 0x43, 0xeb, 0x4f, 0x1d, 0x8c, 0xcf, 0x91, 0x26, 0xec, 0x10, 0x29, 0x23, 0x3d, 0xd0, 0xfd,
-	0xd8, 0xd4, 0x46, 0xda, 0xd8, 0xb0, 0x75, 0x3f, 0x26, 0x04, 0xea, 0x71, 0x94, 0x30, 0x53, 0x1f,
-	0x69, 0xe3, 0xae, 0x2d, 0xbe, 0xc9, 0x55, 0x80, 0x78, 0x7a, 0x18, 0xf8, 0xae, 0x33, 0x4d, 0x02,
-	0xb3, 0x26, 0x74, 0x8d, 0x0c, 0x79, 0x9e, 0x04, 0x64, 0x0c, 0xfd, 0x09, 0x3d, 0x75, 0x66, 0x51,
-	0x30, 0x9d, 0xa0, 0xe3, 0x46, 0xd3, 0x90, 0x99, 0x75, 0xb1, 0xbd, 0x37, 0xa1, 0xa7, 0x2f, 0x04,
-	0xbc, 0xcb, 0x51, 0x32, 0xe2, 0x56, 0x9d, 0x3a, 0x47, 0x7e, 0x80, 0xce, 0x09, 0xce, 0xcd, 0xc6,
-	0x48, 0x1b, 0xd7, 0x6d, 0x98, 0xd0, 0xd3, 0x07, 0x7e, 0x80, 0x8f, 0x70, 0x4e, 0xae, 0x43, 0xdb,
-	0xa3, 0x8c, 0x3a, 0x2e, 0x86, 0x0c, 0x13, 0xb3, 0x29, 0xee, 0x02, 0x0e, 0xed, 0x0a, 0x84, 0xdb,
-	0x97, 0x50, 0xf7, 0xc4, 0x5c, 0x17, 0x12, 0xf1, 0xcd, 0xed, 0xa3, 0xde, 0xc4, 0x0f, 0x1d, 0x61,
-	0x79, 0x4b, 0x5c, 0x6d, 0x08, 0xe4, 0x09, 0x37, 0xff, 0x33, 0x58, 0xcf, 0x6c, 0x4b, 0x4d, 0x63,
-	0x54, 0x1b, 0xb7, 0x77, 0x6e, 0x6e, 0x17, 0x6c, 0x6c, 0x67, 0xe6, 0x3d, 0x0c, 0x8f, 0xa2, 0x64,
-	0x42, 0x99, 0x1f, 0x85, 0x5f, 0x60, 0x9a, 0xd2, 0x63, 0xb4, 0xf3, 0x3d, 0xe4, 0x32, 0xb4, 0x42,
-	0x7c, 0xe9, 0xcc, 0x7c, 0x2f, 0x35, 0x61, 0x54, 0x1b, 0x77, 0xed, 0xf5, 0x10, 0x5f, 0xbe, 0xf0,
-	0xbd, 0x94, 0xdc, 0x80, 0x8e, 0x87, 0x01, 0x32, 0xf4, 0x32, 0x71, 0x5b, 0x88, 0xdb, 0x12, 0xe3,
-	0x2a, 0xd6, 0x73, 0x18, 0x14, 0x64, 0xdb, 0x98, 0xc6, 0x51, 0x98, 0x22, 0x19, 0xc3, 0x46, 0x76,
-	0xfa, 0x81, 0xff, 0x0a, 0xf7, 0xfd, 0x89, 0xcf, 0x84, 0x07, 0xea, 0x76, 0x15, 0x26, 0x17, 0xa1,
-	0x19, 0x20, 0xf5, 0x30, 0x91, 0xb4, 0xcb, 0x95, 0xf5, 0x97, 0x0e, 0xe6, 0x59, 0xa6, 0x0b, 0x9f,
-	0x7a, 0xe2, 0xc4, 0xae, 0xad, 0xfb, 0x1e, 0xe7, 0x2c, 0xf5, 0x5f, 0xa1, 0xf0, 0x69, 0xdd, 0x16,
-	0xdf, 0xe4, 0x1a, 0x80, 0x1b, 0x05, 0x01, 0xba, 0x7c, 0xa3, 0x3c, 0x5c, 0x41, 0x38, 0xa7, 0xc2,
-	0x4d, 0x0b, 0x77, 0xd6, 0x6d, 0x83, 0x23, 0x99, 0x27, 0x8b, 0x97, 0x4b, 0x85, 0xcc, 0x93, 0xf2,
-	0xe5, 0x99, 0xca, 0xfb, 0x40, 0x72, 0x72, 0x0e, 0xe7, 0x85, 0x62, 0x53, 0x28, 0xf6, 0xa5, 0xe4,
-	0xde, 0x3c, 0xd7, 0xbe, 0x02, 0x46, 0x82, 0xd4, 0x73, 0xa2, 0x30, 0x98, 0x0b, 0xe7, 0xb6, 0xec,
-	0x16, 0x07, 0x1e, 0x87, 0xc1, 0x9c, 0xbc, 0x07, 0x83, 0x04, 0xe3, 0xc0, 0x77, 0xa9, 0x13, 0x07,
-	0xd4, 0xc5, 0x09, 0x86, 0xb9, 0x9f, 0xfb, 0x52, 0xf0, 0x24, 0xc7, 0x89, 0x09, 0xeb, 0x33, 0x4c,
-	0x52, 0xfe, 0x2c, 0x43, 0xa8, 0xe4, 0x4b, 0xd2, 0x87, 0x1a, 0x63, 0x81, 0x09, 0x02, 0xe5, 0x9f,
-	0xe4, 0x16, 0xf4, 0xdd, 0x68, 0x12, 0x53, 0x97, 0x39, 0x09, 0xce, 0x7c, 0xb1, 0xa9, 0x2d, 0xc4,
-	0x1b, 0x12, 0xb7, 0x25, 0x6c, 0xad, 0x43, 0x63, 0x6f, 0x12, 0xb3, 0xb9, 0xf5, 0x9b, 0x06, 0x1b,
-	0x07, 0xd3, 0x18, 0x93, 0x7b, 0x41, 0xe4, 0x9e, 0xec, 0x9d, 0xb2, 0x84, 0x92, 0xc7, 0xd0, 0xc3,
-	0x84, 0xa6, 0xd3, 0x84, 0x3f, 0xd3, 0xf3, 0xc3, 0x63, 0xc1, 0x7e, 0x7b, 0x67, 0xac, 0x44, 0x5a,
-	0x65, 0xcf, 0xf6, 0x5e, 0xb6, 0x61, 0x57, 0xe8, 0xdb, 0x5d, 0x54, 0x97, 0xc3, 0xaf, 0xa1, 0x5b,
-	0x92, 0x73, 0x1f, 0xf2, 0x2c, 0x90, 0x5e, 0x15, 0xdf, 0x3c, 0x38, 0x62, 0x9a, 0xf8, 0x6c, 0x2e,
-	0xb3, 0x55, 0xae, 0xb8, 0xef, 0x64, 0x32, 0xf2, 0xa0, 0xac, 0x89, 0xa0, 0x34, 0x32, 0xe4, 0xa1,
-	0x97, 0x5a, 0xb7, 0x60, 0x73, 0x37, 0xf0, 0x31, 0x64, 0xfb, 0x7e, 0xca, 0x30, 0xb4, 0xf1, 0xfb,
-	0x29, 0xa6, 0x8c, 0xdf, 0x10, 0xd2, 0x09, 0xca, 0x5a, 0x20, 0xbe, 0xad, 0x1f, 0xa0, 0x97, 0x45,
-	0xd9, 0x7e, 0xe4, 0x8a, 0x10, 0xe3, 0x1c, 0xf2, 0x22, 0x90, 0x29, 0xf1, 0xcf, 0x4a, 0x75, 0xd0,
-	0xab, 0xd5, 0x41, 0x4d, 0x9f, 0xda, 0xf9, 0xe9, 0x53, 0x5f, 0x4e, 0x9f, 0x67, 0xb0, 0xb9, 0x1f,
-	0x45, 0x27, 0xd3, 0x38, 0x33, 0x23, 0xb7, 0xb5, 0xfc, 0x42, 0x6d, 0x54, 0xe3, 0x77, 0x16, 0x2f,
-	0xac, 0x04, 0xb7, 0x5e, 0x0d, 0x6e, 0xeb, 0x6f, 0x0d, 0xb6, 0xca, 0xc7, 0xca, 0xc4, 0xfc, 0x16,
-	0x36, 0x8b, 0x73, 0x9d, 0x40, 0xbe, 0x39, 0xbb, 0xa0, 0xbd, 0x73, 0x5b, 0x71, 0xe6, 0xaa, 0xdd,
-	0x79, 0x2d, 0xf1, 0x72, 0xb2, 0xec, 0xc1, 0xac, 0x82, 0xa4, 0xc3, 0x53, 0xe8, 0x57, 0xd5, 0x78,
-	0xec, 0x17, 0xb7, 0x4a, 0x66, 0x5b, 0xf9, 0x4e, 0xf2, 0x21, 0x18, 0x0b, 0x43, 0x74, 0x61, 0xc8,
-	0x66, 0xc9, 0x10, 0x79, 0xd7, 0x42, 0x8b, 0x6c, 0x41, 0x03, 0x93, 0x24, 0xca, 0x6b, 0x46, 0xb6,
-	0xb0, 0x3e, 0x81, 0xd6, 0x7f, 0xf6, 0xa2, 0xf5, 0x87, 0x06, 0xdd, 0xbb, 0x69, 0xea, 0x1f, 0x17,
-	0xe1, 0xb2, 0x05, 0x8d, 0x2c, 0xa3, 0xb3, 0xca, 0x95, 0x2d, 0xc8, 0x08, 0xda, 0x32, 0x21, 0x15,
-	0xea, 0x55, 0xe8, 0xb5, 0x85, 0x47, 0x26, 0x69, 0x3d, 0x33, 0x8d, 0x27, 0x69, 0xa5, 0x27, 0x34,
-	0xce, 0xec, 0x09, 0x4d, 0xa5, 0x27, 0x5c, 0x01, 0x43, 0x6c, 0x0a, 0x23, 0x0f, 0x65, 0xb3, 0x68,
-	0x71, 0xe0, 0xcb, 0xc8, 0x43, 0xeb, 0x57, 0x0d, 0x7a, 0xf9, 0x6b, 0xa4, 0xe7, 0xfb, 0x50, 0x3b,
-	0x2a, 0xd8, 0xe7, 0x9f, 0x39, 0x47, 0xfa, 0x59, 0x1c, 0x2d, 0xf5, 0xc1, 0x82, 0x91, 0xba, 0xca,
-	0x48, 0xe1, 0x8c, 0x86, 0xe2, 0x0c, 0x6e, 0x32, 0x9d, 0xb2, 0xef, 0x72, 0x93, 0xf9, 0xb7, 0x75,
-	0x0c, 0x83, 0x03, 0x46, 0x99, 0x9f, 0x32, 0xdf, 0x4d, 0x73, 0x9a, 0x2b, 0x84, 0x6a, 0xaf, 0x23,
-	0x54, 0x3f, 0x8b, 0xd0, 0x5a, 0x41, 0xa8, 0xf5, 0xbb, 0x06, 0x44, 0xbd, 0x49, 0x52, 0xf0, 0x3f,
-	0x5c, 0xc5, 0x29, 0x63, 0x11, 0xa3, 0x81, 0x23, 0x1a, 0x90, 0x6c, 0x23, 0x02, 0xe1, 0x3d, 0x8e,
-	0x7b, 0x69, 0x9a, 0xa2, 0x97, 0x49, 0xb3, 0x1e, 0xd2, 0xe2, 0x80, 0x10, 0x96, 0x5b, 0x50, 0xb3,
-	0xd2, 0x82, 0xac, 0xbb, 0xd0, 0x3e, 0x60, 0x51, 0x42, 0x8f, 0xf1, 0xd9, 0x3c, 0x7e, 0x13, 0xeb,
-	0xa5, 0x75, 0xfa, 0x82, 0x88, 0x11, 0xc0, 0xee, 0xc2, 0xfa, 0x55, 0x05, 0xf0, 0x12, 0x5c, 0x58,
-	0x68, 0xf0, 0x7a, 0x29, 0xfd, 0x62, 0x3d, 0x85, 0x8b, 0x55, 0x81, 0xa4, 0xf1, 0x63, 0x68, 0x2f,
-	0x28, 0xc9, 0x6b, 0xc7, 0x05, 0x25, 0x65, 0x17, 0xfb, 0x6c, 0x55, 0xd3, 0xfa, 0x00, 0x2e, 0x2d,
-	0x44, 0xf7, 0x45, 0x11, 0x3c, 0xaf, 0x36, 0x0f, 0xc1, 0x5c, 0x56, 0xcf, 0x6c, 0xb0, 0x7e, 0xd1,
-	0xa1, 0x73, 0x5f, 0x46, 0x3b, 0x1f, 0x10, 0x94, 0x91, 0xc0, 0x10, 0x23, 0xc1, 0x0d, 0xe8, 0x94,
-	0xe6, 0xb5, 0x6c, 0x34, 0x68, 0xcf, 0x94, 0x61, 0x6d, 0xd5, 0x58, 0x57, 0x13, 0x6a, 0xd5, 0xb1,
-	0xee, 0x5d, 0x18, 0x1c, 0x25, 0x88, 0xcb, 0x13, 0x60, 0xdd, 0xde, 0xe0, 0x02, 0x55, 0x77, 0x1b,
-	0x36, 0xa9, 0xcb, 0xfc, 0x59, 0x45, 0x3b, 0xf3, 0xfd, 0x20, 0x13, 0xa9, 0xfa, 0x0f, 0x0a, 0x43,
-	0xfd, 0xf0, 0x28, 0x4a, 0xcd, 0xe6, 0x9b, 0x4f, 0x70, 0xf2, 0x35, 0x5c, 0x92, 0x5a, 0x3f, 0xea,
-	0xd0, 0xb2, 0xa9, 0x7b, 0xf2, 0x76, 0xb3, 0x71, 0x07, 0x36, 0x8a, 0xaa, 0x56, 0x22, 0xe4, 0x92,
-	0x42, 0x88, 0xea, 0x78, 0xbb, 0xeb, 0x29, 0xab, 0xd4, 0xfa, 0x47, 0x83, 0xde, 0xfd, 0xa2, 0x72,
-	0xbe, 0xdd, 0x64, 0xec, 0x00, 0xf0, 0x52, 0x5f, 0xe2, 0x41, 0x6d, 0x8d, 0xb9, 0xbb, 0x6d, 0x23,
-	0x91, 0x5f, 0xa9, 0xf5, 0xb3, 0x0e, 0x9d, 0x67, 0x51, 0x1c, 0x05, 0xd1, 0xf1, 0xfc, 0xed, 0x7e,
-	0xfd, 0x1e, 0x0c, 0x94, 0xae, 0x58, 0x22, 0xe1, 0x72, 0x25, 0x18, 0x16, 0xce, 0xb6, 0x37, 0xbc,
-	0xd2, 0x3a, 0xb5, 0x36, 0x61, 0x20, 0x27, 0x3c, 0xa5, 0xb8, 0xd9, 0x40, 0x54, 0x50, 0x16, 0xb6,
-	0x4f, 0xa1, 0xcb, 0x24, 0x75, 0xe2, 0x3a, 0x39, 0xe3, 0xaa, 0xa1, 0xa7, 0x52, 0x6b, 0x77, 0x98,
-	0xb2, 0xda, 0xf9, 0xa9, 0x01, 0xeb, 0x07, 0x48, 0x5f, 0x22, 0x7a, 0xe4, 0x21, 0x74, 0x0f, 0x30,
-	0xf4, 0x16, 0xbf, 0x42, 0xb7, 0x94, 0x33, 0x0a, 0x74, 0xf8, 0xce, 0x2a, 0xb4, 0xa8, 0x71, 0x6b,
-	0x63, 0xed, 0xb6, 0x46, 0x9e, 0x40, 0xf7, 0x11, 0x62, 0xbc, 0x1b, 0x85, 0x21, 0xba, 0x0c, 0x3d,
-	0x72, 0x4d, 0xad, 0xb4, 0xcb, 0x63, 0xee, 0xf0, 0xf2, 0x52, 0xe9, 0xc8, 0xa7, 0x22, 0x79, 0xe2,
-	0x53, 0xe8, 0xa8, 0xd3, 0x5d, 0xe9, 0xc0, 0x15, 0xb3, 0xe8, 0xf0, 0xfa, 0x6b, 0xc6, 0x42, 0x6b,
-	0x8d, 0xdc, 0x81, 0x66, 0x36, 0x6e, 0x10, 0x53, 0x51, 0x2e, 0xcd, 0x53, 0x25, 0xbb, 0xca, 0xb3,
-	0x89, 0xb5, 0x46, 0x1e, 0x01, 0x2c, 0x1a, 0x36, 0x51, 0x79, 0x59, 0x9a, 0x18, 0x86, 0x57, 0xcf,
-	0x90, 0x16, 0x87, 0x7d, 0x05, 0xbd, 0x72, 0xeb, 0x22, 0xa3, 0x95, 0xdd, 0x49, 0x89, 0x88, 0xe1,
-	0x8d, 0x73, 0x34, 0x8a, 0x83, 0xbf, 0x81, 0x7e, 0xb5, 0x23, 0x11, 0x6b, 0xe5, 0xc6, 0x52, 0x77,
-	0x1b, 0xde, 0x3c, 0x57, 0x47, 0x25, 0x61, 0x11, 0x95, 0x25, 0x12, 0x96, 0x22, 0xb8, 0x44, 0xc2,
-	0x72, 0x28, 0x5b, 0x6b, 0x87, 0x4d, 0xf1, 0xbf, 0xc8, 0x47, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff,
-	0x88, 0xac, 0x76, 0x9c, 0x27, 0x11, 0x00, 0x00,
+	// 1457 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x58, 0xcd, 0x6e, 0xdb, 0x46,
+	0x10, 0x36, 0x29, 0x59, 0x96, 0x46, 0x96, 0x2c, 0xad, 0x9d, 0x84, 0x51, 0x9a, 0x44, 0xd9, 0x5c,
+	0x94, 0xfe, 0x18, 0xa9, 0x7b, 0xe8, 0xa1, 0x2d, 0x82, 0xc4, 0x71, 0x50, 0x23, 0x6e, 0x93, 0x50,
+	0x49, 0x0a, 0x14, 0x28, 0xd8, 0x35, 0xb9, 0x76, 0x08, 0x53, 0x24, 0x4b, 0xae, 0x1c, 0x2b, 0x97,
+	0x5e, 0x7a, 0x2c, 0xd2, 0x43, 0xdf, 0xa7, 0x97, 0x1e, 0xf3, 0x30, 0x05, 0x7a, 0x2f, 0x50, 0xec,
+	0x0f, 0xc9, 0x25, 0x25, 0xdb, 0x49, 0x81, 0x1e, 0x72, 0xdb, 0x9d, 0x99, 0x9d, 0x9d, 0xfd, 0x66,
+	0xf8, 0xcd, 0x48, 0xb0, 0x3a, 0x21, 0x29, 0xa3, 0xc9, 0x66, 0x9c, 0x44, 0x2c, 0x42, 0x2d, 0xb9,
+	0x73, 0xe2, 0x7d, 0xfc, 0xa6, 0x06, 0xad, 0xaf, 0x29, 0x49, 0xd8, 0x3e, 0x25, 0x0c, 0x75, 0xc1,
+	0xf4, 0x63, 0xcb, 0x18, 0x1a, 0xa3, 0x96, 0x6d, 0xfa, 0x31, 0x42, 0x50, 0x8f, 0xa3, 0x84, 0x59,
+	0xe6, 0xd0, 0x18, 0x75, 0x6c, 0xb1, 0x46, 0x57, 0x01, 0xe2, 0xe9, 0x7e, 0xe0, 0xbb, 0xce, 0x34,
+	0x09, 0xac, 0x9a, 0xb0, 0x6d, 0x49, 0xc9, 0xb3, 0x24, 0x40, 0x23, 0xe8, 0x4d, 0xc8, 0x89, 0x73,
+	0x1c, 0x05, 0xd3, 0x09, 0x75, 0xdc, 0x68, 0x1a, 0x32, 0xab, 0x2e, 0x8e, 0x77, 0x27, 0xe4, 0xe4,
+	0xb9, 0x10, 0x6f, 0x73, 0x29, 0x1a, 0xf2, 0xa8, 0x4e, 0x9c, 0x03, 0x3f, 0xa0, 0xce, 0x11, 0x9d,
+	0x59, 0xcb, 0x43, 0x63, 0x54, 0xb7, 0x61, 0x42, 0x4e, 0x1e, 0xf8, 0x01, 0x7d, 0x48, 0x67, 0xe8,
+	0x3a, 0xb4, 0x3d, 0xc2, 0x88, 0xe3, 0xd2, 0x90, 0xd1, 0xc4, 0x6a, 0x88, 0xbb, 0x80, 0x8b, 0xb6,
+	0x85, 0x84, 0xc7, 0x97, 0x10, 0xf7, 0xc8, 0x5a, 0x11, 0x1a, 0xb1, 0xe6, 0xf1, 0x11, 0x6f, 0xe2,
+	0x87, 0x8e, 0x88, 0xbc, 0x29, 0xae, 0x6e, 0x09, 0xc9, 0x63, 0x1e, 0xfe, 0x57, 0xb0, 0x22, 0x63,
+	0x4b, 0xad, 0xd6, 0xb0, 0x36, 0x6a, 0x6f, 0xdd, 0xdc, 0xcc, 0xd1, 0xd8, 0x94, 0xe1, 0xed, 0x86,
+	0x07, 0x51, 0x32, 0x21, 0xcc, 0x8f, 0xc2, 0x6f, 0x68, 0x9a, 0x92, 0x43, 0x6a, 0x67, 0x67, 0xd0,
+	0x2e, 0xb4, 0x43, 0xfa, 0xd2, 0xc9, 0x5c, 0x80, 0x70, 0x31, 0x9a, 0x73, 0x31, 0x7e, 0x11, 0x25,
+	0x6c, 0x81, 0x1f, 0x08, 0xe9, 0xcb, 0xe7, 0xca, 0xd5, 0x13, 0x58, 0xf3, 0x68, 0x40, 0x19, 0xf5,
+	0x72, 0x77, 0xed, 0x77, 0x74, 0xd7, 0x55, 0x0e, 0x94, 0x4b, 0xfc, 0x0c, 0xfa, 0x79, 0x32, 0x6d,
+	0x9a, 0xc6, 0x51, 0x98, 0x52, 0x34, 0x82, 0x35, 0xe9, 0x7f, 0xec, 0xbf, 0xa2, 0x7b, 0xfe, 0xc4,
+	0x67, 0x22, 0xc3, 0x75, 0xbb, 0x2a, 0x46, 0x17, 0xa1, 0x11, 0x50, 0xe2, 0xd1, 0x44, 0xa5, 0x55,
+	0xed, 0xf0, 0x5f, 0x26, 0x58, 0xa7, 0x41, 0x23, 0x6a, 0xc6, 0x13, 0x1e, 0x3b, 0xb6, 0xe9, 0x7b,
+	0x3c, 0x27, 0xa9, 0xff, 0x8a, 0x8a, 0x9a, 0xa9, 0xdb, 0x62, 0x8d, 0xae, 0x01, 0xb8, 0x51, 0x10,
+	0x50, 0x97, 0x1f, 0x54, 0xce, 0x35, 0x09, 0xcf, 0x99, 0x28, 0x83, 0xa2, 0x5c, 0xea, 0x76, 0x8b,
+	0x4b, 0x64, 0xa5, 0xdc, 0x80, 0x55, 0xf9, 0x50, 0x65, 0x20, 0x2b, 0xa5, 0x2d, 0x65, 0xd2, 0xe4,
+	0x63, 0x40, 0x19, 0x98, 0xfb, 0xb3, 0xdc, 0xb0, 0x21, 0x0c, 0x7b, 0x4a, 0x73, 0x6f, 0x96, 0x59,
+	0x5f, 0x81, 0x56, 0x42, 0x89, 0xe7, 0x44, 0x61, 0x30, 0x13, 0xc5, 0xd3, 0xb4, 0x9b, 0x5c, 0xf0,
+	0x28, 0x0c, 0x66, 0xe8, 0x23, 0xe8, 0x27, 0x34, 0x0e, 0x7c, 0x97, 0x38, 0x71, 0x40, 0x5c, 0x3a,
+	0xa1, 0x61, 0x56, 0x47, 0x3d, 0xa5, 0x78, 0x9c, 0xc9, 0x91, 0x05, 0x2b, 0xc7, 0x34, 0x49, 0xf9,
+	0xb3, 0x5a, 0xc2, 0x24, 0xdb, 0xa2, 0x1e, 0xd4, 0x18, 0x0b, 0x2c, 0x10, 0x52, 0xbe, 0x44, 0xb7,
+	0xa0, 0xe7, 0x46, 0x93, 0x98, 0xb8, 0xcc, 0x49, 0xe8, 0xb1, 0x2f, 0x0e, 0xb5, 0x85, 0x7a, 0x4d,
+	0xc9, 0x6d, 0x25, 0xc6, 0xaf, 0x0d, 0xb8, 0x7a, 0x66, 0xea, 0xe7, 0x60, 0x3f, 0x0f, 0xe2, 0x77,
+	0x7a, 0xd5, 0x5c, 0xec, 0x78, 0x05, 0x96, 0x77, 0x26, 0x31, 0x9b, 0xe1, 0x3f, 0x0c, 0x58, 0x1b,
+	0x4f, 0x63, 0x9a, 0xdc, 0x0b, 0x22, 0xf7, 0x68, 0xe7, 0x84, 0x25, 0x04, 0x3d, 0x82, 0x2e, 0x4d,
+	0x48, 0x3a, 0x4d, 0x38, 0xee, 0x9e, 0x1f, 0x1e, 0x8a, 0xb8, 0xca, 0x85, 0x5c, 0x39, 0xb3, 0xb9,
+	0x23, 0x0f, 0x6c, 0x0b, 0x7b, 0xbb, 0x43, 0xf5, 0xed, 0xe0, 0x7b, 0xe8, 0x94, 0xf4, 0xbc, 0xa8,
+	0xf8, 0x67, 0xaf, 0xde, 0x2b, 0xd6, 0xbc, 0x5a, 0x63, 0x92, 0xf8, 0x6c, 0xa6, 0xe8, 0x49, 0xed,
+	0x78, 0x31, 0x29, 0xf6, 0xf1, 0xbd, 0xd4, 0xaa, 0x0d, 0x6b, 0x9c, 0x00, 0xa4, 0x64, 0xd7, 0x4b,
+	0xf1, 0x2d, 0x58, 0xdf, 0x0e, 0x7c, 0x1a, 0xb2, 0x3d, 0x3f, 0x65, 0x34, 0xb4, 0xe9, 0x4f, 0x53,
+	0x9a, 0x32, 0x7e, 0x43, 0x48, 0x26, 0x54, 0x91, 0x9f, 0x58, 0xe3, 0x9f, 0xa1, 0x2b, 0x93, 0xb0,
+	0x17, 0xb9, 0x02, 0x7c, 0x0e, 0x0c, 0x67, 0x3d, 0x69, 0xc4, 0x97, 0x15, 0x3a, 0x34, 0xab, 0x74,
+	0x78, 0x19, 0x9a, 0x82, 0x2f, 0x8a, 0x50, 0x56, 0x38, 0x05, 0xf8, 0x5e, 0x5a, 0x54, 0xb5, 0x27,
+	0xd5, 0x75, 0xa1, 0x6e, 0x67, 0x9f, 0xb4, 0xef, 0xa5, 0xf8, 0x29, 0xac, 0xef, 0x45, 0xd1, 0xd1,
+	0x34, 0x96, 0x61, 0x64, 0xb1, 0x96, 0x5f, 0x68, 0x0c, 0x6b, 0xfc, 0xce, 0xfc, 0x85, 0x95, 0x52,
+	0x30, 0xab, 0xa5, 0x80, 0xff, 0x36, 0x60, 0xa3, 0xec, 0x56, 0x31, 0xc5, 0x8f, 0xb0, 0x9e, 0xfb,
+	0x75, 0x02, 0xf5, 0x66, 0x79, 0x41, 0x7b, 0xeb, 0xb6, 0x96, 0xcc, 0x45, 0xa7, 0x33, 0xf2, 0xf4,
+	0x32, 0xb0, 0xec, 0xfe, 0x71, 0x45, 0x92, 0x0e, 0x4e, 0xa0, 0x57, 0x35, 0xe3, 0x1f, 0x63, 0x7e,
+	0xab, 0x42, 0xb6, 0x99, 0x9d, 0x44, 0x9f, 0x42, 0xab, 0x08, 0xc4, 0x14, 0x81, 0xac, 0x97, 0x02,
+	0x51, 0x77, 0x15, 0x56, 0x68, 0x03, 0x96, 0x69, 0x92, 0x44, 0x19, 0x89, 0xc9, 0x0d, 0xfe, 0x02,
+	0x9a, 0xff, 0x39, 0x8b, 0xf8, 0x8d, 0x01, 0x9d, 0xbb, 0x69, 0xea, 0x1f, 0xe6, 0xe5, 0xb2, 0x01,
+	0xcb, 0x92, 0x62, 0x24, 0x95, 0xca, 0x0d, 0x1a, 0x42, 0x5b, 0x7d, 0x4b, 0x1a, 0xf4, 0xba, 0xe8,
+	0xdc, 0xcf, 0x54, 0x7d, 0x79, 0x75, 0x19, 0x1a, 0x67, 0x8d, 0x4a, 0x13, 0x5c, 0x3e, 0xb5, 0x09,
+	0x36, 0xb4, 0x26, 0x78, 0x05, 0x5a, 0xe2, 0x50, 0x18, 0x79, 0x54, 0x75, 0xc7, 0x26, 0x17, 0x7c,
+	0x1b, 0x79, 0x14, 0xff, 0x6e, 0x40, 0x37, 0x7b, 0x8d, 0xca, 0x7c, 0x0f, 0x6a, 0x07, 0x39, 0xfa,
+	0x7c, 0x99, 0x61, 0x64, 0x9e, 0x86, 0xd1, 0x5c, 0xe3, 0xcf, 0x11, 0xa9, 0xeb, 0x88, 0xe4, 0xc9,
+	0x58, 0xd6, 0x92, 0xc1, 0x43, 0x26, 0x53, 0xf6, 0x22, 0x0b, 0x99, 0xaf, 0xf1, 0x21, 0xf4, 0xc7,
+	0x8c, 0x30, 0x3f, 0x65, 0xbe, 0x9b, 0x66, 0x30, 0x57, 0x00, 0x35, 0xce, 0x03, 0xd4, 0x3c, 0x0d,
+	0xd0, 0x5a, 0x0e, 0x28, 0xfe, 0xd3, 0x00, 0xa4, 0xdf, 0xa4, 0x20, 0xf8, 0x1f, 0xae, 0xe2, 0x90,
+	0xb1, 0x88, 0x91, 0xc0, 0x11, 0x1d, 0x51, 0xf5, 0x35, 0x21, 0xe1, 0x4d, 0x97, 0x67, 0x69, 0x9a,
+	0x52, 0x4f, 0x6a, 0x65, 0x53, 0x6b, 0x72, 0x81, 0x50, 0x96, 0x7b, 0x62, 0xa3, 0xd2, 0x13, 0xf1,
+	0x5d, 0x68, 0x8f, 0x59, 0x94, 0x90, 0x43, 0xfa, 0x74, 0x16, 0xbf, 0x4d, 0xf4, 0x2a, 0x3a, 0xb3,
+	0x00, 0x62, 0x08, 0xb0, 0x5d, 0x44, 0xbf, 0x88, 0x00, 0x2f, 0xc1, 0x85, 0xc2, 0x82, 0xf3, 0xa5,
+	0xca, 0x0b, 0x7e, 0x02, 0x17, 0xab, 0x0a, 0x05, 0xe3, 0xe7, 0xd0, 0x2e, 0x20, 0xc9, 0xb8, 0xe3,
+	0x82, 0xf6, 0xc9, 0x16, 0xe7, 0x6c, 0xdd, 0x12, 0x7f, 0x02, 0x97, 0x0a, 0xd5, 0x7d, 0x41, 0x82,
+	0x67, 0x71, 0xf3, 0x00, 0xac, 0x79, 0x73, 0x19, 0x03, 0xfe, 0xcd, 0x84, 0xd5, 0xfb, 0xaa, 0xda,
+	0x79, 0xeb, 0xd4, 0x9a, 0x65, 0x4b, 0x34, 0xcb, 0x1b, 0xb0, 0x5a, 0x1a, 0x50, 0xe5, 0xac, 0xd2,
+	0x3e, 0xd6, 0xa6, 0xd3, 0x45, 0x73, 0x6c, 0x4d, 0x98, 0x55, 0xe7, 0xd8, 0x0f, 0xa1, 0x7f, 0x90,
+	0x50, 0x3a, 0x3f, 0xf2, 0xd6, 0xed, 0x35, 0xae, 0xd0, 0x6d, 0x37, 0x61, 0x9d, 0xb8, 0xcc, 0x3f,
+	0xae, 0x58, 0xcb, 0xdc, 0xf7, 0xa5, 0x4a, 0xb7, 0x7f, 0x90, 0x07, 0xea, 0x87, 0x07, 0x51, 0x6a,
+	0x35, 0xde, 0x7e, 0x64, 0x55, 0xaf, 0xe1, 0x9a, 0x14, 0xff, 0x62, 0x42, 0xd3, 0x26, 0xee, 0xd1,
+	0xfb, 0x8d, 0xc6, 0x1d, 0x58, 0xcb, 0x59, 0xad, 0x04, 0xc8, 0x25, 0x0d, 0x10, 0x3d, 0xf1, 0x76,
+	0xc7, 0xd3, 0x76, 0x29, 0xfe, 0xc7, 0x80, 0xee, 0xfd, 0x9c, 0x39, 0xdf, 0x6f, 0x30, 0xb6, 0x00,
+	0x38, 0xd5, 0x97, 0x70, 0xd0, 0x5b, 0x63, 0x96, 0x6e, 0xbb, 0x95, 0xa8, 0x55, 0x8a, 0x5f, 0x9b,
+	0xb0, 0xfa, 0x34, 0x8a, 0xa3, 0x20, 0x3a, 0x9c, 0xbd, 0xdf, 0xaf, 0xdf, 0x81, 0xbe, 0xd6, 0x15,
+	0x4b, 0x20, 0x5c, 0xae, 0x14, 0x43, 0x91, 0x6c, 0x7b, 0xcd, 0x2b, 0xed, 0x53, 0xbc, 0x0e, 0x7d,
+	0x35, 0xe1, 0x69, 0xe4, 0x66, 0x03, 0xd2, 0x85, 0x8a, 0xd8, 0xbe, 0x84, 0x0e, 0x53, 0xd0, 0x89,
+	0xeb, 0xd4, 0x8c, 0xab, 0x97, 0x9e, 0x0e, 0xad, 0xbd, 0xca, 0xb4, 0xdd, 0xd6, 0xaf, 0xcb, 0xb0,
+	0x32, 0xa6, 0xe4, 0x25, 0xa5, 0x1e, 0xda, 0x85, 0xce, 0x98, 0x86, 0x5e, 0xf1, 0xb3, 0x7b, 0x43,
+	0xf3, 0x91, 0x4b, 0x07, 0x1f, 0x2c, 0x92, 0xe6, 0x1c, 0xb7, 0x34, 0x32, 0x6e, 0x1b, 0xe8, 0x31,
+	0x74, 0x1e, 0x52, 0x1a, 0x6f, 0x47, 0x61, 0x48, 0x5d, 0x46, 0x3d, 0x74, 0x4d, 0x67, 0xda, 0xf9,
+	0x31, 0x77, 0x70, 0x79, 0x8e, 0x3a, 0xb2, 0xa9, 0x48, 0x79, 0x7c, 0x02, 0xab, 0xfa, 0x74, 0x57,
+	0x72, 0xb8, 0x60, 0x16, 0x1d, 0x5c, 0x3f, 0x67, 0x2c, 0xc4, 0x4b, 0xe8, 0x0e, 0x34, 0xe4, 0xb8,
+	0x81, 0x2c, 0xcd, 0xb8, 0x34, 0x4f, 0x95, 0xe2, 0x2a, 0xcf, 0x26, 0x78, 0x09, 0x3d, 0x04, 0x28,
+	0x1a, 0x36, 0xd2, 0x71, 0x99, 0x9b, 0x18, 0x06, 0x57, 0x4f, 0xd1, 0xe6, 0xce, 0xbe, 0x83, 0x6e,
+	0xb9, 0x75, 0xa1, 0xe1, 0xc2, 0xee, 0xa4, 0x55, 0xc4, 0xe0, 0xc6, 0x19, 0x16, 0xb9, 0xe3, 0x1f,
+	0xa0, 0x57, 0xed, 0x48, 0x08, 0x2f, 0x3c, 0x58, 0xea, 0x6e, 0x83, 0x9b, 0x67, 0xda, 0xe8, 0x20,
+	0x14, 0x55, 0x59, 0x02, 0x61, 0xae, 0x82, 0x4b, 0x20, 0xcc, 0x97, 0x32, 0x5e, 0xda, 0x6f, 0x88,
+	0x3f, 0x82, 0x3e, 0xfb, 0x37, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x41, 0x9f, 0x9c, 0x18, 0x12, 0x00,
+	0x00,
 }

weed/pb/volume_server.proto

@@ -42,7 +42,9 @@ service VolumeServer {
     rpc CopyFile (CopyFileRequest) returns (stream CopyFileResponse) {
     }
 
-    rpc VolumeTail (VolumeTailRequest) returns (stream VolumeTailResponse) {
+    rpc VolumeTailSender (VolumeTailSenderRequest) returns (stream VolumeTailSenderResponse) {
+    }
+    rpc VolumeTailReceiver (VolumeTailReceiverRequest) returns (VolumeTailReceiverResponse) {
     }
 
 }
@@ -169,17 +171,26 @@ message CopyFileResponse {
     bytes file_content = 1;
 }
 
-message VolumeTailRequest {
+message VolumeTailSenderRequest {
     uint32 volume_id = 1;
     uint64 since_ns = 2;
     uint32 drainingSeconds = 3;
 }
-message VolumeTailResponse {
+message VolumeTailSenderResponse {
     bytes needle_header = 1;
     bytes needle_body = 2;
     bool is_last_chunk = 3;
 }
 
+message VolumeTailReceiverRequest {
+    uint32 volume_id = 1;
+    uint64 since_ns = 2;
+    uint32 drainingSeconds = 3;
+    string source_volume_server = 4;
+}
+message VolumeTailReceiverResponse {
+}
+
 message ReadVolumeFileStatusRequest {
     uint32 volume_id = 1;
 }
@@ -191,6 +202,7 @@ message ReadVolumeFileStatusResponse {
     uint64 dat_file_size = 5;
     uint64 file_count = 6;
     uint32 compaction_revision = 7;
+    string collection = 8;
 }
 
 message DiskStatus {

weed/pb/volume_server_pb/volume_server.pb.go

@@ -39,8 +39,10 @@ It has these top-level messages:
 	VolumeCopyResponse
 	CopyFileRequest
 	CopyFileResponse
-	VolumeTailRequest
-	VolumeTailResponse
+	VolumeTailSenderRequest
+	VolumeTailSenderResponse
+	VolumeTailReceiverRequest
+	VolumeTailReceiverResponse
 	ReadVolumeFileStatusRequest
 	ReadVolumeFileStatusResponse
 	DiskStatus
@@ -660,70 +662,118 @@ func (m *CopyFileResponse) GetFileContent() []byte {
 	return nil
 }
 
-type VolumeTailRequest struct {
+type VolumeTailSenderRequest struct {
 	VolumeId        uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
 	SinceNs         uint64 `protobuf:"varint,2,opt,name=since_ns,json=sinceNs" json:"since_ns,omitempty"`
 	DrainingSeconds uint32 `protobuf:"varint,3,opt,name=drainingSeconds" json:"drainingSeconds,omitempty"`
 }
 
-func (m *VolumeTailRequest) Reset()                    { *m = VolumeTailRequest{} }
-func (m *VolumeTailRequest) String() string            { return proto.CompactTextString(m) }
-func (*VolumeTailRequest) ProtoMessage()               {}
-func (*VolumeTailRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
+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{30} }
 
-func (m *VolumeTailRequest) GetVolumeId() uint32 {
+func (m *VolumeTailSenderRequest) GetVolumeId() uint32 {
 	if m != nil {
 		return m.VolumeId
 	}
 	return 0
 }
 
-func (m *VolumeTailRequest) GetSinceNs() uint64 {
+func (m *VolumeTailSenderRequest) GetSinceNs() uint64 {
 	if m != nil {
 		return m.SinceNs
 	}
 	return 0
 }
 
-func (m *VolumeTailRequest) GetDrainingSeconds() uint32 {
+func (m *VolumeTailSenderRequest) GetDrainingSeconds() uint32 {
 	if m != nil {
 		return m.DrainingSeconds
 	}
 	return 0
 }
 
-type VolumeTailResponse struct {
+type VolumeTailSenderResponse struct {
 	NeedleHeader []byte `protobuf:"bytes,1,opt,name=needle_header,json=needleHeader,proto3" json:"needle_header,omitempty"`
 	NeedleBody   []byte `protobuf:"bytes,2,opt,name=needle_body,json=needleBody,proto3" json:"needle_body,omitempty"`
 	IsLastChunk  bool   `protobuf:"varint,3,opt,name=is_last_chunk,json=isLastChunk" json:"is_last_chunk,omitempty"`
 }
 
-func (m *VolumeTailResponse) Reset()                    { *m = VolumeTailResponse{} }
-func (m *VolumeTailResponse) String() string            { return proto.CompactTextString(m) }
-func (*VolumeTailResponse) ProtoMessage()               {}
-func (*VolumeTailResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
+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{31} }
 
-func (m *VolumeTailResponse) GetNeedleHeader() []byte {
+func (m *VolumeTailSenderResponse) GetNeedleHeader() []byte {
 	if m != nil {
 		return m.NeedleHeader
 	}
 	return nil
 }
 
-func (m *VolumeTailResponse) GetNeedleBody() []byte {
+func (m *VolumeTailSenderResponse) GetNeedleBody() []byte {
 	if m != nil {
 		return m.NeedleBody
 	}
 	return nil
 }
 
-func (m *VolumeTailResponse) GetIsLastChunk() bool {
+func (m *VolumeTailSenderResponse) GetIsLastChunk() bool {
 	if m != nil {
 		return m.IsLastChunk
 	}
 	return false
 }
 
+type VolumeTailReceiverRequest struct {
+	VolumeId           uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
+	SinceNs            uint64 `protobuf:"varint,2,opt,name=since_ns,json=sinceNs" json:"since_ns,omitempty"`
+	DrainingSeconds    uint32 `protobuf:"varint,3,opt,name=drainingSeconds" json:"drainingSeconds,omitempty"`
+	SourceVolumeServer string `protobuf:"bytes,4,opt,name=source_volume_server,json=sourceVolumeServer" json:"source_volume_server,omitempty"`
+}
+
+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{32} }
+
+func (m *VolumeTailReceiverRequest) GetVolumeId() uint32 {
+	if m != nil {
+		return m.VolumeId
+	}
+	return 0
+}
+
+func (m *VolumeTailReceiverRequest) GetSinceNs() uint64 {
+	if m != nil {
+		return m.SinceNs
+	}
+	return 0
+}
+
+func (m *VolumeTailReceiverRequest) GetDrainingSeconds() uint32 {
+	if m != nil {
+		return m.DrainingSeconds
+	}
+	return 0
+}
+
+func (m *VolumeTailReceiverRequest) GetSourceVolumeServer() string {
+	if m != nil {
+		return m.SourceVolumeServer
+	}
+	return ""
+}
+
+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{33} }
+
 type ReadVolumeFileStatusRequest struct {
 	VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId" json:"volume_id,omitempty"`
 }
@@ -731,7 +781,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{32} }
+func (*ReadVolumeFileStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} }
 
 func (m *ReadVolumeFileStatusRequest) GetVolumeId() uint32 {
 	if m != nil {
@@ -748,12 +798,13 @@ type ReadVolumeFileStatusResponse struct {
 	DatFileSize             uint64 `protobuf:"varint,5,opt,name=dat_file_size,json=datFileSize" json:"dat_file_size,omitempty"`
 	FileCount               uint64 `protobuf:"varint,6,opt,name=file_count,json=fileCount" json:"file_count,omitempty"`
 	CompactionRevision      uint32 `protobuf:"varint,7,opt,name=compaction_revision,json=compactionRevision" json:"compaction_revision,omitempty"`
+	Collection              string `protobuf:"bytes,8,opt,name=collection" json:"collection,omitempty"`
 }
 
 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{33} }
+func (*ReadVolumeFileStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} }
 
 func (m *ReadVolumeFileStatusResponse) GetVolumeId() uint32 {
 	if m != nil {
@@ -804,6 +855,13 @@ func (m *ReadVolumeFileStatusResponse) GetCompactionRevision() uint32 {
 	return 0
 }
 
+func (m *ReadVolumeFileStatusResponse) GetCollection() string {
+	if m != nil {
+		return m.Collection
+	}
+	return ""
+}
+
 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"`
@@ -814,7 +872,7 @@ type DiskStatus struct {
 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{34} }
+func (*DiskStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} }
 
 func (m *DiskStatus) GetDir() string {
 	if m != nil {
@@ -857,7 +915,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{35} }
+func (*MemStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} }
 
 func (m *MemStatus) GetGoroutines() int32 {
 	if m != nil {
@@ -939,8 +997,10 @@ func init() {
 	proto.RegisterType((*VolumeCopyResponse)(nil), "volume_server_pb.VolumeCopyResponse")
 	proto.RegisterType((*CopyFileRequest)(nil), "volume_server_pb.CopyFileRequest")
 	proto.RegisterType((*CopyFileResponse)(nil), "volume_server_pb.CopyFileResponse")
-	proto.RegisterType((*VolumeTailRequest)(nil), "volume_server_pb.VolumeTailRequest")
-	proto.RegisterType((*VolumeTailResponse)(nil), "volume_server_pb.VolumeTailResponse")
+	proto.RegisterType((*VolumeTailSenderRequest)(nil), "volume_server_pb.VolumeTailSenderRequest")
+	proto.RegisterType((*VolumeTailSenderResponse)(nil), "volume_server_pb.VolumeTailSenderResponse")
+	proto.RegisterType((*VolumeTailReceiverRequest)(nil), "volume_server_pb.VolumeTailReceiverRequest")
+	proto.RegisterType((*VolumeTailReceiverResponse)(nil), "volume_server_pb.VolumeTailReceiverResponse")
 	proto.RegisterType((*ReadVolumeFileStatusRequest)(nil), "volume_server_pb.ReadVolumeFileStatusRequest")
 	proto.RegisterType((*ReadVolumeFileStatusResponse)(nil), "volume_server_pb.ReadVolumeFileStatusResponse")
 	proto.RegisterType((*DiskStatus)(nil), "volume_server_pb.DiskStatus")
@@ -975,7 +1035,8 @@ type VolumeServerClient interface {
 	VolumeCopy(ctx context.Context, in *VolumeCopyRequest, opts ...grpc.CallOption) (*VolumeCopyResponse, error)
 	ReadVolumeFileStatus(ctx context.Context, in *ReadVolumeFileStatusRequest, opts ...grpc.CallOption) (*ReadVolumeFileStatusResponse, error)
 	CopyFile(ctx context.Context, in *CopyFileRequest, opts ...grpc.CallOption) (VolumeServer_CopyFileClient, error)
-	VolumeTail(ctx context.Context, in *VolumeTailRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTailClient, error)
+	VolumeTailSender(ctx context.Context, in *VolumeTailSenderRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTailSenderClient, error)
+	VolumeTailReceiver(ctx context.Context, in *VolumeTailReceiverRequest, opts ...grpc.CallOption) (*VolumeTailReceiverResponse, error)
 }
 
 type volumeServerClient struct {
@@ -1167,12 +1228,12 @@ func (x *volumeServerCopyFileClient) Recv() (*CopyFileResponse, error) {
 	return m, nil
 }
 
-func (c *volumeServerClient) VolumeTail(ctx context.Context, in *VolumeTailRequest, opts ...grpc.CallOption) (VolumeServer_VolumeTailClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_VolumeServer_serviceDesc.Streams[2], c.cc, "/volume_server_pb.VolumeServer/VolumeTail", opts...)
+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...)
 	if err != nil {
 		return nil, err
 	}
-	x := &volumeServerVolumeTailClient{stream}
+	x := &volumeServerVolumeTailSenderClient{stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -1182,23 +1243,32 @@ func (c *volumeServerClient) VolumeTail(ctx context.Context, in *VolumeTailReque
 	return x, nil
 }
 
-type VolumeServer_VolumeTailClient interface {
-	Recv() (*VolumeTailResponse, error)
+type VolumeServer_VolumeTailSenderClient interface {
+	Recv() (*VolumeTailSenderResponse, error)
 	grpc.ClientStream
 }
 
-type volumeServerVolumeTailClient struct {
+type volumeServerVolumeTailSenderClient struct {
 	grpc.ClientStream
 }
 
-func (x *volumeServerVolumeTailClient) Recv() (*VolumeTailResponse, error) {
-	m := new(VolumeTailResponse)
+func (x *volumeServerVolumeTailSenderClient) Recv() (*VolumeTailSenderResponse, error) {
+	m := new(VolumeTailSenderResponse)
 	if err := x.ClientStream.RecvMsg(m); err != nil {
 		return nil, err
 	}
 	return m, nil
 }
 
+func (c *volumeServerClient) VolumeTailReceiver(ctx context.Context, in *VolumeTailReceiverRequest, opts ...grpc.CallOption) (*VolumeTailReceiverResponse, error) {
+	out := new(VolumeTailReceiverResponse)
+	err := grpc.Invoke(ctx, "/volume_server_pb.VolumeServer/VolumeTailReceiver", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for VolumeServer service
 
 type VolumeServerServer interface {
@@ -1219,7 +1289,8 @@ type VolumeServerServer interface {
 	VolumeCopy(context.Context, *VolumeCopyRequest) (*VolumeCopyResponse, error)
 	ReadVolumeFileStatus(context.Context, *ReadVolumeFileStatusRequest) (*ReadVolumeFileStatusResponse, error)
 	CopyFile(*CopyFileRequest, VolumeServer_CopyFileServer) error
-	VolumeTail(*VolumeTailRequest, VolumeServer_VolumeTailServer) error
+	VolumeTailSender(*VolumeTailSenderRequest, VolumeServer_VolumeTailSenderServer) error
+	VolumeTailReceiver(context.Context, *VolumeTailReceiverRequest) (*VolumeTailReceiverResponse, error)
 }
 
 func RegisterVolumeServerServer(s *grpc.Server, srv VolumeServerServer) {
@@ -1502,27 +1573,45 @@ func (x *volumeServerCopyFileServer) Send(m *CopyFileResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-func _VolumeServer_VolumeTail_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(VolumeTailRequest)
+func _VolumeServer_VolumeTailSender_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(VolumeTailSenderRequest)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(VolumeServerServer).VolumeTail(m, &volumeServerVolumeTailServer{stream})
+	return srv.(VolumeServerServer).VolumeTailSender(m, &volumeServerVolumeTailSenderServer{stream})
 }
 
-type VolumeServer_VolumeTailServer interface {
-	Send(*VolumeTailResponse) error
+type VolumeServer_VolumeTailSenderServer interface {
+	Send(*VolumeTailSenderResponse) error
 	grpc.ServerStream
 }
 
-type volumeServerVolumeTailServer struct {
+type volumeServerVolumeTailSenderServer struct {
 	grpc.ServerStream
 }
 
-func (x *volumeServerVolumeTailServer) Send(m *VolumeTailResponse) error {
+func (x *volumeServerVolumeTailSenderServer) Send(m *VolumeTailSenderResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
+func _VolumeServer_VolumeTailReceiver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(VolumeTailReceiverRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(VolumeServerServer).VolumeTailReceiver(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/volume_server_pb.VolumeServer/VolumeTailReceiver",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(VolumeServerServer).VolumeTailReceiver(ctx, req.(*VolumeTailReceiverRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "volume_server_pb.VolumeServer",
 	HandlerType: (*VolumeServerServer)(nil),
@@ -1579,6 +1668,10 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 			MethodName: "ReadVolumeFileStatus",
 			Handler:    _VolumeServer_ReadVolumeFileStatus_Handler,
 		},
+		{
+			MethodName: "VolumeTailReceiver",
+			Handler:    _VolumeServer_VolumeTailReceiver_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -1592,8 +1685,8 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 			ServerStreams: true,
 		},
 		{
-			StreamName:    "VolumeTail",
-			Handler:       _VolumeServer_VolumeTail_Handler,
+			StreamName:    "VolumeTailSender",
+			Handler:       _VolumeServer_VolumeTailSender_Handler,
 			ServerStreams: true,
 		},
 	},
@@ -1603,92 +1696,96 @@ var _VolumeServer_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("volume_server.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 1378 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x58, 0xdb, 0x6e, 0xd4, 0x46,
-	0x18, 0x8e, 0xd9, 0xcd, 0xe9, 0xdf, 0x5d, 0x08, 0x13, 0x20, 0x8b, 0x39, 0x05, 0x43, 0x61, 0x39,
-	0x34, 0xb4, 0xa0, 0xb6, 0xb4, 0xbd, 0x68, 0x21, 0x69, 0xd5, 0x48, 0x05, 0x24, 0x07, 0x50, 0x2b,
-	0x2a, 0x59, 0x13, 0x7b, 0x92, 0x8c, 0xe2, 0xf5, 0x18, 0xcf, 0x98, 0x92, 0xaa, 0xea, 0xcb, 0x54,
-	0xbd, 0xe9, 0x45, 0x9f, 0xa1, 0x2f, 0xd0, 0x27, 0xea, 0x4d, 0x35, 0x07, 0x7b, 0xd7, 0xa7, 0xac,
-	0x29, 0x77, 0xe3, 0x6f, 0xfe, 0xf3, 0xfc, 0xf3, 0xcf, 0xb7, 0x0b, 0xab, 0x6f, 0x58, 0x98, 0x8e,
-	0x89, 0xc7, 0x49, 0xf2, 0x86, 0x24, 0x1b, 0x71, 0xc2, 0x04, 0x43, 0x2b, 0x05, 0xd0, 0x8b, 0x77,
-	0x9d, 0x7b, 0x80, 0x1e, 0x63, 0xe1, 0x1f, 0x6c, 0x91, 0x90, 0x08, 0xe2, 0x92, 0xd7, 0x29, 0xe1,
-	0x02, 0x9d, 0x87, 0xa5, 0x3d, 0x1a, 0x12, 0x8f, 0x06, 0x7c, 0x68, 0xad, 0x77, 0x46, 0xcb, 0xee,
-	0xa2, 0xfc, 0xde, 0x0e, 0xb8, 0xf3, 0x0c, 0x56, 0x0b, 0x0a, 0x3c, 0x66, 0x11, 0x27, 0xe8, 0x21,
-	0x2c, 0x26, 0x84, 0xa7, 0xa1, 0xd0, 0x0a, 0xbd, 0xfb, 0x97, 0x37, 0xca, 0xbe, 0x36, 0x72, 0x95,
-	0x34, 0x14, 0x6e, 0x26, 0xee, 0x50, 0xe8, 0x4f, 0x6f, 0xa0, 0x35, 0x58, 0x34, 0xbe, 0x87, 0xd6,
-	0xba, 0x35, 0x5a, 0x76, 0x17, 0xb4, 0x6b, 0x74, 0x0e, 0x16, 0xb8, 0xc0, 0x22, 0xe5, 0xc3, 0x13,
-	0xeb, 0xd6, 0x68, 0xde, 0x35, 0x5f, 0xe8, 0x0c, 0xcc, 0x93, 0x24, 0x61, 0xc9, 0xb0, 0xa3, 0xc4,
-	0xf5, 0x07, 0x42, 0xd0, 0xe5, 0xf4, 0x17, 0x32, 0xec, 0xae, 0x5b, 0xa3, 0x81, 0xab, 0xd6, 0xce,
-	0x22, 0xcc, 0x7f, 0x33, 0x8e, 0xc5, 0x91, 0xf3, 0x19, 0x0c, 0x5f, 0x62, 0x3f, 0x4d, 0xc7, 0x2f,
-	0x55, 0x8c, 0x9b, 0x07, 0xc4, 0x3f, 0xcc, 0x72, 0xbf, 0x00, 0xcb, 0x26, 0x72, 0x13, 0xc1, 0xc0,
-	0x5d, 0xd2, 0xc0, 0x76, 0xe0, 0x7c, 0x0d, 0xe7, 0x6b, 0x14, 0x4d, 0x0d, 0xae, 0xc1, 0x60, 0x1f,
-	0x27, 0xbb, 0x78, 0x9f, 0x78, 0x09, 0x16, 0x94, 0x29, 0x6d, 0xcb, 0xed, 0x1b, 0xd0, 0x95, 0x98,
-	0xf3, 0x0a, 0xec, 0x82, 0x05, 0x36, 0x8e, 0xb1, 0x2f, 0xda, 0x38, 0x47, 0xeb, 0xd0, 0x8b, 0x13,
-	0x82, 0xc3, 0x90, 0xf9, 0x58, 0x10, 0x55, 0x85, 0x8e, 0x3b, 0x0d, 0x39, 0x97, 0xe0, 0x42, 0xad,
-	0x71, 0x1d, 0xa0, 0xf3, 0xb0, 0x14, 0x3d, 0x1b, 0x8f, 0x69, 0x2b, 0xd7, 0xce, 0xc5, 0x4a, 0xd4,
-	0x4a, 0xd3, 0xd8, 0xfd, 0xbc, 0xb4, 0x1b, 0x12, 0x1c, 0xa5, 0x71, 0x2b, 0xc3, 0xe5, 0x88, 0x33,
-	0xd5, 0xdc, 0xf2, 0x9a, 0x6e, 0x8e, 0x4d, 0x16, 0x86, 0xc4, 0x17, 0x94, 0x45, 0x99, 0xd9, 0xcb,
-	0x00, 0x7e, 0x0e, 0x9a, 0x56, 0x99, 0x42, 0x1c, 0x1b, 0x86, 0x55, 0x55, 0x63, 0xf6, 0x4f, 0x0b,
-	0xce, 0x3e, 0x32, 0x45, 0xd3, 0x8e, 0x5b, 0x1d, 0x40, 0xd1, 0xe5, 0x89, 0xb2, 0xcb, 0xf2, 0x01,
-	0x75, 0x2a, 0x07, 0x24, 0x25, 0x12, 0x12, 0x87, 0xd4, 0xc7, 0xca, 0x44, 0x57, 0x99, 0x98, 0x86,
-	0xd0, 0x0a, 0x74, 0x84, 0x08, 0x87, 0xf3, 0x6a, 0x47, 0x2e, 0x9d, 0x21, 0x9c, 0x2b, 0xc7, 0x6a,
-	0xd2, 0xf8, 0x14, 0xd6, 0x34, 0xb2, 0x73, 0x14, 0xf9, 0x3b, 0xea, 0x36, 0xb4, 0x2a, 0xfa, 0xbf,
-	0x16, 0x0c, 0xab, 0x8a, 0xa6, 0x8b, 0xdf, 0xb7, 0x02, 0xef, 0x9a, 0x1f, 0xba, 0x02, 0x3d, 0x81,
-	0x69, 0xe8, 0xb1, 0xbd, 0x3d, 0x4e, 0xc4, 0x70, 0x61, 0xdd, 0x1a, 0x75, 0x5d, 0x90, 0xd0, 0x33,
-	0x85, 0xa0, 0x5b, 0xb0, 0xe2, 0xeb, 0x4e, 0xf6, 0x12, 0xf2, 0x86, 0x72, 0x69, 0x79, 0x51, 0x05,
-	0x76, 0xca, 0xcf, 0x3a, 0x5c, 0xc3, 0xc8, 0x81, 0x01, 0x0d, 0xde, 0x7a, 0x6a, 0x80, 0xa8, 0xeb,
-	0xbf, 0xa4, 0xac, 0xf5, 0x68, 0xf0, 0xf6, 0x5b, 0x1a, 0x92, 0x1d, 0x39, 0x05, 0x5e, 0xc2, 0x45,
-	0x9d, 0xfc, 0x76, 0xe4, 0x27, 0x64, 0x4c, 0x22, 0x81, 0xc3, 0x4d, 0x16, 0x1f, 0xb5, 0x6a, 0x81,
-	0xf3, 0xb0, 0xc4, 0x69, 0xe4, 0x13, 0x2f, 0xd2, 0x63, 0xa8, 0xeb, 0x2e, 0xaa, 0xef, 0xa7, 0xdc,
-	0x79, 0x0c, 0x97, 0x1a, 0xec, 0x9a, 0xca, 0x5e, 0x85, 0xbe, 0x0a, 0xcc, 0x67, 0x91, 0x20, 0x91,
-	0x50, 0xb6, 0xfb, 0x6e, 0x4f, 0x62, 0x9b, 0x1a, 0x72, 0x3e, 0x06, 0xa4, 0x6d, 0x3c, 0x61, 0x69,
-	0xd4, 0xee, 0x6a, 0x9e, 0x85, 0xd5, 0x82, 0x8a, 0xe9, 0x8d, 0x07, 0x70, 0x46, 0xc3, 0x2f, 0xa2,
-	0x71, 0x6b, 0x5b, 0x6b, 0x70, 0xb6, 0xa4, 0x64, 0xac, 0xdd, 0xcf, 0x9c, 0x14, 0xdf, 0x89, 0x63,
-	0x8d, 0x9d, 0xcb, 0x22, 0x28, 0x3e, 0x15, 0xce, 0x5f, 0x16, 0x9c, 0xce, 0xc6, 0x48, 0xcb, 0xaa,
-	0xbf, 0x63, 0xdb, 0x75, 0x1a, 0xdb, 0xae, 0x3b, 0x69, 0xbb, 0x11, 0xac, 0x70, 0x96, 0x26, 0x3e,
-	0xf1, 0x02, 0x2c, 0xb0, 0x17, 0xb1, 0x80, 0x98, 0xae, 0x3c, 0xa9, 0xf1, 0x2d, 0x2c, 0xf0, 0x53,
-	0x16, 0x10, 0xe7, 0xab, 0xec, 0x50, 0x0a, 0xa7, 0x79, 0x0b, 0x4e, 0x87, 0x98, 0x0b, 0x0f, 0xc7,
-	0x31, 0x89, 0x02, 0x0f, 0x0b, 0xd9, 0x12, 0x96, 0x6a, 0x89, 0x93, 0x72, 0xe3, 0x91, 0xc2, 0x1f,
-	0x89, 0xa7, 0xdc, 0xf9, 0xdb, 0x82, 0x53, 0x52, 0x57, 0xb6, 0x60, 0xcb, 0x7c, 0x7b, 0x94, 0x7b,
-	0x59, 0x27, 0xab, 0x84, 0x97, 0xdc, 0x65, 0xca, 0xb7, 0x75, 0x1b, 0x9b, 0xfd, 0x00, 0x0b, 0xbd,
-	0xdf, 0xc9, 0xf6, 0xb7, 0xb0, 0x50, 0xfb, 0xf7, 0x60, 0xd5, 0xdc, 0x0c, 0xca, 0xa2, 0xc9, 0xa5,
-	0xd1, 0x6f, 0x21, 0x9a, 0x6c, 0xe5, 0xf7, 0xe6, 0x0a, 0xf4, 0xb8, 0x60, 0x71, 0x76, 0x07, 0xe7,
-	0xf5, 0x1d, 0x94, 0x90, 0xbe, 0x83, 0xce, 0x27, 0xb0, 0x32, 0xc9, 0xa0, 0x7d, 0x3f, 0xa7, 0xd9,
-	0x51, 0x3f, 0xc7, 0x34, 0x7c, 0xcf, 0x0b, 0x86, 0x46, 0x70, 0x2a, 0x48, 0x30, 0x8d, 0x68, 0xb4,
-	0xbf, 0x43, 0x7c, 0x16, 0x05, 0x5c, 0x65, 0x3e, 0x70, 0xcb, 0xb0, 0xf3, 0x5b, 0x76, 0x62, 0xda,
-	0xed, 0xe4, 0x7d, 0x8e, 0x08, 0x09, 0x42, 0xe2, 0x1d, 0x10, 0x1c, 0x90, 0xc4, 0x04, 0xdc, 0xd7,
-	0xe0, 0x77, 0x0a, 0x93, 0x95, 0x30, 0x42, 0xbb, 0x2c, 0x38, 0x52, 0x21, 0xf4, 0x5d, 0xd0, 0xd0,
-	0x63, 0x16, 0x1c, 0xa9, 0x11, 0xc3, 0x3d, 0x75, 0xf4, 0xfe, 0x41, 0x1a, 0x1d, 0x9a, 0xea, 0xf7,
-	0x28, 0xff, 0x1e, 0x73, 0xb1, 0x29, 0x21, 0xe7, 0x0b, 0xb8, 0xe0, 0x12, 0x1c, 0xe8, 0x18, 0xd4,
-	0xe0, 0x69, 0x3f, 0x9c, 0xff, 0x39, 0x01, 0x17, 0xeb, 0x95, 0xdb, 0x0c, 0xe8, 0x2f, 0xc1, 0xce,
-	0x07, 0xa0, 0xa0, 0x63, 0xc2, 0x05, 0x1e, 0xc7, 0x1e, 0x37, 0xe5, 0xd2, 0x05, 0x5d, 0x33, 0xd3,
-	0xf0, 0x79, 0xb6, 0x6f, 0xca, 0x56, 0x9d, 0x9e, 0x9d, 0xca, 0xf4, 0x94, 0x0e, 0xb2, 0xbe, 0xab,
-	0x71, 0xd0, 0xd5, 0x0e, 0x02, 0xdd, 0x87, 0x75, 0x0e, 0x72, 0x65, 0xe5, 0x40, 0x37, 0x5a, 0xcf,
-	0xc8, 0x2b, 0x07, 0x97, 0x00, 0x4c, 0x57, 0xa5, 0x51, 0xf6, 0x1a, 0x2c, 0xeb, 0x9e, 0x4a, 0x23,
-	0xd1, 0xd4, 0xda, 0x8b, 0x4d, 0xad, 0xed, 0xfc, 0x00, 0xb0, 0x45, 0xf9, 0xa1, 0x2e, 0xa2, 0x9c,
-	0x03, 0x01, 0x4d, 0x0c, 0x5d, 0x90, 0x4b, 0x89, 0xe0, 0x30, 0x34, 0xa5, 0x91, 0x4b, 0x49, 0x1d,
-	0x53, 0x4e, 0x02, 0x93, 0xbd, 0x5a, 0x4b, 0x6c, 0x2f, 0x21, 0xc4, 0x24, 0xa8, 0xd6, 0xce, 0xef,
-	0x16, 0x2c, 0x3f, 0x21, 0x63, 0x63, 0xf9, 0x32, 0xc0, 0x3e, 0x4b, 0x58, 0x2a, 0x68, 0x44, 0xf4,
-	0x20, 0x98, 0x77, 0xa7, 0x90, 0xff, 0xef, 0x47, 0x51, 0x59, 0x12, 0xee, 0x99, 0x62, 0xa9, 0xb5,
-	0xc4, 0x0e, 0x08, 0x8e, 0x4d, 0x7d, 0xd4, 0x5a, 0x12, 0x61, 0x2e, 0xb0, 0x7f, 0xa8, 0x8a, 0xd1,
-	0x75, 0xf5, 0xc7, 0xfd, 0x3f, 0x06, 0xd0, 0x37, 0x8f, 0xbd, 0x62, 0xe2, 0xe8, 0x27, 0xe8, 0x4d,
-	0x31, 0x78, 0x74, 0xbd, 0x4a, 0xd4, 0xab, 0xbf, 0x08, 0xec, 0x0f, 0x66, 0x48, 0x99, 0xd9, 0x3e,
-	0x87, 0x22, 0x38, 0x5d, 0x61, 0xc8, 0xe8, 0x76, 0x55, 0xbb, 0x89, 0x7f, 0xdb, 0x77, 0x5a, 0xc9,
-	0xe6, 0xfe, 0x04, 0xac, 0xd6, 0x50, 0x5e, 0x74, 0x77, 0x86, 0x95, 0x02, 0xed, 0xb6, 0x3f, 0x6c,
-	0x29, 0x9d, 0x7b, 0x7d, 0x0d, 0xa8, 0xca, 0x87, 0xd1, 0x9d, 0x99, 0x66, 0x26, 0x7c, 0xdb, 0xbe,
-	0xdb, 0x4e, 0xb8, 0x31, 0x51, 0xcd, 0x94, 0x67, 0x26, 0x5a, 0xe0, 0xe2, 0x33, 0x13, 0x2d, 0xd1,
-	0xef, 0x39, 0x74, 0x08, 0x2b, 0x65, 0x16, 0x8d, 0x6e, 0x35, 0xfd, 0xb4, 0xab, 0x90, 0x74, 0xfb,
-	0x76, 0x1b, 0xd1, 0xdc, 0x19, 0x81, 0x93, 0x45, 0xa6, 0x8b, 0x6e, 0x56, 0xf5, 0x6b, 0x79, 0xbb,
-	0x3d, 0x9a, 0x2d, 0x38, 0x9d, 0x53, 0x99, 0xfd, 0xd6, 0xe5, 0xd4, 0x40, 0xad, 0xeb, 0x72, 0x6a,
-	0x22, 0xd3, 0xce, 0x1c, 0xfa, 0x35, 0xa3, 0x54, 0x25, 0x56, 0x88, 0x36, 0x9a, 0xcc, 0xd4, 0xd3,
-	0x52, 0xfb, 0x5e, 0x6b, 0xf9, 0xcc, 0xf7, 0x47, 0x96, 0xbc, 0xeb, 0x53, 0xe4, 0xb0, 0xee, 0xae,
-	0x57, 0xe9, 0x66, 0xdd, 0x5d, 0xaf, 0x63, 0x98, 0x73, 0x68, 0x17, 0x06, 0x05, 0xba, 0x88, 0x6e,
-	0x34, 0x69, 0x16, 0x49, 0xa8, 0x7d, 0x73, 0xa6, 0x5c, 0xee, 0xc3, 0xcb, 0xa6, 0x97, 0x19, 0x57,
-	0x8d, 0xc1, 0x15, 0xe7, 0xd5, 0x8d, 0x59, 0x62, 0xb9, 0x83, 0x1f, 0x01, 0x26, 0xec, 0x0e, 0x5d,
-	0x6b, 0xd2, 0x9b, 0x3e, 0x8a, 0xeb, 0xc7, 0x0b, 0xe5, 0xa6, 0x7f, 0x86, 0x33, 0x75, 0x2f, 0x39,
-	0xaa, 0xb9, 0x85, 0xc7, 0xd0, 0x05, 0x7b, 0xa3, 0xad, 0x78, 0xee, 0xf8, 0x05, 0x2c, 0x65, 0x6c,
-	0x0d, 0x5d, 0xad, 0x6a, 0x97, 0xb8, 0xa8, 0xed, 0x1c, 0x27, 0x32, 0xd5, 0x4d, 0xaf, 0xb2, 0x52,
-	0x49, 0x5a, 0xd5, 0x5c, 0xaa, 0x29, 0xae, 0xd7, 0x5c, 0xaa, 0x69, 0x66, 0x26, 0x8d, 0xef, 0x2e,
-	0xa8, 0xbf, 0xa8, 0x1e, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0x07, 0x6f, 0xca, 0x8a, 0xb9, 0x12,
-	0x00, 0x00,
+	// 1450 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x6e, 0xdc, 0xc4,
+	0x17, 0x8f, 0xbb, 0x9b, 0xec, 0xe6, 0xec, 0x26, 0x4d, 0x27, 0x69, 0xb3, 0xd9, 0x7e, 0xa5, 0x6e,
+	0xff, 0xed, 0xf6, 0xe3, 0x9f, 0x96, 0x56, 0x40, 0x81, 0x0b, 0x68, 0x13, 0x10, 0x91, 0x68, 0x2b,
+	0x39, 0x6d, 0x05, 0x02, 0xc9, 0x9a, 0xd8, 0x27, 0x89, 0x15, 0xaf, 0xed, 0x78, 0xc6, 0xa1, 0x01,
+	0x2e, 0x79, 0x13, 0xee, 0x7a, 0x01, 0xaf, 0xc0, 0x0b, 0xf1, 0x04, 0xdc, 0x20, 0xcf, 0x8c, 0xbd,
+	0xfe, 0xcc, 0xba, 0x54, 0xe2, 0x6e, 0xf6, 0xcc, 0xf9, 0xf6, 0xf9, 0x9d, 0x39, 0x67, 0x61, 0xf9,
+	0xd8, 0x77, 0xa3, 0x31, 0x9a, 0x0c, 0xc3, 0x63, 0x0c, 0x37, 0x82, 0xd0, 0xe7, 0x3e, 0x59, 0xca,
+	0x11, 0xcd, 0x60, 0x57, 0xbf, 0x0f, 0xe4, 0x29, 0xe5, 0xd6, 0xc1, 0x16, 0xba, 0xc8, 0xd1, 0xc0,
+	0xa3, 0x08, 0x19, 0x27, 0x6b, 0xd0, 0xdd, 0x73, 0x5c, 0x34, 0x1d, 0x9b, 0x0d, 0xb4, 0xf5, 0xd6,
+	0x68, 0xde, 0xe8, 0xc4, 0xbf, 0xb7, 0x6d, 0xa6, 0xbf, 0x80, 0xe5, 0x9c, 0x00, 0x0b, 0x7c, 0x8f,
+	0x21, 0x79, 0x0c, 0x9d, 0x10, 0x59, 0xe4, 0x72, 0x29, 0xd0, 0x7b, 0x78, 0x65, 0xa3, 0x68, 0x6b,
+	0x23, 0x15, 0x89, 0x5c, 0x6e, 0x24, 0xec, 0xba, 0x03, 0xfd, 0xec, 0x05, 0x59, 0x85, 0x8e, 0xb2,
+	0x3d, 0xd0, 0xd6, 0xb5, 0xd1, 0xbc, 0x31, 0x27, 0x4d, 0x93, 0x0b, 0x30, 0xc7, 0x38, 0xe5, 0x11,
+	0x1b, 0x9c, 0x59, 0xd7, 0x46, 0xb3, 0x86, 0xfa, 0x45, 0x56, 0x60, 0x16, 0xc3, 0xd0, 0x0f, 0x07,
+	0x2d, 0xc1, 0x2e, 0x7f, 0x10, 0x02, 0x6d, 0xe6, 0xfc, 0x84, 0x83, 0xf6, 0xba, 0x36, 0x5a, 0x30,
+	0xc4, 0x59, 0xef, 0xc0, 0xec, 0x97, 0xe3, 0x80, 0x9f, 0xe8, 0x1f, 0xc3, 0xe0, 0x35, 0xb5, 0xa2,
+	0x68, 0xfc, 0x5a, 0xf8, 0xb8, 0x79, 0x80, 0xd6, 0x61, 0x12, 0xfb, 0x45, 0x98, 0x57, 0x9e, 0x2b,
+	0x0f, 0x16, 0x8c, 0xae, 0x24, 0x6c, 0xdb, 0xfa, 0x17, 0xb0, 0x56, 0x21, 0xa8, 0x72, 0x70, 0x1d,
+	0x16, 0xf6, 0x69, 0xb8, 0x4b, 0xf7, 0xd1, 0x0c, 0x29, 0x77, 0x7c, 0x21, 0xad, 0x19, 0x7d, 0x45,
+	0x34, 0x62, 0x9a, 0xfe, 0x3d, 0x0c, 0x73, 0x1a, 0xfc, 0x71, 0x40, 0x2d, 0xde, 0xc4, 0x38, 0x59,
+	0x87, 0x5e, 0x10, 0x22, 0x75, 0x5d, 0xdf, 0xa2, 0x1c, 0x45, 0x16, 0x5a, 0x46, 0x96, 0xa4, 0x5f,
+	0x86, 0x8b, 0x95, 0xca, 0xa5, 0x83, 0xfa, 0xe3, 0x82, 0xf7, 0xfe, 0x78, 0xec, 0x34, 0x32, 0xad,
+	0x5f, 0x2a, 0x79, 0x2d, 0x24, 0x95, 0xde, 0x4f, 0x0a, 0xb7, 0x2e, 0x52, 0x2f, 0x0a, 0x1a, 0x29,
+	0x2e, 0x7a, 0x9c, 0x88, 0xa6, 0x9a, 0x57, 0x65, 0x71, 0x6c, 0xfa, 0xae, 0x8b, 0x16, 0x77, 0x7c,
+	0x2f, 0x51, 0x7b, 0x05, 0xc0, 0x4a, 0x89, 0xaa, 0x54, 0x32, 0x14, 0x7d, 0x08, 0x83, 0xb2, 0xa8,
+	0x52, 0xfb, 0x56, 0x83, 0xf3, 0x4f, 0x54, 0xd2, 0xa4, 0xe1, 0x46, 0x1f, 0x20, 0x6f, 0xf2, 0x4c,
+	0xd1, 0x64, 0xf1, 0x03, 0xb5, 0x4a, 0x1f, 0x28, 0xe6, 0x08, 0x31, 0x70, 0x1d, 0x8b, 0x0a, 0x15,
+	0x6d, 0xa1, 0x22, 0x4b, 0x22, 0x4b, 0xd0, 0xe2, 0xdc, 0x1d, 0xcc, 0x8a, 0x9b, 0xf8, 0xa8, 0x0f,
+	0xe0, 0x42, 0xd1, 0x57, 0x15, 0xc6, 0x47, 0xb0, 0x2a, 0x29, 0x3b, 0x27, 0x9e, 0xb5, 0x23, 0xd0,
+	0xd0, 0x28, 0xe9, 0x7f, 0x6b, 0x30, 0x28, 0x0b, 0xaa, 0x2a, 0x7e, 0xdf, 0x0c, 0xbc, 0x6b, 0x7c,
+	0xe4, 0x2a, 0xf4, 0x38, 0x75, 0x5c, 0xd3, 0xdf, 0xdb, 0x63, 0xc8, 0x07, 0x73, 0xeb, 0xda, 0xa8,
+	0x6d, 0x40, 0x4c, 0x7a, 0x21, 0x28, 0xe4, 0x36, 0x2c, 0x59, 0xb2, 0x92, 0xcd, 0x10, 0x8f, 0x1d,
+	0x16, 0x6b, 0xee, 0x08, 0xc7, 0xce, 0x5a, 0x49, 0x85, 0x4b, 0x32, 0xd1, 0x61, 0xc1, 0xb1, 0xdf,
+	0x98, 0xa2, 0x81, 0x08, 0xf8, 0x77, 0x85, 0xb6, 0x9e, 0x63, 0xbf, 0xf9, 0xca, 0x71, 0x71, 0x27,
+	0xee, 0x02, 0xaf, 0xe1, 0x92, 0x0c, 0x7e, 0xdb, 0xb3, 0x42, 0x1c, 0xa3, 0xc7, 0xa9, 0xbb, 0xe9,
+	0x07, 0x27, 0x8d, 0x4a, 0x60, 0x0d, 0xba, 0xcc, 0xf1, 0x2c, 0x34, 0x3d, 0xd9, 0x86, 0xda, 0x46,
+	0x47, 0xfc, 0x7e, 0xce, 0xf4, 0xa7, 0x70, 0xb9, 0x46, 0xaf, 0xca, 0xec, 0x35, 0xe8, 0x0b, 0xc7,
+	0x2c, 0xdf, 0xe3, 0xe8, 0x71, 0xa1, 0xbb, 0x6f, 0xf4, 0x62, 0xda, 0xa6, 0x24, 0xe9, 0x1f, 0x00,
+	0x91, 0x3a, 0x9e, 0xf9, 0x91, 0xd7, 0x0c, 0x9a, 0xe7, 0x61, 0x39, 0x27, 0xa2, 0x6a, 0xe3, 0x11,
+	0xac, 0x48, 0xf2, 0x2b, 0x6f, 0xdc, 0x58, 0xd7, 0x2a, 0x9c, 0x2f, 0x08, 0x29, 0x6d, 0x0f, 0x13,
+	0x23, 0xf9, 0x77, 0xe2, 0x54, 0x65, 0x17, 0x12, 0x0f, 0xf2, 0x4f, 0x85, 0xfe, 0xbb, 0x06, 0xe7,
+	0x92, 0x36, 0xd2, 0x30, 0xeb, 0xef, 0x58, 0x76, 0xad, 0xda, 0xb2, 0x6b, 0x4f, 0xca, 0x6e, 0x04,
+	0x4b, 0xcc, 0x8f, 0x42, 0x0b, 0x4d, 0x9b, 0x72, 0x6a, 0x7a, 0xbe, 0x8d, 0xaa, 0x2a, 0x17, 0x25,
+	0x7d, 0x8b, 0x72, 0xfa, 0xdc, 0xb7, 0x51, 0xff, 0x3c, 0xf9, 0x28, 0xb9, 0xaf, 0x79, 0x1b, 0xce,
+	0xb9, 0x94, 0x71, 0x93, 0x06, 0x01, 0x7a, 0xb6, 0x49, 0x79, 0x5c, 0x12, 0x9a, 0x28, 0x89, 0xc5,
+	0xf8, 0xe2, 0x89, 0xa0, 0x3f, 0xe1, 0xcf, 0x99, 0xfe, 0xa7, 0x06, 0x67, 0x63, 0xd9, 0xb8, 0x04,
+	0x1b, 0xc6, 0xdb, 0x73, 0x98, 0x99, 0x54, 0xb2, 0x08, 0xb8, 0x6b, 0xcc, 0x3b, 0x6c, 0x5b, 0x96,
+	0xb1, 0xba, 0xb7, 0x29, 0x97, 0xf7, 0xad, 0xe4, 0x7e, 0x8b, 0x72, 0x71, 0x7f, 0x1f, 0x96, 0x15,
+	0x32, 0x1c, 0xdf, 0x9b, 0x80, 0x46, 0xbe, 0x85, 0x64, 0x72, 0x95, 0xe2, 0xe6, 0x2a, 0xf4, 0x18,
+	0xf7, 0x83, 0x04, 0x83, 0xb3, 0x12, 0x83, 0x31, 0x49, 0x62, 0x50, 0xff, 0x10, 0x96, 0x26, 0x11,
+	0x34, 0xaf, 0xe7, 0x9f, 0x93, 0x0e, 0xf5, 0x92, 0x3a, 0xee, 0x0e, 0x7a, 0x36, 0x86, 0xef, 0x09,
+	0x33, 0x32, 0x82, 0xb3, 0x76, 0x48, 0x1d, 0xcf, 0xf1, 0xf6, 0x77, 0xd0, 0xf2, 0x3d, 0x9b, 0x89,
+	0xf8, 0x17, 0x8c, 0x22, 0x59, 0xff, 0x35, 0x6d, 0x73, 0x59, 0xeb, 0x93, 0xc7, 0xda, 0x43, 0xb4,
+	0x5d, 0x34, 0x0f, 0x90, 0xda, 0x18, 0x2a, 0xef, 0xfb, 0x92, 0xf8, 0xb5, 0xa0, 0xc5, 0x69, 0x51,
+	0x4c, 0xbb, 0xbe, 0x7d, 0x22, 0x3c, 0xe9, 0x1b, 0x20, 0x49, 0x4f, 0x7d, 0xfb, 0x44, 0xf4, 0x1b,
+	0x66, 0x8a, 0x3a, 0xb0, 0x0e, 0x22, 0xef, 0x50, 0x7d, 0x8a, 0x9e, 0xc3, 0xbe, 0xa1, 0x8c, 0x6f,
+	0xc6, 0x24, 0xfd, 0x0f, 0x0d, 0xd6, 0x26, 0x6e, 0x18, 0x68, 0xa1, 0x73, 0xfc, 0x1f, 0xa6, 0x81,
+	0x3c, 0x80, 0x15, 0x55, 0xe8, 0xb9, 0x89, 0x4c, 0x61, 0x81, 0xc8, 0x3b, 0xf5, 0x1c, 0x88, 0x1b,
+	0xf1, 0xda, 0x57, 0x38, 0xac, 0xf0, 0xfb, 0x29, 0x5c, 0x34, 0x90, 0xda, 0x92, 0x43, 0x74, 0xd5,
+	0xe6, 0x2f, 0xcf, 0x5f, 0x67, 0xe0, 0x52, 0xb5, 0x70, 0x93, 0xd7, 0xe7, 0x33, 0x18, 0xa6, 0xdd,
+	0x9d, 0x3b, 0x63, 0x64, 0x9c, 0x8e, 0x03, 0x93, 0xa9, 0xf0, 0x65, 0x82, 0x56, 0x55, 0xab, 0x7f,
+	0x99, 0xdc, 0x27, 0x69, 0x28, 0x3d, 0x0d, 0xad, 0xd2, 0xd3, 0x10, 0x1b, 0x48, 0x40, 0x55, 0x61,
+	0xa0, 0x2d, 0x0d, 0xd8, 0x12, 0x64, 0x55, 0x06, 0x52, 0x61, 0x61, 0x40, 0xa2, 0xa8, 0xa7, 0xf8,
+	0x85, 0x81, 0xcb, 0x00, 0x0a, 0x32, 0x91, 0x97, 0x3c, 0x75, 0xf3, 0x12, 0x30, 0x91, 0xc7, 0xeb,
+	0x70, 0xdb, 0xa9, 0xc5, 0x6d, 0xbe, 0x31, 0x76, 0x4b, 0x43, 0xd0, 0xb7, 0x00, 0x5b, 0x0e, 0x3b,
+	0x94, 0x49, 0x8e, 0x9b, 0xa0, 0xed, 0x84, 0x6a, 0x56, 0x8a, 0x8f, 0x31, 0x85, 0xba, 0xae, 0x4a,
+	0x5d, 0x7c, 0x8c, 0xe7, 0xe6, 0x88, 0xa1, 0xad, 0xb2, 0x23, 0xce, 0x31, 0x6d, 0x2f, 0x44, 0x54,
+	0x09, 0x10, 0x67, 0xfd, 0x37, 0x0d, 0xe6, 0x9f, 0xe1, 0x58, 0x69, 0xbe, 0x02, 0xb0, 0xef, 0x87,
+	0x7e, 0xc4, 0x1d, 0x0f, 0x65, 0x17, 0x9c, 0x35, 0x32, 0x94, 0x7f, 0x6f, 0x47, 0xcc, 0xf1, 0xe8,
+	0xee, 0xa9, 0x64, 0x8a, 0x73, 0x4c, 0x3b, 0x40, 0x1a, 0xa8, 0xfc, 0x89, 0x73, 0xbc, 0x05, 0x30,
+	0x4e, 0xad, 0x43, 0x91, 0xac, 0xb6, 0x21, 0x7f, 0x3c, 0x7c, 0xbb, 0x08, 0xfd, 0x6c, 0x69, 0x93,
+	0x1f, 0xa0, 0x97, 0x59, 0x5f, 0xc8, 0x8d, 0xf2, 0x96, 0x52, 0x5e, 0x87, 0x86, 0xff, 0x9b, 0xc2,
+	0xa5, 0x80, 0x31, 0x43, 0x3c, 0x38, 0x57, 0x5a, 0x0f, 0xc8, 0x9d, 0xb2, 0x74, 0xdd, 0xf2, 0x31,
+	0xbc, 0xdb, 0x88, 0x37, 0xb5, 0xc7, 0x61, 0xb9, 0x62, 0xde, 0x27, 0xf7, 0xa6, 0x68, 0xc9, 0xed,
+	0x1c, 0xc3, 0xff, 0x37, 0xe4, 0x4e, 0xad, 0x1e, 0x01, 0x29, 0x2f, 0x03, 0xe4, 0xee, 0x54, 0x35,
+	0x93, 0x65, 0x63, 0x78, 0xaf, 0x19, 0x73, 0x6d, 0xa0, 0x72, 0x4d, 0x98, 0x1a, 0x68, 0x6e, 0x11,
+	0x99, 0x1a, 0x68, 0x61, 0xf7, 0x98, 0x21, 0x87, 0xb0, 0x54, 0x5c, 0x21, 0xc8, 0xed, 0xba, 0xbd,
+	0xb6, 0xb4, 0xa1, 0x0c, 0xef, 0x34, 0x61, 0x4d, 0x8d, 0x21, 0x2c, 0xe6, 0xc7, 0x7c, 0x72, 0xab,
+	0x2c, 0x5f, 0xb9, 0xb4, 0x0c, 0x47, 0xd3, 0x19, 0xb3, 0x31, 0x15, 0x47, 0xff, 0xaa, 0x98, 0x6a,
+	0xf6, 0x8a, 0xaa, 0x98, 0xea, 0x36, 0x09, 0x7d, 0x86, 0xfc, 0x92, 0xcc, 0x93, 0x85, 0x91, 0x98,
+	0x6c, 0xd4, 0xa9, 0xa9, 0x9e, 0xc9, 0x87, 0xf7, 0x1b, 0xf3, 0x27, 0xb6, 0x1f, 0x68, 0x31, 0xd6,
+	0x33, 0x93, 0x71, 0x15, 0xd6, 0xcb, 0xb3, 0x76, 0x15, 0xd6, 0xab, 0xc6, 0xeb, 0x19, 0xb2, 0x0b,
+	0x0b, 0xb9, 0x59, 0x99, 0xdc, 0xac, 0x93, 0xcc, 0x4f, 0xe0, 0xc3, 0x5b, 0x53, 0xf9, 0x52, 0x1b,
+	0x66, 0xd2, 0xbd, 0x54, 0xbb, 0xaa, 0x75, 0x2e, 0xdf, 0xaf, 0x6e, 0x4e, 0x63, 0x4b, 0x0d, 0x7c,
+	0x07, 0x30, 0x19, 0x6d, 0xc9, 0xf5, 0x3a, 0xb9, 0xec, 0xa7, 0xb8, 0x71, 0x3a, 0x53, 0xaa, 0xfa,
+	0x47, 0x58, 0xa9, 0x7a, 0xe9, 0x49, 0x05, 0x0a, 0x4f, 0x19, 0x27, 0x86, 0x1b, 0x4d, 0xd9, 0x53,
+	0xc3, 0xaf, 0xa0, 0x9b, 0x8c, 0xaa, 0xe4, 0x5a, 0x59, 0xba, 0x30, 0x88, 0x0f, 0xf5, 0xd3, 0x58,
+	0x32, 0xd5, 0x34, 0x4e, 0x80, 0x33, 0x19, 0x26, 0xeb, 0x81, 0x53, 0x1a, 0x77, 0xeb, 0x81, 0x53,
+	0x9e, 0x4d, 0x85, 0xb9, 0xa3, 0x64, 0xe9, 0xc8, 0xce, 0x60, 0x95, 0x4d, 0xb6, 0x6e, 0xb4, 0xac,
+	0x6c, 0xb2, 0xf5, 0x63, 0xdd, 0xcc, 0xee, 0x9c, 0xf8, 0x93, 0xf0, 0xd1, 0x3f, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x4c, 0x2f, 0x65, 0x47, 0x3b, 0x14, 0x00, 0x00,
 }

weed/server/master_grpc_server.go

@@ -72,29 +72,39 @@ func (ms *MasterServer) SendHeartbeat(stream master_pb.Seaweed_SendHeartbeatServ
 			}
 		}
 
+		glog.V(1).Infof("master received heartbeat %s", heartbeat.String())
 		message := &master_pb.VolumeLocation{
 			Url:       dn.Url(),
 			PublicUrl: dn.PublicUrl,
 		}
-		if len(heartbeat.NewVids) > 0 || len(heartbeat.DeletedVids) > 0 {
+		if len(heartbeat.NewVolumes) > 0 || len(heartbeat.DeletedVolumes) > 0 {
 			// process delta volume ids if exists for fast volume id updates
-			message.NewVids = append(message.NewVids, heartbeat.NewVids...)
-			message.DeletedVids = append(message.DeletedVids, heartbeat.DeletedVids...)
+			for _, volInfo := range heartbeat.NewVolumes{
+				message.NewVids = append(message.NewVids, volInfo.Id)
+			}
+			for _, volInfo := range heartbeat.DeletedVolumes{
+				message.DeletedVids = append(message.DeletedVids, volInfo.Id)
+			}
+			// update master internal volume layouts
+			t.IncrementalSyncDataNodeRegistration(heartbeat.NewVolumes, heartbeat.DeletedVolumes, dn)
 		} else {
 			// process heartbeat.Volumes
 			newVolumes, deletedVolumes := t.SyncDataNodeRegistration(heartbeat.Volumes, dn)
 
 			for _, v := range newVolumes {
+				glog.V(0).Infof("master see new volume %d from %s", uint32(v.Id),  dn.Url())
 				message.NewVids = append(message.NewVids, uint32(v.Id))
 			}
 			for _, v := range deletedVolumes {
+				glog.V(0).Infof("master see deleted volume %d from %s", uint32(v.Id), dn.Url())
 				message.DeletedVids = append(message.DeletedVids, uint32(v.Id))
 			}
 		}
 
 		if len(message.NewVids) > 0 || len(message.DeletedVids) > 0 {
 			ms.clientChansLock.RLock()
-			for _, ch := range ms.clientChans {
+			for host, ch := range ms.clientChans {
+				glog.V(0).Infof("master send to %s: %s", host, message.String())
 				ch <- message
 			}
 			ms.clientChansLock.RUnlock()

weed/server/volume_grpc_client_to_master.go

@@ -97,23 +97,30 @@ func (vs *VolumeServer) doHeartbeat(ctx context.Context, masterNode, masterGrpcA
 
 	for {
 		select {
-		case vid := <-vs.store.NewVolumeIdChan:
+		case volumeMessage := <-vs.store.NewVolumesChan:
 			deltaBeat := &master_pb.Heartbeat{
-				NewVids: []uint32{uint32(vid)},
+				NewVolumes:[]*master_pb.VolumeShortInformationMessage{
+					&volumeMessage,
+				},
 			}
+			glog.V(1).Infof("volume server %s:%d adds volume %d", vs.store.Ip, vs.store.Port, volumeMessage.Id)
 			if err = stream.Send(deltaBeat); err != nil {
 				glog.V(0).Infof("Volume Server Failed to update to master %s: %v", masterNode, err)
 				return "", err
 			}
-		case vid := <-vs.store.DeletedVolumeIdChan:
+		case volumeMessage := <-vs.store.DeletedVolumesChan:
 			deltaBeat := &master_pb.Heartbeat{
-				DeletedVids: []uint32{uint32(vid)},
+				DeletedVolumes:[]*master_pb.VolumeShortInformationMessage{
+					&volumeMessage,
+				},
 			}
+			glog.V(1).Infof("volume server %s:%d deletes volume %d", vs.store.Ip, vs.store.Port, volumeMessage.Id)
 			if err = stream.Send(deltaBeat); err != nil {
 				glog.V(0).Infof("Volume Server Failed to update to master %s: %v", masterNode, err)
 				return "", err
 			}
 		case <-tickChan:
+			glog.V(1).Infof("volume server %s:%d heartbeat", vs.store.Ip, vs.store.Port)
 			if err = stream.Send(vs.store.CollectHeartbeat()); err != nil {
 				glog.V(0).Infof("Volume Server Failed to talk with master %s: %v", masterNode, err)
 				return "", err

weed/server/volume_grpc_copy.go

@@ -19,11 +19,7 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
 
 	v := vs.store.GetVolume(needle.VolumeId(req.VolumeId))
 	if v != nil {
-		// unmount the volume
-		err := vs.store.UnmountVolume(needle.VolumeId(req.VolumeId))
-		if err != nil {
-			return nil, fmt.Errorf("failed to unmount volume %d: %v", req.VolumeId, err)
-		}
+		return nil, fmt.Errorf("volume %d already exists", req.VolumeId)
 	}
 
 	location := vs.store.FindFreeLocation()
@@ -31,8 +27,6 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
 		return nil, fmt.Errorf("no space left")
 	}
 
-	volumeFileName := storage.VolumeFileName(req.Collection, location.Directory, int(req.VolumeId))
-
 	// the master will not start compaction for read-only volumes, so it is safe to just copy files directly
 	// copy .dat and .idx files
 	//   read .idx .dat file size and timestamp
@@ -40,8 +34,7 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
 	//   send .dat file
 	//   confirm size and timestamp
 	var volFileInfoResp *volume_server_pb.ReadVolumeFileStatusResponse
-	datFileName := volumeFileName + ".dat"
-	idxFileName := volumeFileName + ".idx"
+	var volumeFileName, idxFileName, datFileName string
 	err := operation.WithVolumeServerClient(req.SourceDataNode, vs.grpcDialOption, func(client volume_server_pb.VolumeServerClient) error {
 		var err error
 		volFileInfoResp, err = client.ReadVolumeFileStatus(ctx,
@@ -52,6 +45,8 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
 			return fmt.Errorf("read volume file status failed, %v", err)
 		}
 
+		volumeFileName = storage.VolumeFileName(volFileInfoResp.Collection, location.Directory, int(req.VolumeId))
+
 		// println("source:", volFileInfoResp.String())
 
 		copyFileClient, err := client.CopyFile(ctx, &volume_server_pb.CopyFileRequest{
@@ -64,6 +59,7 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
 			return fmt.Errorf("failed to start copying volume %d idx file: %v", req.VolumeId, err)
 		}
 
+		idxFileName = volumeFileName + ".idx"
 		err = writeToFile(copyFileClient, idxFileName)
 		if err != nil {
 			return fmt.Errorf("failed to copy volume %d idx file: %v", req.VolumeId, err)
@@ -79,6 +75,7 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
 			return fmt.Errorf("failed to start copying volume %d dat file: %v", req.VolumeId, err)
 		}
 
+		datFileName = volumeFileName + ".dat"
 		err = writeToFile(copyFileClient, datFileName)
 		if err != nil {
 			return fmt.Errorf("failed to copy volume %d dat file: %v", req.VolumeId, err)
@@ -86,9 +83,13 @@ func (vs *VolumeServer) VolumeCopy(ctx context.Context, req *volume_server_pb.Vo
 
 		return nil
 	})
-	if err != nil {
-		os.Remove(idxFileName)
-		os.Remove(datFileName)
+	if err != nil && volumeFileName != "" {
+		if idxFileName != "" {
+			os.Remove(idxFileName)
+		}
+		if datFileName != "" {
+			os.Remove(datFileName)
+		}
 		return nil, err
 	}
 
@@ -168,6 +169,7 @@ func (vs *VolumeServer) ReadVolumeFileStatus(ctx context.Context, req *volume_se
 	resp.IdxFileTimestampSeconds = uint64(modTime.Unix())
 	resp.FileCount = v.FileCount()
 	resp.CompactionRevision = uint32(v.CompactionRevision)
+	resp.Collection = v.Collection
 	return resp, nil
 }
 

weed/server/volume_grpc_tail.go

@@ -1,16 +1,18 @@
 package weed_server
 
 import (
+	"context"
 	"fmt"
 	"time"
 
 	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/operation"
 	"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
 	"github.com/chrislusf/seaweedfs/weed/storage"
 	"github.com/chrislusf/seaweedfs/weed/storage/needle"
 )
 
-func (vs *VolumeServer) VolumeTail(req *volume_server_pb.VolumeTailRequest, stream volume_server_pb.VolumeServer_VolumeTailServer) error {
+func (vs *VolumeServer) VolumeTailSender(req *volume_server_pb.VolumeTailSenderRequest, stream volume_server_pb.VolumeServer_VolumeTailSenderServer) error {
 
 	v := vs.store.GetVolume(needle.VolumeId(req.VolumeId))
 	if v == nil {
@@ -50,7 +52,7 @@ func (vs *VolumeServer) VolumeTail(req *volume_server_pb.VolumeTailRequest, stre
 
 }
 
-func sendNeedlesSince(stream volume_server_pb.VolumeServer_VolumeTailServer, v *storage.Volume, lastTimestampNs uint64) (lastProcessedTimestampNs uint64, err error) {
+func sendNeedlesSince(stream volume_server_pb.VolumeServer_VolumeTailSenderServer, v *storage.Volume, lastTimestampNs uint64) (lastProcessedTimestampNs uint64, err error) {
 
 	foundOffset, isLastOne, err := v.BinarySearchByAppendAtNs(lastTimestampNs)
 	if err != nil {
@@ -61,7 +63,7 @@ func sendNeedlesSince(stream volume_server_pb.VolumeServer_VolumeTailServer, v *
 
 	if isLastOne {
 		// need to heart beat to the client to ensure the connection health
-		sendErr := stream.Send(&volume_server_pb.VolumeTailResponse{IsLastChunk: true})
+		sendErr := stream.Send(&volume_server_pb.VolumeTailSenderResponse{IsLastChunk: true})
 		return lastTimestampNs, sendErr
 	}
 
@@ -78,7 +80,7 @@ func sendNeedlesSince(stream volume_server_pb.VolumeServer_VolumeTailServer, v *
 				stopOffset = len(needleBody)
 			}
 
-			sendErr := stream.Send(&volume_server_pb.VolumeTailResponse{
+			sendErr := stream.Send(&volume_server_pb.VolumeTailSenderResponse{
 				NeedleHeader: needleHeader,
 				NeedleBody:   needleBody[i:stopOffset],
 				IsLastChunk:  isLastChunk,
@@ -96,3 +98,21 @@ func sendNeedlesSince(stream volume_server_pb.VolumeServer_VolumeTailServer, v *
 	return
 
 }
+
+func (vs *VolumeServer) VolumeTailReceiver(ctx context.Context, req *volume_server_pb.VolumeTailReceiverRequest) (*volume_server_pb.VolumeTailReceiverResponse, error) {
+
+	resp := &volume_server_pb.VolumeTailReceiverResponse{}
+
+	v := vs.store.GetVolume(needle.VolumeId(req.VolumeId))
+	if v == nil {
+		return resp, fmt.Errorf("receiver not found volume id %d", req.VolumeId)
+	}
+
+	defer glog.V(1).Infof("receive tailing volume %d finished", v.Id)
+
+	return resp, operation.TailVolumeFromServer(req.SourceVolumeServer, vs.grpcDialOption, v.Id, req.SinceNs, int(req.DrainingSeconds), func(n *needle.Needle) error {
+		_, err := vs.store.Write(v.Id, n)
+		return err
+	})
+
+}

weed/shell/command_volume_fix_replication.go

@@ -119,7 +119,6 @@ func (c *commandVolumeFixReplication) Do(args []string, commandEnv *commandEnv,
 				err := operation.WithVolumeServerClient(dst.dataNode.Id, commandEnv.option.GrpcDialOption, func(volumeServerClient volume_server_pb.VolumeServerClient) error {
 					_, replicateErr := volumeServerClient.VolumeCopy(ctx, &volume_server_pb.VolumeCopyRequest{
 						VolumeId:       volumeInfo.Id,
-						Collection:     volumeInfo.Collection,
 						SourceDataNode: sourceNode.dataNode.Id,
 					})
 					return replicateErr

weed/shell/command_volume_move.go

@@ -0,0 +1,124 @@
+package shell
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"time"
+
+	"github.com/chrislusf/seaweedfs/weed/operation"
+	"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
+	"github.com/chrislusf/seaweedfs/weed/storage/needle"
+	"google.golang.org/grpc"
+)
+
+func init() {
+	commands = append(commands, &commandVolumeMove{})
+}
+
+type commandVolumeMove struct {
+	grpcDialOption grpc.DialOption
+}
+
+func (c *commandVolumeMove) Name() string {
+	return "volume.move"
+}
+
+func (c *commandVolumeMove) Help() string {
+	return `move a live volume from one volume server to another volume server
+
+	volume.move <source volume server host:port> <target volume server host:port> <volume id>
+
+	This command move a live volume from one volume server to another volume server. Here are the steps:
+
+	1. This command asks the target volume server to copy the source volume from source volume server, remember the last entry's timestamp.
+	2. This command asks the target volume server to mount the new volume
+		Now the master will mark this volume id as readonly.
+	3. This command asks the target volume server to tail the source volume for updates after the timestamp, for 1 minutes to drain the requests.
+	4. This command asks the source volume server to unmount the source volume
+		Now the master will mark this volume id as writable.
+	5. This command asks the source volume server to delete the source volume
+
+`
+}
+
+func (c *commandVolumeMove) Do(args []string, commandEnv *commandEnv, writer io.Writer) (err error) {
+
+	if len(args) != 3 {
+		fmt.Fprintf(writer, "received args: %+v\n", args)
+		return fmt.Errorf("need 3 args of <source volume server host:port> <target volume server host:port> <volume id>")
+	}
+	c.grpcDialOption = commandEnv.option.GrpcDialOption
+	ctx := context.Background()
+
+	sourceVolumeServer, targetVolumeServer, volumeIdString := args[0], args[1], args[2]
+
+	volumeId, err := needle.NewVolumeId(volumeIdString)
+	if err != nil {
+		return fmt.Errorf("wrong volume id format %s: %v", volumeId, err)
+	}
+
+	if sourceVolumeServer == targetVolumeServer {
+		return fmt.Errorf("source and target volume servers are the same!")
+	}
+
+	log.Printf("copying volume %d from %s to %s", volumeId, sourceVolumeServer, targetVolumeServer)
+	lastAppendAtNs, err := c.copyVolume(ctx, volumeId, sourceVolumeServer, targetVolumeServer)
+	if err != nil {
+		return fmt.Errorf("copy volume %d from %s to %s: %v", volumeId, sourceVolumeServer, targetVolumeServer, err)
+	}
+
+	log.Printf("tailing volume %d from %s to %s", volumeId, sourceVolumeServer, targetVolumeServer)
+	if err = c.tailVolume(ctx, volumeId, sourceVolumeServer, targetVolumeServer, lastAppendAtNs, 5*time.Second); err != nil {
+		return fmt.Errorf("tail volume %d from %s to %s: %v", volumeId, sourceVolumeServer, targetVolumeServer, err)
+	}
+
+	log.Printf("deleting volume %d from %s", volumeId, sourceVolumeServer)
+	if err = c.deleteVolume(ctx, volumeId, sourceVolumeServer); err != nil {
+		return fmt.Errorf("delete volume %d from %s: %v", volumeId, sourceVolumeServer, err)
+	}
+
+	log.Printf("moved volume %d from %s to %s", volumeId, sourceVolumeServer, targetVolumeServer)
+
+	return nil
+}
+
+func (c *commandVolumeMove) copyVolume(ctx context.Context, volumeId needle.VolumeId, sourceVolumeServer, targetVolumeServer string) (lastAppendAtNs uint64, err error) {
+
+	err = operation.WithVolumeServerClient(targetVolumeServer, c.grpcDialOption, func(volumeServerClient volume_server_pb.VolumeServerClient) error {
+		resp, replicateErr := volumeServerClient.VolumeCopy(ctx, &volume_server_pb.VolumeCopyRequest{
+			VolumeId:       uint32(volumeId),
+			SourceDataNode: sourceVolumeServer,
+		})
+		if replicateErr == nil {
+			lastAppendAtNs = resp.LastAppendAtNs
+		}
+		return replicateErr
+	})
+
+	return
+}
+
+func (c *commandVolumeMove) tailVolume(ctx context.Context, volumeId needle.VolumeId, sourceVolumeServer, targetVolumeServer string, lastAppendAtNs uint64, timeout time.Duration) (err error) {
+
+	return operation.WithVolumeServerClient(targetVolumeServer, c.grpcDialOption, func(volumeServerClient volume_server_pb.VolumeServerClient) error {
+		_, replicateErr := volumeServerClient.VolumeTailReceiver(ctx, &volume_server_pb.VolumeTailReceiverRequest{
+			VolumeId:           uint32(volumeId),
+			SinceNs:            lastAppendAtNs,
+			DrainingSeconds:    uint32(timeout.Seconds()),
+			SourceVolumeServer: sourceVolumeServer,
+		})
+		return replicateErr
+	})
+
+}
+
+func (c *commandVolumeMove) deleteVolume(ctx context.Context, volumeId needle.VolumeId, sourceVolumeServer string) (err error) {
+	return operation.WithVolumeServerClient(sourceVolumeServer, c.grpcDialOption, func(volumeServerClient volume_server_pb.VolumeServerClient) error {
+		_, unmountErr := volumeServerClient.VolumeDelete(ctx, &volume_server_pb.VolumeDeleteRequest{
+			VolumeId: uint32(volumeId),
+		})
+		return unmountErr
+	})
+}

weed/storage/store.go

@@ -18,18 +18,18 @@ const (
  * A VolumeServer contains one Store
  */
 type Store struct {
-	Ip                  string
-	Port                int
-	PublicUrl           string
-	Locations           []*DiskLocation
-	dataCenter          string //optional informaton, overwriting master setting if exists
-	rack                string //optional information, overwriting master setting if exists
-	connected           bool
-	volumeSizeLimit     uint64 //read from the master
-	Client              master_pb.Seaweed_SendHeartbeatClient
-	NeedleMapType       NeedleMapType
-	NewVolumeIdChan     chan needle.VolumeId
-	DeletedVolumeIdChan chan needle.VolumeId
+	Ip                 string
+	Port               int
+	PublicUrl          string
+	Locations          []*DiskLocation
+	dataCenter         string //optional informaton, overwriting master setting if exists
+	rack               string //optional information, overwriting master setting if exists
+	connected          bool
+	volumeSizeLimit    uint64 //read from the master
+	Client             master_pb.Seaweed_SendHeartbeatClient
+	NeedleMapType      NeedleMapType
+	NewVolumesChan     chan master_pb.VolumeShortInformationMessage
+	DeletedVolumesChan chan master_pb.VolumeShortInformationMessage
 }
 
 func (s *Store) String() (str string) {
@@ -45,8 +45,8 @@ func NewStore(port int, ip, publicUrl string, dirnames []string, maxVolumeCounts
 		location.loadExistingVolumes(needleMapKind)
 		s.Locations = append(s.Locations, location)
 	}
-	s.NewVolumeIdChan = make(chan needle.VolumeId, 3)
-	s.DeletedVolumeIdChan = make(chan needle.VolumeId, 3)
+	s.NewVolumesChan = make(chan master_pb.VolumeShortInformationMessage, 3)
+	s.DeletedVolumesChan = make(chan master_pb.VolumeShortInformationMessage, 3)
 	return
 }
 func (s *Store) AddVolume(volumeId needle.VolumeId, collection string, needleMapKind NeedleMapType, replicaPlacement string, ttlString string, preallocate int64) error {
@@ -67,7 +67,7 @@ func (s *Store) DeleteCollection(collection string) (e error) {
 		if e != nil {
 			return
 		}
-		// let the heartbeat send the list of volumes, instead of sending the deleted volume ids to DeletedVolumeIdChan
+		// let the heartbeat send the list of volumes, instead of sending the deleted volume ids to DeletedVolumesChan
 	}
 	return
 }
@@ -100,7 +100,13 @@ func (s *Store) addVolume(vid needle.VolumeId, collection string, needleMapKind
 			location.Directory, vid, collection, replicaPlacement, ttl)
 		if volume, err := NewVolume(location.Directory, collection, vid, needleMapKind, replicaPlacement, ttl, preallocate); err == nil {
 			location.SetVolume(vid, volume)
-			s.NewVolumeIdChan <- vid
+			glog.V(0).Info("add volume", vid)
+			s.NewVolumesChan <- master_pb.VolumeShortInformationMessage{
+				Id:               uint32(vid),
+				Collection:       collection,
+				ReplicaPlacement: uint32(replicaPlacement.Byte()),
+				Ttl:              ttl.ToUint32(),
+			}
 			return nil
 		} else {
 			return err
@@ -229,7 +235,14 @@ func (s *Store) HasVolume(i needle.VolumeId) bool {
 func (s *Store) MountVolume(i needle.VolumeId) error {
 	for _, location := range s.Locations {
 		if found := location.LoadVolume(i, s.NeedleMapType); found == true {
-			s.NewVolumeIdChan <- needle.VolumeId(i)
+			glog.V(0).Infof("mount volume %d", i)
+			v := s.findVolume(i)
+			s.NewVolumesChan <- master_pb.VolumeShortInformationMessage{
+				Id:               uint32(v.Id),
+				Collection:       v.Collection,
+				ReplicaPlacement: uint32(v.ReplicaPlacement.Byte()),
+				Ttl:              v.Ttl.ToUint32(),
+			}
 			return nil
 		}
 	}
@@ -238,9 +251,20 @@ func (s *Store) MountVolume(i needle.VolumeId) error {
 }
 
 func (s *Store) UnmountVolume(i needle.VolumeId) error {
+	v := s.findVolume(i)
+	if v == nil {
+		return nil
+	}
+	message := master_pb.VolumeShortInformationMessage{
+		Id:               uint32(v.Id),
+		Collection:       v.Collection,
+		ReplicaPlacement: uint32(v.ReplicaPlacement.Byte()),
+		Ttl:              v.Ttl.ToUint32(),
+	}
 	for _, location := range s.Locations {
 		if err := location.UnloadVolume(i); err == nil {
-			s.DeletedVolumeIdChan <- needle.VolumeId(i)
+			glog.V(0).Infof("UnmountVolume %d", i)
+			s.DeletedVolumesChan <- message
 			return nil
 		}
 	}
@@ -249,9 +273,20 @@ func (s *Store) UnmountVolume(i needle.VolumeId) error {
 }
 
 func (s *Store) DeleteVolume(i needle.VolumeId) error {
+	v := s.findVolume(i)
+	if v == nil {
+		return nil
+	}
+	message := master_pb.VolumeShortInformationMessage{
+		Id:               uint32(v.Id),
+		Collection:       v.Collection,
+		ReplicaPlacement: uint32(v.ReplicaPlacement.Byte()),
+		Ttl:              v.Ttl.ToUint32(),
+	}
 	for _, location := range s.Locations {
 		if error := location.deleteVolumeById(i); error == nil {
-			s.DeletedVolumeIdChan <- needle.VolumeId(i)
+			glog.V(0).Infof("DeleteVolume %d", i)
+			s.DeletedVolumesChan <- message
 			return nil
 		}
 	}

weed/storage/volume_info.go

@@ -43,6 +43,20 @@ func NewVolumeInfo(m *master_pb.VolumeInformationMessage) (vi VolumeInfo, err er
 	return vi, nil
 }
 
+func NewVolumeInfoFromShort(m *master_pb.VolumeShortInformationMessage) (vi VolumeInfo, err error) {
+	vi = VolumeInfo{
+		Id:               needle.VolumeId(m.Id),
+		Collection:       m.Collection,
+	}
+	rp, e := NewReplicaPlacementFromByte(byte(m.ReplicaPlacement))
+	if e != nil {
+		return vi, e
+	}
+	vi.ReplicaPlacement = rp
+	vi.Ttl = needle.LoadTTLFromUint32(m.Ttl)
+	return vi, nil
+}
+
 func (vi VolumeInfo) String() string {
 	return fmt.Sprintf("Id:%d, Size:%d, ReplicaPlacement:%s, Collection:%s, Version:%v, FileCount:%d, DeleteCount:%d, DeletedByteCount:%d, ReadOnly:%v",
 		vi.Id, vi.Size, vi.ReplicaPlacement, vi.Collection, vi.Version, vi.FileCount, vi.DeleteCount, vi.DeletedByteCount, vi.ReadOnly)

weed/topology/data_node.go

@@ -78,6 +78,20 @@ func (dn *DataNode) UpdateVolumes(actualVolumes []storage.VolumeInfo) (newVolume
 	return
 }
 
+func (dn *DataNode) DeltaUpdateVolumes(newlVolumes, deletedVolumes []storage.VolumeInfo) {
+	dn.Lock()
+	for _, v := range deletedVolumes {
+		delete(dn.volumes, v.Id)
+		dn.UpAdjustVolumeCountDelta(-1)
+		dn.UpAdjustActiveVolumeCountDelta(-1)
+	}
+	dn.Unlock()
+	for _, v := range newlVolumes {
+		dn.AddOrUpdateVolume(v)
+	}
+	return
+}
+
 func (dn *DataNode) GetVolumes() (ret []storage.VolumeInfo) {
 	dn.RLock()
 	for _, v := range dn.volumes {

weed/topology/topology.go

@@ -171,7 +171,7 @@ func (t *Topology) SyncDataNodeRegistration(volumes []*master_pb.VolumeInformati
 		}
 	}
 	newVolumes, deletedVolumes = dn.UpdateVolumes(volumeInfos)
-	for _, v := range volumeInfos {
+	for _, v := range newVolumes {
 		t.RegisterVolumeLayout(v, dn)
 	}
 	for _, v := range deletedVolumes {
@@ -179,3 +179,27 @@ func (t *Topology) SyncDataNodeRegistration(volumes []*master_pb.VolumeInformati
 	}
 	return
 }
+
+func (t *Topology) IncrementalSyncDataNodeRegistration(newVolumes, deletedVolumes []*master_pb.VolumeShortInformationMessage, dn *DataNode) {
+	var newVis, oldVis []storage.VolumeInfo
+	for _, v := range newVolumes {
+		vi, err := storage.NewVolumeInfoFromShort(v)
+		if err != nil {
+			glog.V(0).Infof("NewVolumeInfoFromShort %v: %v", v, err)
+			continue
+		}
+		newVis = append(newVis, vi)
+		t.RegisterVolumeLayout(vi, dn)
+	}
+	for _, v := range deletedVolumes {
+		vi, err := storage.NewVolumeInfoFromShort(v)
+		if err != nil {
+			glog.V(0).Infof("NewVolumeInfoFromShort %v: %v", v, err)
+			continue
+		}
+		oldVis = append(oldVis, vi)
+		t.UnRegisterVolumeLayout(vi, dn)
+	}
+	dn.DeltaUpdateVolumes(newVis, oldVis)
+	return
+}

weed/wdclient/masterclient.go

@@ -52,28 +52,28 @@ func (mc *MasterClient) KeepConnectedToMaster() {
 
 func (mc *MasterClient) tryAllMasters() {
 	for _, master := range mc.masters {
-		glog.V(1).Infof("Connecting to master %v", master)
+		glog.V(1).Infof("%s Connecting to master %v", mc.name, master)
 		gprcErr := withMasterClient(context.Background(), master, mc.grpcDialOption, func(ctx context.Context, client master_pb.SeaweedClient) error {
 
 			stream, err := client.KeepConnected(ctx)
 			if err != nil {
-				glog.V(0).Infof("failed to keep connected to %s: %v", master, err)
+				glog.V(0).Infof("%s failed to keep connected to %s: %v", mc.name, master, err)
 				return err
 			}
 
 			if err = stream.Send(&master_pb.ClientListenRequest{Name: mc.name}); err != nil {
-				glog.V(0).Infof("failed to send to %s: %v", master, err)
+				glog.V(0).Infof("%s failed to send to %s: %v", mc.name, master, err)
 				return err
 			}
 
 			if mc.currentMaster == "" {
-				glog.V(1).Infof("Connected to %v", master)
+				glog.V(1).Infof("%s Connected to %v", mc.name, master)
 				mc.currentMaster = master
 			}
 
 			for {
 				if volumeLocation, err := stream.Recv(); err != nil {
-					glog.V(0).Infof("failed to receive from %s: %v", master, err)
+					glog.V(0).Infof("%s failed to receive from %s: %v", mc.name, master, err)
 					return err
 				} else {
 					loc := Location{
@@ -81,9 +81,11 @@ func (mc *MasterClient) tryAllMasters() {
 						PublicUrl: volumeLocation.PublicUrl,
 					}
 					for _, newVid := range volumeLocation.NewVids {
+						glog.V(0).Infof("%s: %s adds volume %d", mc.name, loc.Url, newVid)
 						mc.addLocation(newVid, loc)
 					}
 					for _, deletedVid := range volumeLocation.DeletedVids {
+						glog.V(0).Infof("%s: %s removes volume %d", mc.name, loc.Url, deletedVid)
 						mc.deleteLocation(deletedVid, loc)
 					}
 				}