/// <summary> /// Called when the internal SignalR client is trying to reconnect after a connection loss. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected virtual void OnReconnecting(object sender, EventArgs e) { if (State == ResonanceComponentState.Connected) { Reconnecting?.Invoke(this, e); } }
/// <summary> /// Connects to client. /// </summary> /// <returns>A Task that can be awaited</returns> protected virtual async Task ConnectToClient() { using (HttpClient client = new HttpClient()) { if (hasConnected) { Reconnecting?.Invoke(); } client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken); using (var stream = await client.GetStreamAsync(streamUri)) { if (ReadTimeout > 0) { stream.ReadTimeout = ReadTimeout; } if (!hasConnected) { Connected?.Invoke(); hasConnected = true; } else { Reconnected?.Invoke(); } await ListensToStreamAsync(stream).ConfigureAwait(true); } } }
public HubConfigurator(TaskFactory sync) { Hub = new HubConnection(Settings.Default.server); this.sync = sync; Hub.Closed += () => sync.StartNew(() => Disconnected?.Invoke()); Hub.Reconnected += () => sync.StartNew(() => Reconnected?.Invoke()); Hub.Reconnecting += () => sync.StartNew(() => Reconnecting?.Invoke()); Hub.Received += Console.WriteLine; }
private void OnGatewayStateChanged(GatewayStatus newState) { switch (newState) { case GatewayStatus.Resuming: Resuming?.Invoke(); break; case GatewayStatus.Reconnecting: Reconnecting?.Invoke(); break; case GatewayStatus.Disconnected: LoggedOut?.Invoke(); break; } }
public async Task StartAsync(bool automaticRetry, Exception exception = null) { if (Running) { throw new InvalidOperationException("The SignalR client is running."); } Running = true; AutomaticRetry = automaticRetry; await Task.Run(() => { while (true) { if (exception is null) { Connecting?.Invoke(this); } else { Reconnecting?.Invoke(this, exception); } try { Connection.StartAsync().Wait(); Connected?.Invoke(this); RetryCount = 0; return; } catch (Exception ex) { RetryCount++; Exception?.Invoke(this, ex); if (!AutomaticRetry || RetryCount >= MaxRetry) { HandleFailed(ex); throw; } Thread.Sleep(ExceptionRetryDelay); continue; } } }); }
/// <summary> /// Handles and fires the <see cref="OnReconnecting(EventArgs)"/> event. /// </summary> protected virtual void OnReconnecting(EventArgs e) { Reconnecting?.Invoke(this, e); }
/// <summary> /// Starts the connection. /// </summary> /// <returns></returns> public Task StartAsync() { if (IsStarted) { return(Task.FromResult(true)); } TaskCompletionSource <object> completion = new TaskCompletionSource <object>(); bool completed = false; Task.Factory.StartNew(() => { try { var urlHub = SplitUrl(Url); _connection = new HubConnection(urlHub.url); _proxy = _connection.CreateHubProxy(urlHub.hub); _connection.StateChanged += (x) => { if (x.NewState == ConnectionState.Connected) { if (!completed) { IsStarted = true; completed = true; completion.SetResult(true); } } }; bool reconnecting = false; _connection.Error += (exception) => { if (EnableAutoReconnection) { if (reconnecting && _connection.State == ConnectionState.Reconnecting && exception.GetType() == typeof(TimeoutException)) { Error?.Invoke(this, new ResonanceExceptionEventArgs(exception)); } } }; _connection.Reconnecting += () => { if (!reconnecting) { reconnecting = true; if (EnableAutoReconnection) { Reconnecting?.Invoke(this, new EventArgs()); } else if (_connection.LastError != null) { try { Stop(); Error?.Invoke(this, new ResonanceExceptionEventArgs(_connection.LastError)); } catch { } } } }; _connection.Reconnected += () => { if (EnableAutoReconnection) { reconnecting = false; Reconnected?.Invoke(this, new EventArgs()); } }; _connection.Start(); } catch (Exception ex) { if (!completed) { completed = true; completion.SetException(ex); } } }); TimeoutTask.StartNew(() => { if (!completed) { completed = true; completion.SetException(new TimeoutException("Could not establish the connection within the given timeout.")); } }, TimeSpan.FromSeconds(10)); return(completion.Task); }
/// <summary> /// Starts the connection. /// </summary> /// <returns></returns> public async Task StartAsync() { if (IsStarted) { return; } var builder = new HubConnectionBuilder().WithUrl(Url).WithAutomaticReconnect(); if (UseMessagePackProtocol) { builder = builder.AddMessagePackProtocol(); } if (EnableAutoReconnection) { builder = builder.WithAutomaticReconnect(new TimeSpan[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1) }); } _connection = builder.Build(); bool reconnecting = false; _connection.Closed += (exception) => { if (EnableAutoReconnection) { if (reconnecting && _connection.State == HubConnectionState.Disconnected && exception.GetType() == typeof(OperationCanceledException)) { Error?.Invoke(this, new ResonanceExceptionEventArgs(exception)); } } return(Task.FromResult(true)); }; _connection.Reconnecting += (ex) => { if (!reconnecting) { reconnecting = true; if (EnableAutoReconnection) { Reconnecting?.Invoke(this, new EventArgs()); } else { try { Stop(); Error?.Invoke(this, new ResonanceExceptionEventArgs(ex)); } catch { } } } return(Task.FromResult(true)); }; _connection.Reconnected += (msg) => { if (EnableAutoReconnection) { Reconnected?.Invoke(this, new EventArgs()); reconnecting = false; } return(Task.FromResult(true)); }; await _connection.StartAsync(); IsStarted = true; }
public void Init(string url, string token) { if (_hubConnection != null) { return; } _hubConnection = new HubConnectionBuilder() .WithUrl(url, options => { /* * The access token function you provide is called before every HTTP request made by SignalR. * If you need to renew the token in order to keep the connection active * (because it may expire during the connection), * do so from within this function and return the updated token. * https://docs.microsoft.com/en-us/aspnet/core/signalr/authn-and-authz?view=aspnetcore-3.1#bearer-token-authentication */ options.AccessTokenProvider = () => { // verify access token here // if not verified, refresh access token using refresh token //Debug.WriteLine(token); Debug.Assert(token != null); return(Task.FromResult(token)); }; }) .WithAutomaticReconnect(new[] { // default: wait 0,2,10,30 seconds and try to reconnect TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(1) }) .Build(); // Handle Hub connection events _hubConnection.Closed += err => { Closed?.Invoke(this, new ConnectionEventArgs($"Connection to SignalR Hub Closed. {err.Message}")); return(Task.CompletedTask); }; _hubConnection.Reconnecting += err => { Reconnecting?.Invoke(this, new ConnectionEventArgs($"Try to reconnect to SignarR Hub. current error message: {err.Message}")); return(Task.CompletedTask); }; _hubConnection.Reconnected += connectionId => { Reconnected?.Invoke(this, new ConnectionEventArgs($"Succesfully re-connected to SignalR hub. New Connectionid: {connectionId}")); return(Task.CompletedTask); }; // Handle Hub messages _hubConnection.On <string, string, int, int, DateTime, string>("ReceiveMessage", ReceiveMessage); _hubConnection.On <string>("Entered", user => { SomeoneEntered?.Invoke(this, new SignalREventArgs($"{user} entered.", user)); //AddLocalMessage($"{user} entered.", user); }); _hubConnection.On <string>("Left", user => { SomeoneLeft?.Invoke(this, new SignalREventArgs($"{user} left.", user)); }); }
private void OnReconnecting() { Reconnecting?.Invoke(); }
/// <summary> /// Called when the client starts reconnecting. /// </summary> protected virtual void OnReconnecting() { Reconnecting?.Invoke(this, EventArgs.Empty); }
private void Handle_Reconnecting(object sender, ClientReconnectingEventArgs e) { _logger?.LogTrace($"Reconnecting: {e.Connection.ConnectionName}"); Reconnecting?.Invoke(sender, e); }
private void Hub_Reconnecting() { Reconnecting?.Invoke(true); }
protected void OnReconnecting() => Reconnecting?.Invoke();
/// <summary> /// Called when the internal SignalR client is reconnecting. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected virtual void OnReconnecting(object sender, EventArgs e) { IsRegistered = false; Reconnecting?.Invoke(this, new EventArgs()); }
public void Reconnect() { try { Reconnecting?.Invoke(new DeviceEventArgs(this)); _reconnecting = true; if (phx42 != null) { try { phx42.Error -= Phx42OnError; phx42.CommandError -= Phx42OnCommandError; phx42.WriteFlashProgress -= Phx42OnWriteFlashProgress; phx42.ReadFlashProgress -= Phx42OnReadFlashProgress; phx42.UpdateFirmwareProgress -= Phx42OnUpdateFirmwareProgress; phx42.ShutdownNow = true; } catch (Exception ex) { phx42?.WriteToPhxLog("Problem disconnecting"); phx42?.WriteExceptionToPhxLog(ex); } IsConnected = false; Status = "Disconnected"; } try { var streams = _bluetoothService.Reconnect(_device); phx42 = new Phx42(streams.InputStream, streams.OutputStream, _fileManager, _device.Name, TimeMongerService); phx42.Error += Phx42OnError; phx42.CommandError += Phx42OnCommandError; phx42.WriteFlashProgress += Phx42OnWriteFlashProgress; phx42.ReadFlashProgress += Phx42OnReadFlashProgress; phx42.UpdateFirmwareProgress += Phx42OnUpdateFirmwareProgress; if (IsPollingData) { phx42.StartPollingData(); } IsConnected = true; Status = "Connected"; ReconnectSuccess?.Invoke(new DeviceEventArgs(this)); } catch (Exception ex) { phx42?.WriteToPhxLog("Problem reconnecting"); phx42?.WriteExceptionToPhxLog(ex); OnDisconnected(new DeviceEventArgs(this)); return; } } finally { _reconnecting = false; } }