private async Task Reconnect(ReconnectionType type) { IsRunning = false; if (_disposing) { return; } _reconnecting = true; if (type != ReconnectionType.Error) { _disconnectedSubject.OnNext(TranslateTypeToDisconnection(type)); } _cancellation.Cancel(); _client?.Abort(); _client?.Dispose(); if (!IsReconnectionEnabled) { // reconnection disabled, do nothing IsStarted = false; _reconnecting = false; return; } Logger.Debug(L("Reconnecting...")); _cancellation = new CancellationTokenSource(); await StartClient(_url, _cancellation.Token, type).ConfigureAwait(false); _reconnecting = false; }
private async Task ReconnectSynchronized(ReconnectionType type, bool failFast, Exception causedException) { using (await _locker.LockAsync()) { await Reconnect(type, failFast, causedException); } }
private async Task ReconnectSynchronized(ReconnectionType type) { using (await _locker.LockAsync()) { await Reconnect(type); } }
//------------------------------------------------------------------------------------------------ // connection //------------------------------------------------------------------------------------------------ public async Task Reconnect(ReconnectionType reconnectionType, CancellationToken ct) { // determine url string wssurl; switch (this.deribitconfig.Environment) { case DeribitEnvironment.Live: wssurl = this.websocketurl_live_v2; break; case DeribitEnvironment.Test: wssurl = this.websocketurl_test_v2; break; default: throw new Exception(); } // connect this.ClientWebSocket = new ClientWebSocket(); this.logger.Information($"[{{ReconnectionType}}] Connecting to {wssurl}", reconnectionType); await this.ClientWebSocket.ConnectAsync(new Uri(wssurl), ct); this.ReconnectionHappened?.Invoke(reconnectionType); }
private async Task Reconnect(ReconnectionType type) { if (_disposing) { return; } Log.Debug(L("Reconnecting...")); _cancelation.Cancel(); await Task.Delay(1000); _cancelation = new CancellationTokenSource(); await StartClient(_url, _cancelation.Token, type); }
private Task _OnConnectAsync(ReconnectionType type) { if (type == ReconnectionType.Initial) { _Logger.LogInformation($"Stream connected"); } else { _Logger.LogInformation($"{type}, reconnecting"); _Resubscribe(); } return(Task.CompletedTask); }
private Task OnConnect(ReconnectionType type) { if (type == ReconnectionType.Initial) { _logger.LogInformation("Websocket Client Connected!!"); } else { _logger.LogInformation("Websocket Client Reconnected!!"); } _client.Subscribe(_subscription); return(Task.CompletedTask); }
private async Task Reconnect(ReconnectionType type, bool failFast, Exception causedException) { IsRunning = false; if (_disposing) { return; } _reconnecting = true; var disType = TranslateTypeToDisconnection(type); var disInfo = DisconnectionInfo.Create(disType, _client, causedException); if (type != ReconnectionType.Error) { _disconnectedSubject.OnNext(disInfo); if (disInfo.CancelReconnection) { // reconnection canceled by user, do nothing Logger.Info(L($"Reconnecting canceled by user, exiting.")); } } _cancellation.Cancel(); try { _client?.Abort(); } catch (Exception e) { Logger.Error(e, L($"Exception while aborting client. " + $"Error: '{e.Message}'")); } _client?.Dispose(); if (!IsReconnectionEnabled || disInfo.CancelReconnection) { // reconnection disabled, do nothing IsStarted = false; _reconnecting = false; return; } Logger.Debug(L("Reconnecting...")); _cancellation = new CancellationTokenSource(); await StartClient(_url, _cancellation.Token, type, failFast).ConfigureAwait(false); _reconnecting = false; }
private async Task Reconnect(ReconnectionType type) { IsRunning = false; if (_disposing) { return; } if (type != ReconnectionType.Error) { //_disconnectedSubject.OnNext(TranslateTypeToDisconnection(type)); } _cancelation.Cancel(); await Task.Delay(1000).ConfigureAwait(false); _cancelation = new CancellationTokenSource(); await StartClient(new Uri(_url), _cancelation.Token, type).ConfigureAwait(false); }
private async Task StartClient(Uri uri, CancellationToken token, ReconnectionType type) { DeactiveLastChance(); _client = _clientFactory(); try { await _client.ConnectAsync(uri, token); #pragma warning disable 4014 Listen(_client, token); #pragma warning restore 4014 ActivateLastChance(); _reconnectionSubject.OnNext(type); } catch (Exception e) { Log.Error(e, L("Exception while connecting. " + $"Waiting {ErrorReconnectTimeoutMs/1000} sec before next reconnection try.")); await Task.Delay(ErrorReconnectTimeoutMs, token); await Reconnect(ReconnectionType.Error); } }
/// <inheritdoc /> public ReconnectionInfo(ReconnectionType type) { Type = type; }
/// <summary> /// Simple factory method /// </summary> public static ReconnectionInfo Create(ReconnectionType type) { return(new ReconnectionInfo(type)); }
//------------------------------------------------------------------------------------------------ // reconnection //------------------------------------------------------------------------------------------------ private void Jsonrpc_ReconnectionHappened(ReconnectionType obj) { this.jsonrpc.RpcProxy.subscription += this.handle_notification; }
private async Task StartClient(Uri uri, CancellationToken token, ReconnectionType type) { // also check if connection was lost, that's probably why we get called multiple times. if (_clientWebSocket == null || _clientWebSocket.State != WebSocketState.Open) { // create a new web-socket so the next connect call works. _clientWebSocket?.Dispose(); //var options = new ClientWebSocketOptions(); _clientWebSocket = new ClientWebSocket(); _clientWebSocket.Options.KeepAliveInterval = new TimeSpan(0, 0, 15, 0); if (!string.IsNullOrEmpty(_token)) { _clientWebSocket.Options.SetRequestHeader("Authorization", "Bearer " + _token); } } // don't do anything, we are already connected. else { return; } try { //await _clientWebSocket.ConnectAsync(uri, CancellationToken.None).ConfigureAwait(false); await _clientWebSocket.ConnectAsync(uri, token).ConfigureAwait(false); OnConnect?.Invoke(this, EventArgs.Empty); IsRunning = true; await Receive(_clientWebSocket, token, async (receivedMessage) => { JObject jObject = null; InvocationDescriptor invocationDescriptor = null; try { jObject = Newtonsoft.Json.JsonConvert.DeserializeObject <JObject>(receivedMessage); //invocationDescriptor = JsonConvert.DeserializeObject<InvocationDescriptor>(serializedMessage); invocationDescriptor = jObject.ToObject <InvocationDescriptor>(); //if (invocationDescriptor == null) return; } catch (Exception ex) { // ignore invalid data sent to the server. } if (jObject == null) { try { var obj = MethodInvocationStrategy.OnTextReceivedAsync("", receivedMessage); } catch (Exception ex) { } return; } if (invocationDescriptor != null && invocationDescriptor.Params != null) { if (invocationDescriptor.Id == 0) { // invoke the method only. try { await MethodInvocationStrategy.OnInvokeMethodReceivedAsync("", invocationDescriptor); } catch (Exception) { // we consume all exceptions. return; } } else { // invoke the method and get the result. InvocationResult invokeResult; try { // create an invocation result with the results. invokeResult = new InvocationResult() { Id = invocationDescriptor.Id, Result = await MethodInvocationStrategy.OnInvokeMethodReceivedAsync("", invocationDescriptor), Exception = null }; } // send the exception as the invocation result if there was one. catch (Exception ex) { invokeResult = new InvocationResult() { Id = invocationDescriptor.Id, Result = null, Exception = new RemoteException(ex) }; } // send a message to the server containing the result. var message = new Message() { MessageType = MessageType.MethodReturnValue, Data = JsonConvert.SerializeObject(invokeResult) }; //var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message, _jsonSerializerSettings)); //var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message.Data, _jsonSerializerSettings)); //await _clientWebSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, CancellationToken.None).ConfigureAwait(false); await Send(message.Data); } } else { try { var invocationResult = jObject.ToObject <InvocationResult>(); if ((invocationResult != null) && (invocationResult.Exception != null || invocationResult.Result != null)) { // find the completion source in the waiting list. if (_waitingRemoteInvocations.ContainsKey(invocationResult.Id)) { // set the result of the completion source so the invoke method continues executing. _waitingRemoteInvocations[invocationResult.Id].SetResult(invocationResult); // remove the completion source from the waiting list. _waitingRemoteInvocations.Remove(invocationResult.Id); } } } catch (Exception e) { var str = e.Message; } } }); ActivateLastChance(); } catch (Exception e) { Console.WriteLine($"{DateTime.Now} _clientWebSocket.ConnectAsync Exception: {e.Message}"); IsRunning = false; await Task.Delay(ErrorReconnectTimeoutMs, _cancelation.Token).ConfigureAwait(false); await Reconnect(ReconnectionType.Error).ConfigureAwait(false); } }
//------------------------------------------------------------------------------------------------ // reconnection //------------------------------------------------------------------------------------------------ private void Jsonrpc_ReconnectionHappened(ReconnectionType obj) { this.jsonrpc.RpcProxy.heartbeat += this.handle_heartbeat; }
public void UpdateDiscordWebSocketState(ReconnectionType type) { IsDiscordBotConnected = true; retryTimer.Stop(); RaisePropertyChanged(this, new PropertyChangedEventArgs(nameof(DiscordSocketStateMessage))); }
protected void handleReconnect(ReconnectionType type) { sendLogIn(); }