/// <summary>
/// 获取当前心跳
/// </summary>
/// <returns></returns>
public static HeartbeatRequest GetHeartBeatByCurrent()
{
HeartbeatRequest sendHeartBeat = new HeartbeatRequest();
SystemSettingService systemSettingService = new SystemSettingService();
var result = systemSettingService.GetSystemSetting();
if (result == null)
{
return(null);
}
//机器码mac地址从数据库取
sendHeartBeat.UniqueId = result.Set_Unique_Id;
//bdl_system_setting表装换成json，赋值
sendHeartBeat.SettingJSON = JsonTools.Obj2JSONStrNew <SystemSettingEntity>(result);
//项目名 智能健身赋值
sendHeartBeat.ProductName = "智能健身";
//使用期限
sendHeartBeat.UseDeadTime = result.Auth_OfflineTime.ToString().Replace("/", "-");
//冻结
if (result.User_Status == SystemSettingEntity.USER_STATUS_FREEZE)
{
//是否为冻结状态的心跳,这里不能从数据库取，否则，云通知本地锁死，本地改状态后，会再次通知云锁死本机，陷入死循环
//状态 正常0和锁定1
sendHeartBeat.Status = 1.ToString();
}
//正常
else if (result.User_Status == SystemSettingEntity.USER_STATUS_GENERAL)
{
//状态 正常0和锁定1
//默认为正常心跳
sendHeartBeat.Status = 0.ToString();
}
return(sendHeartBeat);
}
public override Task <HeartbeatResponse> Heartbeat(HeartbeatRequest request, ServerCallContext context)
{
Console.WriteLine("[RECEIVED] Heartbeat. Heartbeat for Partition: " + request.PartitionId +
"- From server+ " + request.Sending);
_storage.ResetTimeout(request.PartitionId);
return(Task.FromResult(new HeartbeatResponse()));
}
public void MergeFrom(BodyStrongMessage other)
{
if (other == null)
{
return;
}
if (other.MessageType != 0)
{
MessageType = other.MessageType;
}
switch (other.DataBodyCase)
{
case DataBodyOneofCase.HeartbeatRequest:
if (HeartbeatRequest == null)
{
HeartbeatRequest = new global::HeartbeatRequest();
}
HeartbeatRequest.MergeFrom(other.HeartbeatRequest);
break;
case DataBodyOneofCase.HeartbeatResponse:
if (HeartbeatResponse == null)
{
HeartbeatResponse = new global::HeartbeatResponse();
}
HeartbeatResponse.MergeFrom(other.HeartbeatResponse);
break;
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
public void GameState_HealthCallbackReturnsHealthy_StatusSent()
{
HeartbeatRequest request = null;
_testConfiguration = new
{
heartbeatEndpoint = "heartbeatendpoint",
sessionHostId = "serverid"
};
_mockHttpClient.Setup(x => x.SendHeartbeatAsync(It.IsAny <HeartbeatRequest>()))
.ReturnsAsync(new HeartbeatResponse
{
Operation = GameOperation.Active
})
.Callback <HeartbeatRequest>(x => request = x);
var sdk = new InternalSdk(_mockSystemOperations.Object, _mockHttpClientFactory.Object);
sdk.HealthCallback = () => true;
sdk.Start(false);
sdk.State = GameState.StandingBy;
sdk.TransitionToActiveEvent.WaitOne();
request.Should().NotBeNull();
request.CurrentGameHealth.Should().Be("Healthy");
}
public void Establish()
{
var dispatcher = A.Fake <IDispatcher>();
s_firstConsumer = A.Fake <IAmAConsumer>();
A.CallTo(() => s_firstConsumer.Name).Returns(new ConnectionName(TEST_FIRST_CONNECTION_NAME));
A.CallTo(() => s_firstConsumer.State).Returns(ConsumerState.Open);
s_secondConsumer = A.Fake <IAmAConsumer>();
A.CallTo(() => s_secondConsumer.Name).Returns(new ConnectionName(TEST_SECOND_CONNECTION_NAME));
A.CallTo(() => s_secondConsumer.State).Returns(ConsumerState.Shut);
A.CallTo(() => dispatcher.Consumers).Returns(new List <IAmAConsumer>()
{
s_firstConsumer, s_secondConsumer
});
var hostName = new HostName(Environment.MachineName + "." + System.Reflection.Assembly.GetEntryAssembly().FullName);
A.CallTo(() => dispatcher.HostName).Returns(hostName);
s_hostName = hostName;
s_heartbeatRequest = new HeartbeatRequest(new ReplyAddress(TEST_ROUTING_KEY, s_CorrelationId));
s_handler = new HeartbeatRequestCommandHandler(s_spyCommandProcessor, dispatcher);
}
private async Task SendHeartbeat()
{
var remotePeer = SelectNeighbor(_gossipNode.RemotePeers);
if (remotePeer == null)
{
Logger.Debug("SendHeartbeat is called without action");
return;
}
else
{
Logger.Debug($"SendHeartbeat is called to {remotePeer.ToString()}");
}
try
{
HeartbeatRequest message = new HeartbeatRequest(remotePeer);
message.Id = Guid.NewGuid().ToString();
message.RemoteEndPoint = _gossipNode.GossipPeer.EndPoint;
message.Members.Add(_gossipNode.GossipPeer);
message.Members.Concat(_gossipNode.RemotePeers);
await SendAsync(message, remotePeer.EndPoint);
}
catch (Exception e)
{
Logger.Warn(e);
}
}
//实现接收心跳服务
public override Task <GeneralReply> Heartbeat(HeartbeatRequest request, ServerCallContext context)
{
Console.WriteLine("Heart Get: " + request.DeviceAddress + ", " + request.DeviceIdent);
return(Task.FromResult(new GeneralReply {
Message = "Get heartbeat!"
}));
}
private void SendHeartBeat()
{
try
{
Log("Sending heartbeat to " + mTestServer + ".");
TcpClient client = new TcpClient(mTestServer, Definitions.mPortNumber);
HeartbeatRequest request = new HeartbeatRequest()
{
TestCommandID = (mCommandResponse == null ? -1 : mCommandResponse.TestCommandID),
RunCount = (mCommandResponse == null ? -1 : mCommandResponse.RunCount)
};
byte[] data = JsonHelper.ToByteStream <HeartbeatRequest>(request);
Send(client, AutomationTestMessageID.HeartBeatRequest, data);
client.Client.ReceiveTimeout = 10000; // ms timeout
int read = client.Client.Receive(mHeaderData, 8, SocketFlags.None);
if (read > 0)
{
// Data received, or connection closed
int dataLength = BitConverter.ToInt32(mHeaderData, 4);
data = new byte[dataLength];
client.Client.Receive(data, dataLength, SocketFlags.None);
var response = JsonHelper.ToObject <HeartbeatResponse>(data);
Log("Heartbeat response; TestRunning: " + response.TestRunning);
if (mProcess != null && response.TestRunning == false)
{
StopProcess("Process cancelled by database.");
}
}
client.Close();
}
catch { }
}
/// <summary>
/// Periodic communication with the service.
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns>True if the agent is to exit, false otherwise.</returns>
private async Task <bool> HeartbeatAsync(CancellationToken cancellationToken)
{
//Create the request.
var request = new HeartbeatRequest
{
UptimeSeconds = _uptimeProvider.Ellapsed.TotalSeconds,
State = _deviceStateProvider.State,
AgentVersion = await _agentUpdateService.GetCurrentVersionAsync(cancellationToken),
ApplicationVersion = await _applicationUpdateService.GetCurrentVersionAsync(cancellationToken),
RootFileSystemVersion = await _rootFileSystemUpdateService.GetCurrentVersionAsync(cancellationToken)
};
//Send the request.
var response = await _deviceApiClient.Heartbeat.HeartbeatAsync(request, cancellationToken);
//Check to see if we need to update the configuration
if (_configurationVersion == response.ConfigurationVersion)
{
_logger.Verbose("Heartbeat complete. No new configuration.");
}
else
{
_logger.Information("Downloading new configuration...");
return(await DownloadAndProcessConfigurationAsync(cancellationToken));
}
return(false);
}
public HeartbeatResponse Heartbeat(String groupId, String memberId, Int32 generationId)
{
var request = new HeartbeatRequest(groupId, generationId, memberId);
var response = (HeartbeatResponse)_client.SubmitRequest(_coordinateBroker, request);
//response.TryThrowFirstErrorOccured();
return(response);
}
//心跳事件
private async void AlarmEvtImpl_OnHeartBeat(HeartbeatRequest request)
{
try
{
}
catch (Exception exp)
{
}
}
public void HeartbeatRequest(
[Values("test", "a groupId")] string groupId,
[Values(0, 1, 20000)] int generationId,
[Values("", "an existing member")] string memberId)
{
var request = new HeartbeatRequest(groupId, generationId, memberId);
request.AssertCanEncodeDecodeRequest(0);
}
public void UnsubscribeHearbeat()
{
HeartbeatRequest hb = new HeartbeatRequest
{
Action = ActionType.Unsubscribe
};
AddMessageToQueue(hb);
}
public static void Main(string[] args)
{
//建立通道
Channel channel = new Channel("127.0.0.1:50051", ChannelCredentials.Insecure);
//新建客户端
var client = new SurvCenterService.SurvCenterServiceClient(channel);
//任意设置一些属性值
String user = "******";
//新建报警事件
Event nevent = new Event();
nevent.Description = user;
//新建报警事件图片
AnnotatedImage anno_img = new AnnotatedImage();
//将二进制JPEG码流拷贝到报警事件图片中
anno_img.Img = Google.Protobuf.ByteString.CopyFrom(new byte[] { 1, 2 });
//设置报警事件图片中的目标
Target target = new Target {
X = 1, Y = 2, W = 3, H = 4, Type = Target.Types.Type.Person
};
anno_img.Targets.Add(target);
nevent.AnnoImgs.Add(anno_img);
//向服务器提交报警事件
System.Collections.Generic.List <AsyncUnaryCall <GeneralReply> > rets = new System.Collections.Generic.List <AsyncUnaryCall <GeneralReply> >();
for (int i = 0; i < 1000; i++)
{
AsyncUnaryCall <GeneralReply> ret = client.ReportEventAsync(nevent);
rets.Add(ret);
}
Console.WriteLine("number: ", rets.Count);
for (int i = 0; i < rets.Count; ++i)
{
rets[i].ResponseAsync.Wait();
Console.WriteLine("reportevent: " + rets[i].ResponseAsync.Result);
}
//Console.WriteLine("Greeting: " + reply.Message);
HeartbeatRequest hr = new HeartbeatRequest();
hr.DeviceAddress = "127.0.0.1";
hr.DeviceIdent = "i am a deivce";
//异步调用心跳请求
var hr_reply = client.HeartbeatAsync(hr);
//等待异步操作返回，具体实现时可以使用完整异步机制
hr_reply.ResponseAsync.Wait();
Console.WriteLine("Heartbeat over: " + hr_reply.ResponseAsync.Result);
channel.ShutdownAsync().Wait();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
/// <summary>
/// Handles emulated <see cref="HeartbeatRequest"/> messages.
/// </summary>
/// <param name="request">The received message.</param>
/// <returns>The tracking <see cref="Task"/>.</returns>
private async Task OnEmulatedHeartbeatRequestAsync(HeartbeatRequest request)
{
if (Settings.DebugIgnoreHeartbeats)
{
// Ignore heartbeats so unit tests can verify the correct behavior.
return;
}
await EmulatedLibraryClient.SendReplyAsync(request, new HeartbeatReply());
}
public void When_mapping_from_a_message_to_a_heartbeat_request()
{
_request = _mapper.MapToRequest(_message);
//_should_put_the_message_reply_topic_into_the_address
_request.ReplyAddress.Topic.Should().Be(TOPIC);
//_should_put_the_message_correlation_id_into_the_address
_request.ReplyAddress.CorrelationId.Should().Be(_correlationId);
//_should_set_the_id_of_the_request
_request.Id.Should().Be(_commandId);
}
// Command callback for handling heartbeats from clients indicating client is connect and missed heartbeat counter should be reset
private HeartbeatResponse OnHeartbeat(HeartbeatRequest Request, ICommandCallerInfo CallerInfo)
{
// Heartbeats are issued by clients authoritative over the player entity and should only be sending heartbeats for themselves
if (Request.senderEntityId == thisEntityId)
{
// Reset missed heartbeat counter to avoid entity being deleted
PlayerLifecycleWriter.Send(new PlayerLifecycle.Update().SetCurrentMissedHeartbeats(0));
}
// Acknowledge command receipt
return(new HeartbeatResponse());
}
protected override void OnReceiveConsumer(object sender, BasicDeliverEventArgs ea)
{
var heartbeatReq = HeartbeatRequest.FromBytes(ea.Body);
if (heartbeatReq.SenderUID == serviceID)
{
return;
}
OnHeartbeatAnswerReceived?.Invoke(this, new HeartbeatAnswerReceivedArgs(heartbeatReq));
}
public override Task <HeartbeatReply> SendHeartbeat(HeartbeatRequest request, ServerCallContext context)
{
if (request.StopRequested)
{
Environment.Exit(0);
}
return(Task.FromResult(new HeartbeatReply()
{
StopAck = request.StopRequested
}));
}
public void When_mapping_from_a_message_to_a_heartbeat_request()
{
_request = _mapper.MapToRequest(_message);
//_should_put_the_message_reply_topic_into_the_address
Assert.AreEqual(TOPIC, _request.ReplyAddress.Topic);
//_should_put_the_message_correlation_id_into_the_address
Assert.AreEqual(_correlationId, _request.ReplyAddress.CorrelationId);
//_should_set_the_id_of_the_request
Assert.AreEqual(_commandId, _request.Id);
}
private void HeartbeatThread(object state)
{
HeartbeatRequest request = new HeartbeatRequest();
request.UserID = GlobalResourceManager.CurrentUser.UserID;
while (true)
{
Thread.Sleep(2000);
TCPClient.Singleton.SendProtoMessage(CMD.HeartbeatRequestCMD, request);
}
}
public void SendHeartbeat()
{
if (this.IsConnected)
{
HeartbeatRequest heartbeat = new HeartbeatRequest();
heartbeat.DeviceNumber = this.DeviceNumberHex;
heartbeat.Foot = heartbeat.BuildFoot();
this.LocalSocket.BeginSend(heartbeat.BuildFull());
}
}
public void AnswerHeartbeatRequest(HeartbeatRequest heartbeatReq)
{
if (!IsActive)
{
throw new InvalidOperationException("Module 'HeartbeatAnswerModule' is not active");
}
var localChanges = getKnownChanges();
GetOutdatedChanges(localChanges, heartbeatReq.KnownChanges, out var outdatedLocalChanges, out var outdatedRequestChanges);
NotifyOfOutdatedLocalChanges(outdatedLocalChanges);
NotifyOfOutdatedRequestChanges(outdatedRequestChanges, localChanges);
}
private Task <HeartbeatResponse> HeartbeatAsync(HeartbeatRequest request, CancellationToken token)
{
return(RunFuncAsync(
request.Header,
(context, session) => Task.FromResult(new HeartbeatResponse {
Header = ResponseHeader.Success(context.StartTime)
}),
(context, errorMessage) => new HeartbeatResponse {
Header = ResponseHeader.Failure(context.StartTime, errorMessage)
},
// It is important to trace heartbeat messages because lack of them will cause sessions to expire.
trace: true));
}
public void HeartbeatRequest()
{
var request = new HeartbeatRequest();
request.GroupId = Guid.NewGuid().ToString();
request.GenerationId = _random.Next();
request.MemberId = Guid.NewGuid().ToString();
Stream binary1 = new MemoryStream();
request.Serialize(binary1);
binary1.Seek(0L, SeekOrigin.Begin);
var request2 = new HeartbeatRequest();
request2.Deserialize(binary1);
var compareLogic = new CompareLogic();
var result = compareLogic.Compare(request, request2);
Assert.True(result.AreEqual);
Stream binary2 = new MemoryStream();
request.Serialize(binary2);
Assert.Equal(binary1.Length, binary2.Length);
using (var stream1 = new MemoryStream())
using (var stream2 = new MemoryStream()) {
binary1.Seek(0L, SeekOrigin.Begin);
binary1.CopyTo(stream1);
binary2.Seek(0L, SeekOrigin.Begin);
binary2.CopyTo(stream2);
Assert.Equal(stream1.Length, stream2.Length);
stream1.Seek(0L, SeekOrigin.Begin);
var bytes1 = stream1.ToArray();
stream2.Seek(0L, SeekOrigin.Begin);
var bytes2 = stream2.ToArray();
Assert.Equal(bytes1.Length, bytes2.Length);
for (int i = 0; i < bytes1.Length; i++)
{
Assert.Equal(bytes1[i], bytes2[i]);
}
}
}
/// <summary>
/// Implements a heartbeat request for a session.
/// </summary>
private Task <HeartbeatResponse> HeartbeatAsync(HeartbeatRequest request, CancellationToken token)
{
LogRequestHandling();
DateTime startTime = DateTime.UtcNow;
return(RunFuncAndReportAsync(
request.Header.SessionId,
session => Task.FromResult(new HeartbeatResponse {
Header = ResponseHeader.Success(startTime)
}),
errorMessage => new HeartbeatResponse {
Header = ResponseHeader.Failure(startTime, errorMessage)
}));
}
public static Datagram ResolveRequest(byte[] rawDatagram)
{
Datagram result = null;
Datagram temp = new DatagramRequest();
temp.Parse(rawDatagram);
if (DatagramResolver.HeadTag.SequenceEqual(temp.Head))
{
if (temp.CommandCode.SequenceEqual(HeartbeatRequest.FixCommandCode) &&
rawDatagram.Length == HeartbeatRequest.Length)
{
result = new HeartbeatRequest();
}
if (temp.CommandCode.SequenceEqual(LoginRequest.FixCommandCode) &&
rawDatagram.Length == LoginRequest.Length)
{
result = new LoginRequest();
}
if (temp.CommandCode.SequenceEqual(BlacklistQueryRequest.FixCommandCode) &&
rawDatagram.Length == BlacklistQueryRequest.Length)
{
result = new BlacklistQueryRequest();
}
if (temp.CommandCode.SequenceEqual(BlacklistDownloadRequest.FixCommandCode) &&
rawDatagram.Length == BlacklistDownloadRequest.Length)
{
result = new BlacklistDownloadRequest();
}
if (temp.CommandCode.SequenceEqual(CurrencyRequest.FixCommandCode) &&
rawDatagram.Length == CurrencyRequest.Length)
{
result = new CurrencyRequest();
}
if (result != null)
{
result.Parse(rawDatagram);
}
}
return result;
}
private async Task ReceiveHeartbeat(HeartbeatRequest msg)
{
var needReply = MergeLists(msg.Peer, msg.Members);
if (needReply)
{
HeartbeatResponse o = new HeartbeatResponse();
o.Members.Add(_gossipNode.GossipPeer);
o.Members.Concat(_gossipNode.RemotePeers);
o.RemoteEndPoint = _gossipNode.GossipPeer.EndPoint;
o.Id = Guid.NewGuid().ToString();
o.RequestMessageId = msg.Id;
await SendAsync(o, msg.RemoteEndPoint);
}
}
private void HandleHeartbeat(int dataLength)
{
byte[] data = ReadBuffer(dataLength);
if (data != null)
{
HeartbeatRequest request = JsonHelper.ToObject <HeartbeatRequest>(data);
var response = mVMInstance.HandleHeartbeat(request);
data = JsonHelper.ToByteStream <HeartbeatResponse>(response);
SendData(AutomationTestMessageID.HeartBeatResponse, data);
}
else
{
mVMInstance.HandleHeartbeat(null);
SendData(AutomationTestMessageID.HeartBeatResponse, null);
}
}
public override Task <GeneralReply> Heartbeat(HeartbeatRequest request, ServerCallContext context)
{
try
{
if (OnHeartBeat != null)
{
OnHeartBeat(request);
}
}
catch (Exception exp)
{
}
return(Task.FromResult(new GeneralReply()
{
ErrorCode = 0, Message = DateTime.Now.ToString("yyyy:MM:dd:HH:mm:ss")
}));
}
/// <summary>
/// 获取当前心跳
/// </summary>
/// <returns></returns>
public static HeartbeatRequest GetHeartBeatByCurrent()
{
HeartbeatRequest sendHeartBeat = new HeartbeatRequest();
//不属于未注册状态
SetterDAO setterDAO = new SetterDAO();
Setter setter = setterDAO.getSetter();
if (setterDAO.ListAll().Count != 1)
{
//设置表没有唯一标识，直接返回
return(null);
}
AuthDAO authDAO = new AuthDAO();
var result = authDAO.GetByAuthLevel(Auther.AUTH_LEVEL_MANAGER);
if (result == null)
{
return(null);
}
//机器码mac地址从本地拿
sendHeartBeat.UniqueId = setter.Set_Unique_Id;
//setting表装换成json，赋值
sendHeartBeat.SettingJSON = JsonTools.Obj2JSONStrNew <Setter>(setter);
//项目名 医疗康复赋值
sendHeartBeat.ProductName = "医疗康复";
//使用期限
sendHeartBeat.UseDeadTime = result.Auth_OfflineTime.ToString().Replace("/", "-");
//地理位置
//sendHeartBeat.Address = setter.Set_Organizationaddress;
//冻结
if (result.User_Status == Auther.USER_STATUS_FREEZE)
{
//是否为冻结状态的心跳,这里不能从数据库取，否则，云通知本地锁死，本地改状态后，会再次通知云锁死本机，陷入死循环
//状态 正常0和锁定1
sendHeartBeat.Status = 1.ToString();
}
//正常
else if (result.User_Status == Auther.USER_STATUS_GENERAL)
{
//状态 正常0和锁定1
//默认为正常心跳
sendHeartBeat.Status = 0.ToString();
}
return(sendHeartBeat);
}
public void SendHeartbeat()
{
if (this.IsConnected)
{
HeartbeatRequest heartbeat = new HeartbeatRequest();
heartbeat.DeviceNumber = this.DeviceNumberHex;
heartbeat.Foot = heartbeat.BuildFoot();
this.LocalSocket.BeginSend(heartbeat.BuildFull());
}
}
