public async Task Reconnect(CancellationToken Token)
{
Close();
await Open(Token);
OnReconnected?.Invoke(this, new OnReconnectedEventArgs());
}
public async Task Reconnect()
{
Close();
await Open();
OnReconnected?.Invoke(this, new OnReconnectedEventArgs());
}
public void Reconnect()
{
Close();
if (Open())
{
OnReconnected?.Invoke(this, new OnReconnectedEventArgs());
}
}
public StreamFlowDriverSignalR(ISignalRService signalRService)
{
SignalRService = signalRService;
SignalRService.Connection.Reconnected += async(e) => OnReconnected?.Invoke();
SignalRService.Connection.Reconnecting += async(e) => OnReconnecting?.Invoke();
SignalRService.Connection.Closed += async(e) => OnDisconnected?.Invoke();
}
public async Task <bool> CreateAsync()
{
if (connecting || connected)
{
return(false);
}
connecting = true;
try
{
var sessionToken = tokenProvider.GetSessionToken();
var token = JsonConvert.SerializeObject(sessionToken);
var sessionTokenData = token.Base64Encode();
webSocket = new ClientWebSocket();
webSocket.Options.SetRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36");
webSocket.Options.SetRequestHeader("session-token", sessionTokenData);
await webSocket.ConnectAsync(new Uri(settings.WebSocketEndpoint), CancellationToken.None);
connected = true;
Interlocked.Increment(ref connectionCounter);
logger.Debug("Connected to the server");
if (readProcessThread == null)
{
(readProcessThread = new Thread(ProcessRead)).Start();
}
if (sendProcessThread == null)
{
(sendProcessThread = new Thread(ProcessSend)).Start();
}
if (reconnecting)
{
reconnecting = false;
OnReconnected?.Invoke(this, EventArgs.Empty);
}
return(true);
}
catch (Exception exc)
{
logger.Error(exc.Message.ToString());
connected = false;
}
finally
{
connecting = false;
}
return(false);
}
internal void HandleReconnected()
{
connection.ReOpenSession(ClientId).ContinueWith(t => {
if (t.IsFaulted)
{
AVRealtime.PrintLog(t.Exception.InnerException.Message);
return;
}
// IM Client 重连完成
OnReconnected?.Invoke();
});
}
public void Reconnect()
{
Task.Run(() =>
{
Task.Delay(20).Wait();
Close();
if (Open())
{
OnReconnected?.Invoke(this, new OnReconnectedEventArgs());
}
});
}
private void ReConnecting()
{
while (true)
{
log("ReConnecting");
try
{
InitConnection();
OnReconnected?.Invoke();
log("Reconnected");
break;
}
catch
{
}
Thread.Sleep(60000);
}
}
/// <exception cref="OperationCanceledException"></exception>
async Task ConnectLoop(bool resume, CancellationToken cancellationToken)
{
// Keep track of whether this is a resume or new session so
// we can respond to the HELLO payload appropriately.
isConnectionResuming = resume;
log.LogVerbose($"[ConnectLoop] resume = {resume}");
handshakeCompleteEvent.Reset();
handshakeCompleteCancellationSource = new CancellationTokenSource();
while (!cancellationToken.IsCancellationRequested)
{
// Ensure previous socket has been closed
if (socket != null)
{
UnsubscribeSocketEvents();
if (resume)
{
// Store previous sequence
lastSequence = socket.Sequence;
}
if (socket.CanBeDisconnected)
{
log.LogVerbose("[ConnectLoop] Disconnecting previous socket...");
// If for some reason the socket cannot be disconnected gracefully,
// DisconnectAsync will abort the socket after 5s.
if (resume)
{
// Make sure to disconnect with a non 1000 code to ensure Discord doesn't
// force us to make a new session since we are resuming.
await socket.DisconnectAsync(WebSocketCloseStatus.EndpointUnavailable,
"Reconnecting to resume...", cancellationToken).ConfigureAwait(false);
}
else
{
await socket.DisconnectAsync(WebSocketCloseStatus.NormalClosure,
"Starting new session...", cancellationToken).ConfigureAwait(false);
}
}
socket.Dispose();
}
if (!resume)
{
// If not resuming, reset gateway session state.
lastSequence = 0;
}
// Create a new socket
socket = new GatewaySocket($"GatewaySocket#{shard.Id}", lastSequence,
outboundPayloadRateLimiter, gameStatusUpdateRateLimiter, identifyRateLimiter);
socket.OnHello = async() =>
{
if (isDisposed)
{
return;
}
if (isConnectionResuming)
{
// Resume
await socket.SendResumePayload(botToken, sessionId, lastSequence);
}
else
{
// Identify
await socket.SendIdentifyPayload(botToken, lastShardStartConfig.GatewayLargeThreshold,
shard.Id, totalShards);
}
};
SubscribeSocketEvents();
// Get the gateway URL if we don't have one
string gatewayUrl = GatewayUrlMemoryCache.GatewayUrl;
if (gatewayUrl == null)
{
try
{
log.LogVerbose("[ConnectLoop] Retrieving Gateway URL...");
gatewayUrl = await http.GetGateway().ConfigureAwait(false);
GatewayUrlMemoryCache.UpdateUrl(gatewayUrl);
}
catch (Exception ex) when(ex is DiscordHttpApiException || ex is HttpRequestException || ex is OperationCanceledException)
{
log.LogError($"[ConnectLoop:GetGateway] {ex}");
log.LogError("[ConnectLoop] No gateway URL to connect with, trying again in 10s...");
await Task.Delay(10 * 1000, cancellationToken).ConfigureAwait(false);
continue;
}
catch (Exception ex)
{
// This should never-ever happen, but we need to handle it just in-case.
log.LogError(ex);
log.LogError("[ConnectLoop] Uncaught severe error occured while getting the Gateway URL, setting state to Disconnected.");
state = GatewayState.Disconnected;
gatewayFailureData = new GatewayFailureData(
"Failed to retrieve the Gateway URL because of an unknown error.",
ShardFailureReason.Unknown, ex);
handshakeCompleteEvent.Set();
OnFailure?.Invoke(this, gatewayFailureData);
break;
}
}
log.LogVerbose($"[ConnectLoop] gatewayUrl = {gatewayUrl}");
// Wait if necessary
if (nextConnectionDelayMs > 0)
{
log.LogVerbose($"[ConnectLoop] Waiting {nextConnectionDelayMs}ms before connecting socket...");
await Task.Delay(nextConnectionDelayMs, cancellationToken).ConfigureAwait(false);
nextConnectionDelayMs = 0;
}
try
{
// Attempt to connect
await socket.ConnectAsync(new Uri($"{gatewayUrl}?v={GATEWAY_VERSION}&encoding=json"), cancellationToken)
.ConfigureAwait(false);
// At this point the socket has successfully connected
log.LogVerbose("[ConnectLoop] Socket connected successfully.");
break;
}
catch (WebSocketException wsex)
{
UnsubscribeSocketEvents();
// Failed to connect
log.LogError("[ConnectLoop] Failed to connect: " +
$"{wsex.WebSocketErrorCode} ({(int)wsex.WebSocketErrorCode}), {wsex.Message}");
// Invalidate the cached URL since we failed to connect the socket
log.LogVerbose("[ConnectLoop] Invalidating Gateway URL...");
GatewayUrlMemoryCache.InvalidateUrl();
// Wait 5s then retry
log.LogVerbose("[ConnectLoop] Waiting 5s before retrying...");
await Task.Delay(5000, cancellationToken).ConfigureAwait(false);
}
}
// If the token is cancelled between the socket successfully connecting and the loop exiting,
// do not throw an exception because the connection did technically complete before the cancel.
if (socket == null || !socket.IsConnected)
{
// If the loop stopped from the token being cancelled, ensure an exception is still thrown.
cancellationToken.ThrowIfCancellationRequested();
}
// If this is an automatic reconnection, fire OnReconnected event
if (state == GatewayState.Connected)
{
if (resume)
{
log.LogInfo("[ConnectLoop:Reconnection] Successfully started a resume.");
}
else
{
log.LogInfo("[ConnectLoop:Reconnection] Successfully started creating a new session.");
}
OnReconnected?.Invoke(this, new GatewayReconnectedEventArgs(!resume));
}
}
public Client() : base(null)
{
ThreadDispatcher.EnsureCreated();
base.OverrideBeingHostedCheck = true;
base.OnLog += (object sender, OnLogArgs e) => { ThreadDispatcher.Enqueue(() => OnLog?.Invoke(sender, e)); };
base.OnConnected += ((object sender, OnConnectedArgs e) => { ThreadDispatcher.Enqueue(() => OnConnected?.Invoke(sender, e)); });
base.OnJoinedChannel += ((object sender, OnJoinedChannelArgs e) => {
ThreadDispatcher.Enqueue(() => OnJoinedChannel?.Invoke(sender, e));
if (OnBeingHosted == null)
{
return;
}
if (e.Channel.ToLower() != TwitchUsername && !OverrideBeingHostedCheck)
{
ThreadDispatcher.Enqueue(() => throw new BadListenException("BeingHosted", "You cannot listen to OnBeingHosted unless you are connected to the broadcaster's channel as the broadcaster. You may override this by setting the TwitchClient property OverrideBeingHostedCheck to true."));
}
});
base.OnIncorrectLogin += ((object sender, OnIncorrectLoginArgs e) => { ThreadDispatcher.Enqueue(() => OnIncorrectLogin?.Invoke(sender, e)); });
base.OnChannelStateChanged += ((object sender, OnChannelStateChangedArgs e) => { ThreadDispatcher.Enqueue(() => OnChannelStateChanged?.Invoke(sender, e)); });
base.OnUserStateChanged += ((object sender, OnUserStateChangedArgs e) => { ThreadDispatcher.Enqueue(() => OnUserStateChanged?.Invoke(sender, e)); });
base.OnMessageReceived += ((object sender, OnMessageReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageReceived?.Invoke(sender, e)); });
base.OnWhisperReceived += ((object sender, OnWhisperReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperReceived?.Invoke(sender, e)); });
base.OnMessageSent += ((object sender, OnMessageSentArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageSent?.Invoke(sender, e)); });
base.OnWhisperSent += ((object sender, OnWhisperSentArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperSent?.Invoke(sender, e)); });
base.OnChatCommandReceived += ((object sender, OnChatCommandReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnChatCommandReceived?.Invoke(sender, e)); });
base.OnWhisperCommandReceived += ((object sender, OnWhisperCommandReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperCommandReceived?.Invoke(sender, e)); });
base.OnUserJoined += ((object sender, OnUserJoinedArgs e) => { ThreadDispatcher.Enqueue(() => OnUserJoined?.Invoke(sender, e)); });
base.OnModeratorJoined += ((object sender, OnModeratorJoinedArgs e) => { ThreadDispatcher.Enqueue(() => OnModeratorJoined?.Invoke(sender, e)); });
base.OnModeratorLeft += ((object sender, OnModeratorLeftArgs e) => { ThreadDispatcher.Enqueue(() => OnModeratorLeft?.Invoke(sender, e)); });
base.OnNewSubscriber += ((object sender, OnNewSubscriberArgs e) => { ThreadDispatcher.Enqueue(() => OnNewSubscriber?.Invoke(sender, e)); });
base.OnReSubscriber += ((object sender, OnReSubscriberArgs e) => { ThreadDispatcher.Enqueue(() => OnReSubscriber?.Invoke(sender, e)); });
base.OnHostLeft += ((object sender, EventArgs arg) => { ThreadDispatcher.Enqueue(() => OnHostLeft?.Invoke(sender, arg)); });
base.OnExistingUsersDetected += ((object sender, OnExistingUsersDetectedArgs e) => { ThreadDispatcher.Enqueue(() => OnExistingUsersDetected?.Invoke(sender, e)); });
base.OnUserLeft += ((object sender, OnUserLeftArgs e) => { ThreadDispatcher.Enqueue(() => OnUserLeft?.Invoke(sender, e)); });
base.OnHostingStarted += ((object sender, OnHostingStartedArgs e) => { ThreadDispatcher.Enqueue(() => OnHostingStarted?.Invoke(sender, e)); });
base.OnHostingStopped += ((object sender, OnHostingStoppedArgs e) => { ThreadDispatcher.Enqueue(() => OnHostingStopped?.Invoke(sender, e)); });
base.OnDisconnected += ((object sender, OnDisconnectedEventArgs e) => { ThreadDispatcher.Enqueue(() => OnDisconnected?.Invoke(sender, e)); });
base.OnConnectionError += ((object sender, OnConnectionErrorArgs e) => { ThreadDispatcher.Enqueue(() => OnConnectionError?.Invoke(sender, e)); });
base.OnChatCleared += ((object sender, OnChatClearedArgs e) => { ThreadDispatcher.Enqueue(() => OnChatCleared?.Invoke(sender, e)); });
base.OnUserTimedout += ((object sender, OnUserTimedoutArgs e) => { ThreadDispatcher.Enqueue(() => OnUserTimedout?.Invoke(sender, e)); });
base.OnLeftChannel += ((object sender, OnLeftChannelArgs e) => { ThreadDispatcher.Enqueue(() => OnLeftChannel?.Invoke(sender, e)); });
base.OnUserBanned += ((object sender, OnUserBannedArgs e) => { ThreadDispatcher.Enqueue(() => OnUserBanned?.Invoke(sender, e)); });
base.OnModeratorsReceived += ((object sender, OnModeratorsReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnModeratorsReceived?.Invoke(sender, e)); });
base.OnChatColorChanged += ((object sender, OnChatColorChangedArgs e) => { ThreadDispatcher.Enqueue(() => OnChatColorChanged?.Invoke(sender, e)); });
base.OnSendReceiveData += ((object sender, OnSendReceiveDataArgs e) => { ThreadDispatcher.Enqueue(() => OnSendReceiveData?.Invoke(sender, e)); });
base.OnNowHosting += ((object sender, OnNowHostingArgs e) => { ThreadDispatcher.Enqueue(() => OnNowHosting?.Invoke(sender, e)); });
base.OnBeingHosted += ((object sender, OnBeingHostedArgs e) => { ThreadDispatcher.Enqueue(() => OnBeingHosted?.Invoke(sender, e)); });
base.OnRaidNotification += ((object sender, OnRaidNotificationArgs e) => { ThreadDispatcher.Enqueue(() => OnRaidNotification?.Invoke(sender, e)); });
base.OnGiftedSubscription += ((object sender, OnGiftedSubscriptionArgs e) => { ThreadDispatcher.Enqueue(() => OnGiftedSubscription?.Invoke(sender, e)); });
base.OnRaidedChannelIsMatureAudience += ((object sender, EventArgs arg) => { ThreadDispatcher.Enqueue(() => OnRaidedChannelIsMatureAudience?.Invoke(sender, arg)); });
base.OnRitualNewChatter += ((object sender, OnRitualNewChatterArgs e) => { ThreadDispatcher.Enqueue(() => OnRitualNewChatter?.Invoke(sender, e)); });
base.OnFailureToReceiveJoinConfirmation += ((object sender, OnFailureToReceiveJoinConfirmationArgs e) => { ThreadDispatcher.Enqueue(() => OnFailureToReceiveJoinConfirmation?.Invoke(sender, e)); });
base.OnUnaccountedFor += ((object sender, OnUnaccountedForArgs e) => { ThreadDispatcher.Enqueue(() => OnUnaccountedFor?.Invoke(sender, e)); });
base.OnSelfRaidError += ((object sender, EventArgs e) => { ThreadDispatcher.Enqueue(() => OnSelfRaidError?.Invoke(sender, e)); });
base.OnNoPermissionError += ((object sender, EventArgs e) => { ThreadDispatcher.Enqueue(() => OnNoPermissionError?.Invoke(sender, e)); });
base.OnMessageCleared += ((object sender, OnMessageClearedArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageCleared?.Invoke(sender, e)); });
base.OnReconnected += ((object sender, OnReconnectedEventArgs e) => { ThreadDispatcher.Enqueue(() => OnReconnected?.Invoke(sender, e)); });
base.OnWhisperThrottled += ((object sender, OnWhisperThrottledEventArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperThrottled?.Invoke(sender, e)); });
base.OnMessageThrottled += ((object sender, OnMessageThrottledEventArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageThrottled?.Invoke(sender, e)); });
base.OnCommunitySubscription += ((object sender, OnCommunitySubscriptionArgs e) => { ThreadDispatcher.Enqueue(() => OnCommunitySubscription?.Invoke(sender, e)); });
base.OnError += ((object sender, OnErrorEventArgs e) => { ThreadDispatcher.Enqueue(() => OnError?.Invoke(sender, e)); });
base.OnVIPsReceived += ((object sender, OnVIPsReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnVIPsReceived?.Invoke(sender, e)); });
}
public ScrumPokerHubClient(ILogger <ScrumPokerHubClient> logger, IJSRuntime jsRuntime, NavigationManager navigationManager, ProfileService profileService)
{
_logger = logger;
_profileService = profileService;
_hubConnection = new HubConnectionBuilder()
.WithUrl(navigationManager.ToAbsoluteUri($"/{SignalRConstants.ScrumPokerHub}"))
.WithAutomaticReconnect()
.ConfigureLogging(builder =>
{
Assembly assembly = Assembly.LoadFrom("Blazor.Extensions.Logging.dll");
Type logProvider = assembly.GetType("Blazor.Extensions.Logging.BrowserConsoleLoggerProvider", true, true);
ILoggerProvider loggingProvider = (ILoggerProvider)Activator.CreateInstance(logProvider, BindingFlags.CreateInstance, null, new[] { jsRuntime }, null);
builder.AddProvider(loggingProvider);
})
.Build();
_hubConnection.Closed += ex =>
{
if (ex == null)
{
_logger.LogWarning("SignalR connection closed without error");
}
else
{
_logger.LogError(ex, "SignalR connection closed with error");
}
return(Task.CompletedTask);
};
_hubConnection.Reconnected += s =>
{
_logger.LogDebug($"Reconnected.");
OnReconnected?.Invoke(this, s);
return(Task.CompletedTask);
};
_hubConnection.On <PlayerVoted>(SignalRConstants.ReceiveVote, (evnt) =>
{
var encodedMsg = $"{evnt.UserId} {evnt.Vote}";
_logger.LogDebug($"Vote Cast: {encodedMsg}");
OnReceiveVote?.Invoke(this, evnt);
});
_hubConnection.On <PlayerJoined>(SignalRConstants.AddPlayer, (evnt) =>
{
_logger.LogDebug($"Player Joined: {evnt.UserName}");
OnAddPlayer?.Invoke(this, evnt);
});
_hubConnection.On <PlayerEvent>(SignalRConstants.RemovePlayer, (evnt) =>
{
_logger.LogDebug($"Player Left: {evnt.UserId}");
OnRemovePlayer?.Invoke(this, evnt);
});
_hubConnection.On <GameInfo>(SignalRConstants.ReceiveInitialGameState, (evnt) =>
{
_logger.LogDebug("Received GameInfo!");
OnReceiveInitialGameState?.Invoke(this, evnt);
});
_hubConnection.On <PlayerEvent>(SignalRConstants.GameEnded, (evnt) =>
{
_logger.LogDebug("Game Deleted!");
OnGameEnded?.Invoke(this, evnt);
});
_hubConnection.On <PlayerEvent>(SignalRConstants.ResetGame, (evnt) =>
{
_logger.LogDebug("Game Reset!");
OnGameReset?.Invoke(this, evnt);
});
}
private void Gateway_OnReconnected(object sender, GatewayReconnectedEventArgs e)
{
OnReconnected?.Invoke(this, new ShardReconnectedEventArgs(this, e.IsNewSession));
}
