seaweedfs/weed/server/master_grpc_server.go

316 lines
8.8 KiB
Go
Raw Normal View History

2017-01-10 09:01:12 +00:00
package weed_server
import (
"context"
2018-07-29 04:02:56 +00:00
"fmt"
2017-01-12 21:42:53 +00:00
"net"
"strings"
"time"
2017-01-12 21:42:53 +00:00
2018-07-29 04:02:56 +00:00
"github.com/chrislusf/raft"
2020-02-27 01:27:49 +00:00
"google.golang.org/grpc/peer"
2017-01-10 09:01:12 +00:00
"github.com/chrislusf/seaweedfs/weed/glog"
2018-05-10 06:11:54 +00:00
"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
"github.com/chrislusf/seaweedfs/weed/storage/backend"
"github.com/chrislusf/seaweedfs/weed/storage/needle"
2017-01-10 09:01:12 +00:00
"github.com/chrislusf/seaweedfs/weed/topology"
)
func (ms *MasterServer) SendHeartbeat(stream master_pb.Seaweed_SendHeartbeatServer) error {
2017-01-10 09:01:12 +00:00
var dn *topology.DataNode
t := ms.Topo
defer func() {
if dn != nil {
glog.V(0).Infof("unregister disconnected volume server %s:%d", dn.Ip, dn.Port)
t.UnRegisterDataNode(dn)
message := &master_pb.VolumeLocation{
Url: dn.Url(),
PublicUrl: dn.PublicUrl,
}
for _, v := range dn.GetVolumes() {
message.DeletedVids = append(message.DeletedVids, uint32(v.Id))
}
2019-05-26 08:05:08 +00:00
for _, s := range dn.GetEcShards() {
message.DeletedVids = append(message.DeletedVids, uint32(s.VolumeId))
}
if len(message.DeletedVids) > 0 {
ms.clientChansLock.RLock()
for _, ch := range ms.clientChans {
ch <- message
}
ms.clientChansLock.RUnlock()
}
}
}()
2017-01-10 09:01:12 +00:00
for {
heartbeat, err := stream.Recv()
2018-08-24 07:30:03 +00:00
if err != nil {
if dn != nil {
glog.Warningf("SendHeartbeat.Recv server %s:%d : %v", dn.Ip, dn.Port, err)
} else {
2019-10-25 16:44:58 +00:00
glog.Warningf("SendHeartbeat.Recv: %v", err)
}
2018-08-24 07:30:03 +00:00
return err
}
t.Sequence.SetMax(heartbeat.MaxFileKey)
2018-08-24 07:30:03 +00:00
if dn == nil {
dcName, rackName := t.Configuration.Locate(heartbeat.Ip, heartbeat.DataCenter, heartbeat.Rack)
dc := t.GetOrCreateDataCenter(dcName)
rack := dc.GetOrCreateRack(rackName)
dn = rack.GetOrCreateDataNode(heartbeat.Ip,
int(heartbeat.Port), heartbeat.PublicUrl,
int64(heartbeat.MaxVolumeCount))
2018-08-24 07:30:03 +00:00
glog.V(0).Infof("added volume server %v:%d", heartbeat.GetIp(), heartbeat.GetPort())
if err := stream.Send(&master_pb.HeartbeatResponse{
VolumeSizeLimit: uint64(ms.option.VolumeSizeLimitMB) * 1024 * 1024,
MetricsAddress: ms.option.MetricsAddress,
MetricsIntervalSeconds: uint32(ms.option.MetricsIntervalSec),
StorageBackends: backend.ToPbStorageBackends(),
2018-08-24 07:30:03 +00:00
}); err != nil {
glog.Warningf("SendHeartbeat.Send volume size to %s:%d %v", dn.Ip, dn.Port, err)
2018-08-24 07:30:03 +00:00
return err
}
}
2017-01-10 09:01:12 +00:00
2020-03-23 01:33:19 +00:00
if heartbeat.MaxVolumeCount != 0 && dn.GetMaxVolumeCount() != int64(heartbeat.MaxVolumeCount) {
delta := int64(heartbeat.MaxVolumeCount) - dn.GetMaxVolumeCount()
dn.UpAdjustMaxVolumeCountDelta(delta)
}
2019-04-26 16:32:07 +00:00
glog.V(4).Infof("master received heartbeat %s", heartbeat.String())
2018-08-24 07:30:03 +00:00
message := &master_pb.VolumeLocation{
Url: dn.Url(),
PublicUrl: dn.PublicUrl,
}
2019-04-20 18:35:20 +00:00
if len(heartbeat.NewVolumes) > 0 || len(heartbeat.DeletedVolumes) > 0 {
// process delta volume ids if exists for fast volume id updates
2019-04-30 03:22:19 +00:00
for _, volInfo := range heartbeat.NewVolumes {
2019-04-20 18:35:20 +00:00
message.NewVids = append(message.NewVids, volInfo.Id)
}
2019-04-30 03:22:19 +00:00
for _, volInfo := range heartbeat.DeletedVolumes {
2019-04-20 18:35:20 +00:00
message.DeletedVids = append(message.DeletedVids, volInfo.Id)
}
// update master internal volume layouts
t.IncrementalSyncDataNodeRegistration(heartbeat.NewVolumes, heartbeat.DeletedVolumes, dn)
}
2019-06-05 20:32:33 +00:00
if len(heartbeat.Volumes) > 0 || heartbeat.HasNoVolumes {
// process heartbeat.Volumes
newVolumes, deletedVolumes := t.SyncDataNodeRegistration(heartbeat.Volumes, dn)
for _, v := range newVolumes {
2019-04-30 03:22:19 +00:00
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 {
2019-04-20 18:35:20 +00:00
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 {
// update master internal volume layouts
t.IncrementalSyncDataNodeEcShards(heartbeat.NewEcShards, heartbeat.DeletedEcShards, dn)
for _, s := range heartbeat.NewEcShards {
message.NewVids = append(message.NewVids, s.Id)
}
for _, s := range heartbeat.DeletedEcShards {
if dn.HasVolumesById(needle.VolumeId(s.Id)) {
continue
}
message.DeletedVids = append(message.DeletedVids, s.Id)
}
}
2019-06-05 20:32:33 +00:00
if len(heartbeat.EcShards) > 0 || heartbeat.HasNoEcShards {
glog.V(1).Infof("master recieved ec shards from %s: %+v", dn.Url(), heartbeat.EcShards)
2019-05-24 06:47:49 +00:00
newShards, deletedShards := t.SyncDataNodeEcShards(heartbeat.EcShards, dn)
// broadcast the ec vid changes to master clients
for _, s := range newShards {
message.NewVids = append(message.NewVids, uint32(s.VolumeId))
2019-05-24 06:47:49 +00:00
}
for _, s := range deletedShards {
if dn.HasVolumesById(s.VolumeId) {
continue
}
message.DeletedVids = append(message.DeletedVids, uint32(s.VolumeId))
2019-05-24 06:47:49 +00:00
}
2018-08-24 07:30:03 +00:00
}
2018-08-24 07:30:03 +00:00
if len(message.NewVids) > 0 || len(message.DeletedVids) > 0 {
ms.clientChansLock.RLock()
2019-04-20 18:35:20 +00:00
for host, ch := range ms.clientChans {
glog.V(0).Infof("master send to %s: %s", host, message.String())
2018-08-24 07:30:03 +00:00
ch <- message
}
2018-08-24 07:30:03 +00:00
ms.clientChansLock.RUnlock()
2017-01-10 09:01:12 +00:00
}
// tell the volume servers about the leader
newLeader, err := t.Leader()
if err != nil {
glog.Warningf("SendHeartbeat find leader: %v", err)
return err
}
if err := stream.Send(&master_pb.HeartbeatResponse{
Leader: newLeader,
}); err != nil {
glog.Warningf("SendHeartbeat.Send response to to %s:%d %v", dn.Ip, dn.Port, err)
return err
}
2017-01-10 09:01:12 +00:00
}
}
2018-07-28 08:30:03 +00:00
// KeepConnected keep a stream gRPC call to the master. Used by clients to know the master is up.
// And clients gets the up-to-date list of volume locations
func (ms *MasterServer) KeepConnected(stream master_pb.Seaweed_KeepConnectedServer) error {
req, err := stream.Recv()
if err != nil {
return err
}
2018-07-28 08:30:03 +00:00
if !ms.Topo.IsLeader() {
return ms.informNewLeader(stream)
2018-07-28 08:30:03 +00:00
}
peerAddress := findClientAddress(stream.Context(), req.GrpcPort)
// only one shell can be connected at any time
if req.Name == "shell" {
if ms.currentAdminShellClient == ""{
ms.currentAdminShellClient = peerAddress
defer func() {
ms.currentAdminShellClient = ""
}()
} else {
return fmt.Errorf("only one concurrent shell allowed, but another shell is already connected from %s", peerAddress)
}
}
stopChan := make(chan bool)
clientName, messageChan := ms.addClient(req.Name, peerAddress)
defer ms.deleteClient(clientName)
2018-07-28 08:17:35 +00:00
for _, message := range ms.Topo.ToVolumeLocations() {
if err := stream.Send(message); err != nil {
return err
}
}
go func() {
for {
_, err := stream.Recv()
if err != nil {
glog.V(2).Infof("- client %v: %v", clientName, err)
stopChan <- true
break
}
}
}()
ticker := time.NewTicker(5 * time.Second)
for {
select {
case message := <-messageChan:
if err := stream.Send(message); err != nil {
glog.V(0).Infof("=> client %v: %+v", clientName, message)
return err
}
case <-ticker.C:
if !ms.Topo.IsLeader() {
return ms.informNewLeader(stream)
}
case <-stopChan:
return nil
}
}
return nil
}
func (ms *MasterServer) informNewLeader(stream master_pb.Seaweed_KeepConnectedServer) error {
leader, err := ms.Topo.Leader()
if err != nil {
2019-07-31 09:09:04 +00:00
glog.Errorf("topo leader: %v", err)
return raft.NotLeaderError
}
if err := stream.Send(&master_pb.VolumeLocation{
Leader: leader,
}); err != nil {
return err
}
return nil
}
func (ms *MasterServer) addClient(clientType string, clientAddress string) (clientName string, messageChan chan *master_pb.VolumeLocation) {
clientName = clientType + "@" + clientAddress
glog.V(0).Infof("+ client %v", clientName)
messageChan = make(chan *master_pb.VolumeLocation)
ms.clientChansLock.Lock()
ms.clientChans[clientName] = messageChan
ms.clientChansLock.Unlock()
return
}
func (ms *MasterServer) deleteClient(clientName string) {
glog.V(0).Infof("- client %v", clientName)
ms.clientChansLock.Lock()
delete(ms.clientChans, clientName)
ms.clientChansLock.Unlock()
}
func findClientAddress(ctx context.Context, grpcPort uint32) string {
// fmt.Printf("FromContext %+v\n", ctx)
pr, ok := peer.FromContext(ctx)
if !ok {
glog.Error("failed to get peer from ctx")
return ""
}
if pr.Addr == net.Addr(nil) {
glog.Error("failed to get peer address")
return ""
}
if grpcPort == 0 {
return pr.Addr.String()
}
if tcpAddr, ok := pr.Addr.(*net.TCPAddr); ok {
externalIP := tcpAddr.IP
return fmt.Sprintf("%s:%d", externalIP, grpcPort)
}
return pr.Addr.String()
}
2020-03-02 06:21:13 +00:00
func (ms *MasterServer) ListMasterClients(ctx context.Context, req *master_pb.ListMasterClientsRequest) (*master_pb.ListMasterClientsResponse, error) {
resp := &master_pb.ListMasterClientsResponse{}
ms.clientChansLock.RLock()
defer ms.clientChansLock.RUnlock()
for k := range ms.clientChans {
if strings.HasPrefix(k, req.ClientType+"@") {
resp.GrpcAddresses = append(resp.GrpcAddresses, k[len(req.ClientType)+1:])
}
}
return resp, nil
}