lsm/seaweedfs
1
0
Fork 0
mirror of https://github.com/seaweedfs/seaweedfs.git synced 2025-05-08 08:27:48 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor https://github.com/seaweedfs/seaweedfs/pull/3616 (#3625)

Browse Source
This commit is contained in:
Konstantin Lebedev 2022-09-08 11:23:33 +05:00 committed by GitHub
parent 7de112943b
commit 31d2f77ceb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 117 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

234
weed/server/master_grpc_server.go
View File

@ -104,136 +104,136 @@ func (ms *MasterServer) SendHeartbeat(stream master_pb.Seaweed_SendHeartbeatServ
return err return err
} }
if ms.Topo.IsLeader() { if !ms.Topo.IsLeader() {
ms.Topo.Sequence.SetMax(heartbeat.MaxFileKey) // tell the volume servers about the leader
newLeader, err := ms.Topo.Leader()
if dn == nil { if err != nil {
dcName, rackName := ms.Topo.Configuration.Locate(heartbeat.Ip, heartbeat.DataCenter, heartbeat.Rack) glog.Warningf("SendHeartbeat find leader: %v", err)
dc := ms.Topo.GetOrCreateDataCenter(dcName) return err
rack := dc.GetOrCreateRack(rackName) }
dn = rack.GetOrCreateDataNode(heartbeat.Ip, int(heartbeat.Port), int(heartbeat.GrpcPort), heartbeat.PublicUrl, heartbeat.MaxVolumeCounts) if err := stream.Send(&master_pb.HeartbeatResponse{
glog.V(0).Infof("added volume server %d: %v:%d %v", dn.Counter, heartbeat.GetIp(), heartbeat.GetPort(), heartbeat.LocationUuids) Leader: string(newLeader),
uuidlist, err := ms.RegisterUuids(heartbeat) }); err != nil {
if err != nil { if dn != nil {
if stream_err := stream.Send(&master_pb.HeartbeatResponse{ glog.Warningf("SendHeartbeat.Send response to %s:%d %v", dn.Ip, dn.Port, err)
DuplicatedUuids: uuidlist, } else {
}); stream_err != nil { glog.Warningf("SendHeartbeat.Send response %v", err)
glog.Warningf("SendHeartbeat.Send DuplicatedDirectory response to %s:%d %v", dn.Ip, dn.Port, stream_err)
return stream_err
}
return err
} }
return err
}
continue
}
if err := stream.Send(&master_pb.HeartbeatResponse{ ms.Topo.Sequence.SetMax(heartbeat.MaxFileKey)
VolumeSizeLimit: uint64(ms.option.VolumeSizeLimitMB) * 1024 * 1024, if dn == nil {
}); err != nil { dcName, rackName := ms.Topo.Configuration.Locate(heartbeat.Ip, heartbeat.DataCenter, heartbeat.Rack)
glog.Warningf("SendHeartbeat.Send volume size to %s:%d %v", dn.Ip, dn.Port, err) dc := ms.Topo.GetOrCreateDataCenter(dcName)
return err rack := dc.GetOrCreateRack(rackName)
dn = rack.GetOrCreateDataNode(heartbeat.Ip, int(heartbeat.Port), int(heartbeat.GrpcPort), heartbeat.PublicUrl, heartbeat.MaxVolumeCounts)
glog.V(0).Infof("added volume server %d: %v:%d %v", dn.Counter, heartbeat.GetIp(), heartbeat.GetPort(), heartbeat.LocationUuids)
uuidlist, err := ms.RegisterUuids(heartbeat)
if err != nil {
if stream_err := stream.Send(&master_pb.HeartbeatResponse{
DuplicatedUuids: uuidlist,
}); stream_err != nil {
glog.Warningf("SendHeartbeat.Send DuplicatedDirectory response to %s:%d %v", dn.Ip, dn.Port, stream_err)
return stream_err
} }
stats.MasterReceivedHeartbeatCounter.WithLabelValues("dataNode").Inc() return err
dn.Counter++
} }
dn.AdjustMaxVolumeCounts(heartbeat.MaxVolumeCounts) if err := stream.Send(&master_pb.HeartbeatResponse{
VolumeSizeLimit: uint64(ms.option.VolumeSizeLimitMB) * 1024 * 1024,
glog.V(4).Infof("master received heartbeat %s", heartbeat.String()) }); err != nil {
stats.MasterReceivedHeartbeatCounter.WithLabelValues("total").Inc() glog.Warningf("SendHeartbeat.Send volume size to %s:%d %v", dn.Ip, dn.Port, err)
return err
message := &master_pb.VolumeLocation{
Url: dn.Url(),
PublicUrl: dn.PublicUrl,
DataCenter: dn.GetDataCenterId(),
} }
if len(heartbeat.NewVolumes) > 0 { stats.MasterReceivedHeartbeatCounter.WithLabelValues("dataNode").Inc()
stats.FilerRequestCounter.WithLabelValues("newVolumes").Inc() dn.Counter++
}
dn.AdjustMaxVolumeCounts(heartbeat.MaxVolumeCounts)
glog.V(4).Infof("master received heartbeat %s", heartbeat.String())
stats.MasterReceivedHeartbeatCounter.WithLabelValues("total").Inc()
message := &master_pb.VolumeLocation{
Url: dn.Url(),
PublicUrl: dn.PublicUrl,
DataCenter: dn.GetDataCenterId(),
}
if len(heartbeat.NewVolumes) > 0 {
stats.FilerRequestCounter.WithLabelValues("newVolumes").Inc()
}
if len(heartbeat.DeletedVolumes) > 0 {
stats.FilerRequestCounter.WithLabelValues("deletedVolumes").Inc()
}
if len(heartbeat.NewVolumes) > 0 || len(heartbeat.DeletedVolumes) > 0 {
// process delta volume ids if exists for fast volume id updates
for _, volInfo := range heartbeat.NewVolumes {
message.NewVids = append(message.NewVids, volInfo.Id)
} }
if len(heartbeat.DeletedVolumes) > 0 { for _, volInfo := range heartbeat.DeletedVolumes {
stats.FilerRequestCounter.WithLabelValues("deletedVolumes").Inc() message.DeletedVids = append(message.DeletedVids, volInfo.Id)
} }
if len(heartbeat.NewVolumes) > 0 || len(heartbeat.DeletedVolumes) > 0 { // update master internal volume layouts
// process delta volume ids if exists for fast volume id updates ms.Topo.IncrementalSyncDataNodeRegistration(heartbeat.NewVolumes, heartbeat.DeletedVolumes, dn)
for _, volInfo := range heartbeat.NewVolumes { }
message.NewVids = append(message.NewVids, volInfo.Id)
} if len(heartbeat.Volumes) > 0 || heartbeat.HasNoVolumes {
for _, volInfo := range heartbeat.DeletedVolumes { dcName, rackName := ms.Topo.Configuration.Locate(heartbeat.Ip, heartbeat.DataCenter, heartbeat.Rack)
message.DeletedVids = append(message.DeletedVids, volInfo.Id) ms.Topo.DataNodeRegistration(dcName, rackName, dn)
}
// update master internal volume layouts // process heartbeat.Volumes
ms.Topo.IncrementalSyncDataNodeRegistration(heartbeat.NewVolumes, heartbeat.DeletedVolumes, dn) stats.MasterReceivedHeartbeatCounter.WithLabelValues("Volumes").Inc()
newVolumes, deletedVolumes := ms.Topo.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 {
if len(heartbeat.Volumes) > 0 || heartbeat.HasNoVolumes { glog.V(0).Infof("master see deleted volume %d from %s", uint32(v.Id), dn.Url())
dcName, rackName := ms.Topo.Configuration.Locate(heartbeat.Ip, heartbeat.DataCenter, heartbeat.Rack) message.DeletedVids = append(message.DeletedVids, uint32(v.Id))
ms.Topo.DataNodeRegistration(dcName, rackName, dn)
// process heartbeat.Volumes
stats.MasterReceivedHeartbeatCounter.WithLabelValues("Volumes").Inc()
newVolumes, deletedVolumes := ms.Topo.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(heartbeat.NewEcShards) > 0 || len(heartbeat.DeletedEcShards) > 0 {
stats.MasterReceivedHeartbeatCounter.WithLabelValues("newEcShards").Inc()
// update master internal volume layouts
ms.Topo.IncrementalSyncDataNodeEcShards(heartbeat.NewEcShards, heartbeat.DeletedEcShards, dn)
for _, s := range heartbeat.NewEcShards {
message.NewEcVids = append(message.NewEcVids, s.Id)
}
for _, s := range heartbeat.DeletedEcShards {
if dn.HasEcShards(needle.VolumeId(s.Id)) {
continue
}
message.DeletedEcVids = append(message.DeletedEcVids, s.Id)
}
}
if len(heartbeat.EcShards) > 0 || heartbeat.HasNoEcShards {
stats.MasterReceivedHeartbeatCounter.WithLabelValues("ecShards").Inc()
glog.V(4).Infof("master received ec shards from %s: %+v", dn.Url(), heartbeat.EcShards)
newShards, deletedShards := ms.Topo.SyncDataNodeEcShards(heartbeat.EcShards, dn)
// broadcast the ec vid changes to master clients
for _, s := range newShards {
message.NewEcVids = append(message.NewEcVids, uint32(s.VolumeId))
}
for _, s := range deletedShards {
if dn.HasVolumesById(s.VolumeId) {
continue
}
message.DeletedEcVids = append(message.DeletedEcVids, uint32(s.VolumeId))
}
}
if len(message.NewVids) > 0 || len(message.DeletedVids) > 0 || len(message.NewEcVids) > 0 || len(message.DeletedEcVids) > 0 {
ms.broadcastToClients(&master_pb.KeepConnectedResponse{VolumeLocation: message})
} }
} }
// tell the volume servers about the leader if len(heartbeat.NewEcShards) > 0 || len(heartbeat.DeletedEcShards) > 0 {
newLeader, err := ms.Topo.Leader() stats.MasterReceivedHeartbeatCounter.WithLabelValues("newEcShards").Inc()
if err != nil { // update master internal volume layouts
glog.Warningf("SendHeartbeat find leader: %v", err) ms.Topo.IncrementalSyncDataNodeEcShards(heartbeat.NewEcShards, heartbeat.DeletedEcShards, dn)
return err
} for _, s := range heartbeat.NewEcShards {
if err := stream.Send(&master_pb.HeartbeatResponse{ message.NewEcVids = append(message.NewEcVids, s.Id)
Leader: string(newLeader),
}); err != nil {
if dn != nil {
glog.Warningf("SendHeartbeat.Send response to %s:%d %v", dn.Ip, dn.Port, err)
} else {
glog.Warningf("SendHeartbeat.Send response %v", err)
} }
return err for _, s := range heartbeat.DeletedEcShards {
if dn.HasEcShards(needle.VolumeId(s.Id)) {
continue
}
message.DeletedEcVids = append(message.DeletedEcVids, s.Id)
}
}
if len(heartbeat.EcShards) > 0 || heartbeat.HasNoEcShards {
stats.MasterReceivedHeartbeatCounter.WithLabelValues("ecShards").Inc()
glog.V(4).Infof("master received ec shards from %s: %+v", dn.Url(), heartbeat.EcShards)
newShards, deletedShards := ms.Topo.SyncDataNodeEcShards(heartbeat.EcShards, dn)
// broadcast the ec vid changes to master clients
for _, s := range newShards {
message.NewEcVids = append(message.NewEcVids, uint32(s.VolumeId))
}
for _, s := range deletedShards {
if dn.HasVolumesById(s.VolumeId) {
continue
}
message.DeletedEcVids = append(message.DeletedEcVids, uint32(s.VolumeId))
}
}
if len(message.NewVids) > 0 || len(message.DeletedVids) > 0 || len(message.NewEcVids) > 0 || len(message.DeletedEcVids) > 0 {
ms.broadcastToClients(&master_pb.KeepConnectedResponse{VolumeLocation: message})
} }
} }
} }