/// <summary>
/// 接受来自leader节点的心跳请求
/// </summary>
/// <param name="heartBeat"></param>
/// <returns></returns>
public async Task <HeartBeatResponse> Handle(HeartBeat heartBeat)
{
_logger.LogInformation($"leader 接收{heartBeat.LeaderId}的心跳");
//如果当前任期大于心跳任期
var rs = new HeartBeatResponse();
var currentLog = _blockDataManager.GetLastBlockEntity(_node.GetChannelId());
rs.Term = CurrentState.CurrentTerm;
rs.Height = currentLog.Header.Number;
rs.BlockCurrentHash = currentLog.Header.DataHash;
rs.BlockPreviousHash = currentLog.Header.PreviousHash;
rs.LeaderId = CurrentState.LeaderId;
rs.Success = false;
//当前任期大于leader任期 返回当前任期，leaderID和最新日志信息
if (CurrentState.CurrentTerm > heartBeat.Term)
{
return(rs);
}
else
//任期小于等于leader任期，则返回最新日志,改变自身状态(觉得自身状态和自己最新的日志的任期一致)
{
CurrentState.LeaderId = heartBeat.LeaderId;
rs.LeaderId = heartBeat.LeaderId;
rs.Success = true;
return(rs);
}
}
private void CategoryInquery(IAsyncResult ar)
{
HeartBeatResponse heartBeatResponse = this.EndHeartBeat(ar);
if (heartBeatResponse == null || heartBeatResponse.Result == Result.ProductListUpdated)
{
this.BeginCategoryInquiry(new AsyncCallback(this.ProductInquery), null);
}
Scheduler.Schedule(this.thread, Job.Create <DateTime>(new Action <DateTime>(this.HeartBeat), this.releaseTicks), new TimeSpan(0, 2, 0));
}
public async Task <HeartBeatResponse> Handle(HeartBeat heartBeat)
{
try
{
///接受到了消息 停止计时 等待处理
_electionTimer.Change(Timeout.Infinite, Timeout.Infinite);
_logger.LogInformation($"接收到来自{heartBeat.LeaderId} 任期 {heartBeat.Term} 的心跳");
var rs = new HeartBeatResponse();
///获取当前节点最新的区块
var currentBlock = _blockDataManager.GetLastBlockEntity(_node.GetChannelId());
//如果区块为0则初始化区块对象
if (currentBlock == null)
{
currentBlock = new QMBlockSDK.MongoModel.MongoBlock();
currentBlock.Header.Number = -1;
currentBlock.Header.Term = -1;
}
rs.Term = CurrentState.CurrentTerm;
rs.LeaderId = CurrentState.LeaderId;
rs.Height = currentBlock.Header.Number;
rs.BlockCurrentHash = currentBlock.Header.DataHash;
rs.BlockPreviousHash = currentBlock.Header.PreviousHash;
rs.LeaderId = CurrentState.LeaderId;
rs.Success = false;
//当前任期大于leader任期 返回当前任期，leaderID和最新日志信息
if (CurrentState.CurrentTerm > heartBeat.Term)
{
return(rs);
}
//任期小于等于leader任期，
//则返回最新日志,改变自身状态(觉得自身状态和自己最新的日志的任期一致)
else
{
CurrentState.LeaderId = heartBeat.LeaderId;
CurrentState.CurrentTerm = heartBeat.Term;
rs.LeaderId = heartBeat.LeaderId;
rs.Success = true;
_logger.LogInformation("请求合法，刷新选举计时器");
//同步指定高度的区块
await SynchronizedBlockAsync(heartBeat.Height);
//接收成功的信息才刷新计时器
//ResetElectionTimer();
return(rs);
}
}
finally
{
//接收成功的信息才刷新计时器
ResetElectionTimer();
}
}
private Task HandleResponseAsync(Response response, CancellationToken ct)
{
return(response switch
{
PlayerRegistered playerRegistered => OnPlayerRegistered(playerRegistered, ct),
MapUpdated mapUpdated => OnMapUpdated(mapUpdated, ct),
GameLink gameLink => OnGameLink(gameLink),
GameStarting gameStarting => OnGameStarting(gameStarting),
GameResult gameResult => OnInfoEvent(gameResult),
CharacterStunned characterStunned => OnInfoEvent(characterStunned),
HeartBeatResponse heartBeatResponse => OnHearBeatEvent(heartBeatResponse, ct),
GameEnded gameEnded => OnGameEnded(gameEnded),
TournamentEnded tournamentEnded => OnTournamentEnded(tournamentEnded),
InvalidPlayerName invalidPlayerName => OnInfoEvent(invalidPlayerName),
_ => Task.CompletedTask
});
public static void HeartBeatRequestCallback(Message message)
{
try
{
HeartBeatResponse response = null;
response = JsonTools.UnSerializeFromString <HeartBeatResponse>(message.GetMessageBuffer());
if (response.ret == -1)
{
UIType <string> warnText = new UIType <string>(UICacheKeys.MESSAGE_STRING, "网络连接中断");
UIMgr.Instance.ShowPanel <WarnBox>(UIPanelPath.WARN_MESSAGE_BOX);
HeartBeat.Instance.Stop();
NetworkMgr.Instance.Close();
}
}
catch (Exception ex)
{
Debug.Log("HeartBeatRequestCallback parse error. " + ex.ToString());
}
}
//peer级别
//[Authorize(Roles = "Peer")]
public override async Task <NetResponse> HeartBeat(NetRequest request, ServerCallContext context)
{
try
{
var model = Newtonsoft.Json.JsonConvert.DeserializeObject <HeartBeat>(request.Data);
var rs = await _raftNet.Handle(model);
return(new NetResponse()
{
Data = Newtonsoft.Json.JsonConvert.SerializeObject(rs)
});
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
var rs = new HeartBeatResponse();
rs.Success = false;
return(new NetResponse()
{
Data = Newtonsoft.Json.JsonConvert.SerializeObject(rs)
});
}
}
protected override void ConstructeResponse()
{
HeartBeatResponse response = new HeartBeatResponse(_session, _request);
_sendingBuffer = response.BuildResponse();
}
private void OnHearBeatEvent(HeartBeatResponse heartBeat)
{
Console.WriteLine(heartBeat);
SendHearBeat();
}
/// <summary>
/// 单独给每一个节点发送心跳信息 和日志信息，
/// 如果收到有的节点返回的任期大于当前的任期则节点变为follower
/// </summary>
/// <returns></returns>
private async Task SendHeartbatAsync()
{
var peers = _configProviders.GetPeersExcludeSelf(_node.GetChannelId());
if (peers.Count() == 0)
{
return;
}
//根据提供的节点进行数据访问
PeerStates = PeerStates.Where(p => peers.Select(x => x.Id).Contains(p.Peer.Id)).ToList();
if (PeerStates.Count != peers.Count)
{
var peersNotInPeerStates = peers.Where(p => !PeerStates.Select(x => x.Peer.Id).Contains(p.Id)).ToList();
peersNotInPeerStates.ForEach(p =>
{
var model = new PeerState(p);
PeerStates.Add(new PeerState(p));
});
}
var lastlog = _blockDataManager.GetLastBlockEntity(_node.GetChannelId());
var heartbeat = new HeartBeat();
heartbeat.Term = CurrentState.CurrentTerm;
heartbeat.LeaderId = CurrentState.Id;
heartbeat.Height = lastlog.Header.Number;
heartbeat.LogCurrentHash = lastlog.Header.DataHash;
heartbeat.LogPreviousHash = lastlog.Header.PreviousHash;
heartbeat.LogTerm = lastlog.Header.Term;
heartbeat.ChannelId = lastlog.Header.ChannelId;
//获取所需要的区块数据
var needBecomeFollower = false;
HeartBeatResponse heartResponse = null;
foreach (var item in PeerStates)
{
if (item.HeartBeatTask == null)
{
item.HeartBeatTask = HeartBeatRequest(item.Peer, heartbeat);
}
else
{
_logger.LogInformation($"{item.Peer.Id} {item.HeartBeatTask.IsCompleted}");
//请求完毕就可以重新再发生请求
if (item.HeartBeatTask != null && item.HeartBeatTask.IsCompleted)
{
try
{
var rs = await item.HeartBeatTask;
//如果返回节点任期大于当前节点任期 则需要变更节点状态
if (rs.Term > CurrentState.CurrentTerm)
{
needBecomeFollower = true;
heartResponse = rs;
break;
}
item.CurrentHash = rs.BlockCurrentHash;
item.PreviousHash = rs.BlockPreviousHash;
item.Height = rs.Height;
item.LogTerm = rs.LogTerm;
}
catch (Exception ex)
{
_logger.LogInformation($"心跳请求失败{ex.Message}");
}
finally
{
item.HeartBeatTask = null;
}
}
}
}
if (needBecomeFollower)
{
CurrentState.CurrentTerm = heartbeat.Term;
BecomeFollower();
}
}
public void HeartBeat(HeartBeatResponse heatBeatData)
{
setValuesLongOkSignal.Dispatch();
lastHeartBeatTime = DateTime.Now;
}
