protected virtual void AcceptHeartbeat(MessageEventArgs message)
{
try
{
HeartbeatResponse response = message.Data.FromJson <HeartbeatResponse>();
if (response.ResponseStatus == null)
{
_heartbeatStatus.AddEvent("null");
}
else
{
_heartbeatStatus.AddEvent(response.ResponseStatus.Status);
}
_acceptHeartbeatLatency.AddValue(DateTimeUtils.CurrentTimeInMilliseconds - _heartbeatAcceptStartTime);
if (response.ResponseStatus.IsServiceDown())
{
_sessionContext.Markdown();
}
if (response.ResponseStatus.IsFail())
{
_log.Warn("heartbeat failed: " + response.ResponseStatus.Message);
}
else if (response.ResponseStatus.isPartialFail())
{
_log.Info("heartbeat partial failed: " + response.ResponseStatus.Message);
}
Register(response.FailedInstances);
}
catch (Exception e)
{
_log.Warn("handle heartbeat message failed", e);
}
}
private async Task SendHeartbeatAsync(Context context)
{
StructResult <int> sessionResult = await _sessionState.GetIdAsync();
if (!sessionResult.Succeeded)
{
// We do not even attempt to send a heartbeat if we can't get a session ID.
return;
}
int sessionId = sessionResult.Data;
try
{
HeartbeatResponse response = await _client.HeartbeatAsync(new HeartbeatRequest { Header = new RequestHeader(context.Id, sessionId) });
// Check for null header here as a workaround to a known service bug, which returns null headers on successful heartbeats.
if (response?.Header != null && !response.Header.Succeeded)
{
_tracer.Warning(
context,
$"Heartbeat failed: ErrorMessage=[{response.Header.ErrorMessage}] Diagnostics=[{response.Header.Diagnostics}]");
// Nor do we attempt to reset a session ID based on a failed heartbeat.
}
}
catch (Exception ex)
{
string message = (ex is RpcException rpcEx) && (rpcEx.Status.StatusCode == StatusCode.Unavailable)
? "Heartbeat failed to detect running service."
: $"Heartbeat failed: [{ex}]";
_tracer.Debug(context, message);
}
}
private async Task HeartbeatAsync(Context context, int originalSessionId)
{
var sessionContext = await CreateSessionContextAsync(context);
if (!sessionContext)
{
// We do not even attempt to send a heartbeat if we can't get a session ID.
Tracer.Warning(context, $"Skipping heartbeat. Can't find session context for SessionId={originalSessionId}.");
return;
}
// It is very important for the heartbeat not to get stuck forever because if the service won't receive
// any calls for some time, the session will be closed on the service side due to inactivity.
// This operation passes a cancellation token to gracefully cancel the request,
// and then uses hard timeout to abort the async operation if the operation is not gracefully canceled.
var operationContext = new OperationContext(context);
// Can't use original session id, because it may have changed due to reconnect.
var sessionId = sessionContext.Value.SessionId;
await operationContext.PerformOperationAsync(
Tracer,
() => sendHeartbeatAsync().WithTimeoutAsync(HeartbeatHardTimeout),
extraEndMessage : r => $"SessionId={sessionId}")
.IgnoreFailure(); // The error was already traced.
async Task <BoolResult> sendHeartbeatAsync()
{
using var timeoutCancellationSource = new CancellationTokenSource(_heartbeatTimeout);
try
{
HeartbeatResponse response = await HeartbeatAsync(new HeartbeatRequest { Header = sessionContext.Value.CreateHeader() }, timeoutCancellationSource.Token);
// Check for null header here as a workaround to a known service bug, which returns null headers on successful heartbeats.
if (response?.Header != null && !response.Header.Succeeded)
{
// Heartbeat failed.
// Maybe the session is stale. Resetting it without throwing an exception.
await ResetOnUnknownSessionAsync(context, response.Header, sessionId, throwFailures : false);
var error = new BoolResult(response.Header.ErrorMessage, response.Header.Diagnostics);
return(new BoolResult(error, "Heartbeat failed"));
}
return(BoolResult.Success);
}
catch (Exception ex)
{
if (timeoutCancellationSource.IsCancellationRequested)
{
return(new BoolResult(ex, $"Heartbeat timed out out after '{_heartbeatTimeout}'."));
}
string message = (ex is RpcException rpcEx) && (rpcEx.Status.StatusCode == StatusCode.Unavailable)
? "Heartbeat failed to detect running service."
: $"Heartbeat failed: [{ex}]";
return(new BoolResult(ex, message));
}
}
}
private async Task SendHeartbeatAsync(Context context)
{
var sessionContext = await CreateSessionContextAsync(context);
if (!sessionContext)
{
// We do not even attempt to send a heartbeat if we can't get a session ID.
return;
}
try
{
HeartbeatResponse response = await HeartbeatAsync(new HeartbeatRequest { Header = sessionContext.Value.CreateHeader() });
// Check for null header here as a workaround to a known service bug, which returns null headers on successful heartbeats.
if (response?.Header != null && !response.Header.Succeeded)
{
Tracer.Warning(
context,
$"Heartbeat failed: ErrorMessage=[{response.Header.ErrorMessage}] Diagnostics=[{response.Header.Diagnostics}]");
// Nor do we attempt to reset a session ID based on a failed heartbeat.
}
}
catch (Exception ex)
{
string message = (ex is RpcException rpcEx) && (rpcEx.Status.StatusCode == StatusCode.Unavailable)
? "Heartbeat failed to detect running service."
: $"Heartbeat failed: [{ex}]";
Tracer.Debug(context, message);
}
}
//增加使用时间
//根据用户名增加使用时间
public static void AddUseTime(HeartbeatResponse heartbeatResponse)
{
//将接受到的字符串(yyyy-mm-dd)转换成Datetime格式
DateTime Offlinetime = Convert.ToDateTime(heartbeatResponse.Attachment);
//如果返回的时间等于9999/12/31 就把状态设为永久离线
if (Offlinetime.ToShortDateString().ToString() == DateTime.MaxValue.ToString("yyyy/MM/dd"))
{
using (var conn = DbUtil.getConn())
{
Console.WriteLine("________________________________________________________设为永久离线");
const string query = "UPDATE bdl_auth SET user_status = @User_Status,auth_offlinetime = @Auth_Offlinetime WHERE auth_level = 1";
conn.Execute(query, new { Auth_Offlinetime = Offlinetime, User_Status = Auther.USER_STATUS_FREE });
}
}
//如果不是9999/12/31就只更改时间，不改变状态
else
{
using (var conn = DbUtil.getConn())
{
Console.WriteLine("________________________________________________________增加使用时间" + Offlinetime);
const string query = "UPDATE bdl_auth SET auth_offlinetime = @Auth_Offlinetime WHERE auth_level = 1";
conn.Execute(query, new { Auth_Offlinetime = Offlinetime });
}
}
}
public async Task ConnectTest()
{
var url = BitstampValues.ApiWebsocketUrl;
using (var communicator = new BitstampWebsocketCommunicator(url))
{
HeartbeatResponse received = null;
var receivedEvent = new ManualResetEvent(false);
using (var client = new BitstampWebsocketClient(communicator))
{
client.Streams.HeartbeatStream.Subscribe(pong =>
{
received = pong;
receivedEvent.Set();
});
await communicator.Start();
client.Send(new SubscribeRequest("btcusd", Channel.Heartbeat));
receivedEvent.WaitOne(TimeSpan.FromSeconds(90));
Assert.NotNull(received);
}
}
}
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 async Task Heartbeat()
{
var url = CoinbaseValues.ApiWebsocketUrl;
using (var communicator = new CoinbaseWebsocketCommunicator(url))
{
HeartbeatResponse received = null;
var receivedEvent = new ManualResetEvent(false);
using (var client = new CoinbaseWebsocketClient(communicator))
{
client.Streams.HeartbeatStream.Subscribe(pong =>
{
received = pong;
receivedEvent.Set();
});
await communicator.Start();
client.Send(new SubscribeRequest(new [] { "BTC-EUR" }, ChannelSubscriptionType.Heartbeat));
receivedEvent.WaitOne(TimeSpan.FromSeconds(30));
Assert.NotNull(received);
}
}
}
public UserInfo(ICoreServiceHost core, string id, string login)
{
_core = core ?? throw new ArgumentNullException(nameof(core));
_heartbeatResponse = new HeartbeatResponse(string.Empty);
ID = string.IsNullOrEmpty(id) ? throw new ArgumentNullException(nameof(id)) : id;
Login = string.IsNullOrEmpty(login) ? throw new ArgumentNullException(nameof(login)) : login;
Accounts = new List <CommonObjects.AccountInfo>();
}
private void HeartbeatResponseCallback(HeartbeatResponse message)
{
Logger.Info("Heartbeat");
if (string.Equals(message.Text, DisconnectByServer))
{
Logout(ConnectionStatus.DisconnectedByServer, "Disconnected by server");
}
}
private bool HandleObjectMessage(string msg)
{
var gmessage = GenesysMessage.Parse(msg);
return
(PongResponse.TryHandle(gmessage, Streams.PongSubject) ||
HeartbeatResponse.TryHandle(gmessage, Streams.HeartbeatsSubject) ||
SocketClosingResponse.TryHandle(gmessage, Streams.SocketClosingSubject) ||
SubscriptionResponse.TryHandle(gmessage, Streams.SubscriptionsSubject, _subscriptions));
}
public void HeartbeatResponse(
[Values(
ErrorCode.NONE,
ErrorCode.OFFSET_METADATA_TOO_LARGE
)] ErrorCode errorCode)
{
var response = new HeartbeatResponse(errorCode);
response.AssertCanEncodeDecodeResponse(0);
}
public void HeartbeatResponse(
[Values(
ErrorResponseCode.None,
ErrorResponseCode.OffsetMetadataTooLarge
)] ErrorResponseCode errorCode)
{
var response = new HeartbeatResponse(errorCode);
response.AssertCanEncodeDecodeResponse(0);
}
/// <summary>
/// Invoked when a Heartbeat Acknowledged event is fired from Discord's WebSocket server.
/// </summary>
/// <param name="response">JSON response.</param>
public void HeartbeatAcknowledged(string response)
{
HeartbeatResponse heartbeat = serializer.Deserialize <HeartbeatResponse>(response);
DiscordOnHeartbeatEventArgs args = new DiscordOnHeartbeatEventArgs()
{
Heartbeat = heartbeat
};
OnHeartbeatNotify(args);
}
private void PropagateHeartbeatInformation(HeartbeatResponse heartbeatResponse)
{
this._dateTimeService.UpdateServerTime(heartbeatResponse.ServerTime);
this._messenger.Send <OnTimeLeftUntilExamStarts>(new OnTimeLeftUntilExamStarts(heartbeatResponse.ExaminationStartInSeconds));
this._messenger.Send <OnTimeLeftUntilExamEnds>(new OnTimeLeftUntilExamEnds(heartbeatResponse.ExaminationEndInSeconds));
this._messenger.Send <OnNewGrabSettings>(new OnNewGrabSettings(heartbeatResponse.EnableGrabs, heartbeatResponse.NoGrabsAfterSeconds, heartbeatResponse.ExaminationStartInSeconds));
this._messenger.Send <OnNewBackupSettings>(new OnNewBackupSettings(heartbeatResponse.EnableBackup, heartbeatResponse.NoBackupAfterSeconds, heartbeatResponse.BackupIntervalInSeconds));
this._messenger.Send <OnEnableHandInReceived>(new OnEnableHandInReceived(heartbeatResponse.EnableHandin));
this._messenger.Send <OnHandInStatusHandInTypeUpdated>(new OnHandInStatusHandInTypeUpdated(heartbeatResponse.HandinType.ToHandInType(), heartbeatResponse.HandinStatus.ToHandInStatus()));
this._messenger.Send <OnAllowHandInReceived>(new OnAllowHandInReceived(heartbeatResponse.AllowHandin));
}
static void SendHeartbeat(bool fromSave = false)
{
// if (_debug) Debug.Log("<WakaTime> Sending heartbeat...");
var currentScene = EditorSceneManager.GetActiveScene().path;
var file = currentScene != string.Empty ? Path.Combine(Application.dataPath, currentScene.Substring("Assets/".Length)) : string.Empty;
var heartbeat = new Heartbeat(file, fromSave);
if ((heartbeat.time - _lastHeartbeat.time < HEARTBEAT_COOLDOWN) && !fromSave && (heartbeat.entity == _lastHeartbeat.entity))
{
// if (_debug) Debug.Log("<WakaTime> Skip this heartbeat");
return;
}
var heartbeatJSON = JsonUtility.ToJson(heartbeat);
var request = UnityWebRequest.Post(URL_PREFIX + "users/current/heartbeats?api_key=" + _apiKey, string.Empty);
request.uploadHandler = new UploadHandlerRaw(System.Text.Encoding.UTF8.GetBytes(heartbeatJSON));
request.chunkedTransfer = false;
request.SetRequestHeader("Content-Type", "application/json");
request.SendWebRequest().completed += (operation) => {
if (request.downloadHandler.text == string.Empty)
{
Debug.LogWarning("<WakaTime> Network is unreachable. Consider disabling completely if you're working offline");
return;
}
// if (_debug) Debug.Log("<WakaTime> Got response\n" + request.downloadHandler.text);
var response = JsonUtility.FromJson <Response <HeartbeatResponse> >(request.downloadHandler.text);
if (response.error != null)
{
if (response.error == "Duplicate")
{
if (_debug)
{
Debug.LogWarning("<WakaTime> Duplicate heartbeat");
}
}
else
{
Debug.LogError("<WakaTime> Failed to send heartbeat to WakaTime!\n" + response.error);
}
}
else
{
// if (_debug) Debug.Log("<WakaTime> Sent heartbeat!");
_lastHeartbeat = response.data;
}
};
}
protected override async Task HandleResponse(string json, CancellationToken token)
{
var msg = EventResponse.Parse(json) ?? (dynamic)HeartbeatResponse.Parse(json) ?? TradeExecutionUpdate.Parse(json);
if (msg != null)
{
await HandleResponse(msg);
RechargePingPong();
}
}
/// <exception cref="System.IO.IOException"/>
private static void SetHeartbeatResponse(DatanodeCommand[] cmds)
{
NNHAStatusHeartbeat ha = new NNHAStatusHeartbeat(HAServiceProtocol.HAServiceState
.Active, fsImage.GetLastAppliedOrWrittenTxId());
HeartbeatResponse response = new HeartbeatResponse(cmds, ha, null);
Org.Mockito.Mockito.DoReturn(response).When(spyNN).SendHeartbeat((DatanodeRegistration
)Matchers.Any(), (StorageReport[])Matchers.Any(), Matchers.AnyLong(), Matchers.AnyLong
(), Matchers.AnyInt(), Matchers.AnyInt(), Matchers.AnyInt(), (VolumeFailureSummary
)Matchers.Any());
}
private async Task <dynamic> GetResponse()
{
var json = await Messenger.GetResponseAsync(CancellationToken);
var result = EventResponse.Parse(json) ??
TickerResponse.Parse(json) ??
OrderBookSnapshotResponse.Parse(json) ??
(dynamic)OrderBookUpdateResponse.Parse(json) ??
HeartbeatResponse.Parse(json);
return(result);
}
internal void OnHeartbeat(HeartbeatResponse message)
{
switch (message.Text)
{
case DisconnectByServer:
Logout(ConnectionState.ServerDisconnected, "Disconnected by server side");
break;
case DisconnectByAnotherUser:
Logout(ConnectionState.DisconnectedByAnotherUser, "Disconnected by server side. Reason : Another user connected with the same credentials");
break;
}
}
//上锁
//根据用户名改变状态设为冻结状态，时间未改动。
public static void LockUse(HeartbeatResponse heartbeatResponse)
{
//将接受到的字符串(yyyy-mm-dd)转换成Datetime格式
//DateTime Offlinetime = Convert.ToDateTime(heartbeatResponse.Attachment);
//状态 正常0和锁定1
//int status = 1;
using (var conn = DbUtil.getConn())
{
const string query = "UPDATE bdl_auth SET user_status = @User_Status WHERE auth_level = 1";
conn.Execute(query, new { User_Status = Auther.USER_STATUS_FREEZE });
}
}
//上锁
//根据用户名改变状态设为冻结状态，时间未改动。
public static void LockUse(HeartbeatResponse heartbeatResponse)
{
//将接受到的字符串(yyyy-mm-dd)转换成Datetime格式
//DateTime Offlinetime = Convert.ToDateTime(heartbeatResponse.Attachment);
//状态 正常0和锁定1
//int status = 1;
using (var conn = DbUtil.getConn())
{
Console.WriteLine("________________________________________________________上锁");
const string query = "UPDATE bdl_system_setting SET user_status = @User_Status";
conn.Execute(query, new { User_Status = SystemSettingEntity.USER_STATUS_FREEZE });
}
}
public string HandleHeartBeat(OCPPMessage msgIn, OCPPMessage msgOut)
{
string errorCode = null;
Logger.LogTrace("Processing heartbeat...");
HeartbeatResponse heartbeatResponse = new HeartbeatResponse();
heartbeatResponse.CurrentTime = DateTimeOffset.UtcNow;
msgOut.JsonPayload = JsonConvert.SerializeObject(heartbeatResponse);
Logger.LogTrace("Heartbeat => Response serialized");
WriteMessageLog(ChargePointStatus?.Id, null, msgIn.Action, null, errorCode);
return(errorCode);
}
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);
}
}
public static HeartbeatResponse GetHeartbeatStatus(string filepath)
{
var info = new HeartbeatResponse();
try
{
if (string.IsNullOrEmpty(filepath))
{
return(info);
}
if (!File.Exists(filepath))
{
return(info);
}
var settings = (new SettingsFileLoader()).ReadSettingsFile(filepath);
info.Status.FileVersion = SettingHelpers.GetSingleStringValue(settings, "FileVersion");
if (!info.Status.FileVersion.StartsWith(HeartbeatGameStatus.MASTER_FILE_VERSION_COMPAT))
{
throw new Exception(string.Format(
"Incompatible heartbeat status file version: {0}",
info.Status.FileVersion));
}
info.Status.UptimeSeconds = SettingHelpers.GetSingleIntValue(settings, "UptimeSeconds");
info.Status.ServerName = SettingHelpers.GetSingleStringValue(settings, "ServerName");
info.Status.AccountName = SettingHelpers.GetSingleStringValue(settings, "AccountName");
info.Status.CharacterName = SettingHelpers.GetSingleStringValue(settings, "CharacterName");
info.LogFilepath = SettingHelpers.GetSingleStringValue(settings, "LogFilepath");
info.Status.ProcessId = SettingHelpers.GetSingleIntValue(settings, "ProcessId");
info.Status.TeamList = SettingHelpers.GetSingleStringValue(settings, "TeamList");
info.Status.ThwargFilterVersion = SettingHelpers.GetSingleStringValue(settings, "ThwargFilterVersion");
info.Status.ThwargFilterFilePath = SettingHelpers.GetSingleStringValue(settings, "ThwargFilterFilePath");
info.Status.IsOnline = SettingHelpers.GetSingleBoolValue(settings, "IsOnline", false);
info.Status.LastServerDispatchSecondsAgo = SettingHelpers.GetSingleIntValue(settings, "LastServerDispatchSecondsAgo");
info.Status.ActualServerName = SettingHelpers.GetSingleStringValue(settings, "ActualServerName");
info.Status.ActualAccountName = SettingHelpers.GetSingleStringValue(settings, "ActualAccountName");
info.Status.ActualCharacterName = SettingHelpers.GetSingleStringValue(settings, "ActualCharacterName");
info.IsValid = true;
}
catch (Exception exc)
{
log.WriteError("GetHeartbeatStatus exception: {0}", exc);
}
return(info);
}
public void HeartbeatResponse()
{
var response1 = new HeartbeatResponse();
Stream binary1 = new MemoryStream();
response1.Serialize(binary1);
binary1.Seek(0L, SeekOrigin.Begin);
var response2 = new HeartbeatResponse();
response2.Deserialize(binary1);
var compareLogic = new CompareLogic();
var result = compareLogic.Compare(response1, response2);
Assert.True(result.AreEqual);
Stream binary2 = new MemoryStream();
response2.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]);
}
}
}
protected override async Task HandleResponse(string json, CancellationToken token)
{
dynamic msg = null;
try
{
msg = EventResponse.Parse(json) ?? (dynamic)HeartbeatResponse.Parse(json) ?? TradeExecutionUpdate.Parse(json);
}
catch (JsonSerializationException)
{
await _log.WriteWarningAsync(nameof(HandleResponse), "Unexpected message", json);
}
if (msg != null)
{
await HandleResponse(msg);
RechargePingPong();
}
}
public async Task <HeartbeatResponse> SendHeartbeatAsync(HeartbeatRequest request)
{
string formattedText = JsonConvert.SerializeObject(request, Formatting.Indented);
HttpRequestMessage requestMessage = new HttpRequestMessage
{
Method = new HttpMethod("PATCH"),
RequestUri = new Uri(_baseUrl),
Content = new StringContent(formattedText, Encoding.UTF8, "application/json")
};
HttpResponseMessage responseMessage = await _client.SendAsync(requestMessage);
responseMessage.EnsureSuccessStatusCode();
HeartbeatResponse response = JsonConvert.DeserializeObject <HeartbeatResponse>(
await responseMessage.Content.ReadAsStringAsync());
return(response);
}
private void RestartHeartbeats()
{
HeartbeatResponse heartbeatResponse = this.GetHeartbeatResponse();
if (heartbeatResponse != null)
{
this.PropagateHeartbeatInformation(heartbeatResponse);
this._heartbeatIntervalTimer.Stop();
if (heartbeatResponse.NextHeartbeatInSeconds <= 0)
{
return;
}
this._heartbeatIntervalTimer.Interval = (double)(heartbeatResponse.NextHeartbeatInSeconds * 1000);
this._heartbeatIntervalTimer.Start();
}
else
{
this._heartbeatIntervalTimer.Start();
}
}
private bool HandleObjectMessage(string msg)
{
var response = CoinbaseJsonSerializer.Deserialize <JObject>(msg);
// ********************
// ADD OBJECT HANDLERS BELOW
// ********************
return
(HeartbeatResponse.TryHandle(response, Streams.HeartbeatSubject) ||
TradeResponse.TryHandle(response, Streams.TradesSubject) ||
OrderBookUpdateResponse.TryHandle(response, Streams.OrderBookUpdateSubject) ||
OrderBookSnapshotResponse.TryHandle(response, Streams.OrderBookSnapshotSubject) ||
TickerResponse.TryHandle(response, Streams.TickerSubject) ||
ErrorResponse.TryHandle(response, Streams.ErrorSubject) ||
SubscribeResponse.TryHandle(response, Streams.SubscribeSubject) ||
false);
}
