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); }