private async Task SendResultsAsync()
{
try
{
await foreach (IReadOnlyQueryResult result in
_responseStream.WithCancellation(_cts.Token))
{
await _connection.SendAsync(
new DataResultMessage(Id, result).Serialize(),
_cts.Token)
.ConfigureAwait(false);
}
if (!_cts.IsCancellationRequested)
{
await _connection.SendAsync(
new DataCompleteMessage(Id).Serialize(),
_cts.Token).ConfigureAwait(false);
Completed?.Invoke(this, EventArgs.Empty);
}
}
catch (TaskCanceledException)
{
// the subscription was canceled.
}
finally
{
Dispose();
}
}
protected override async Task HandleAsync(
ISocketConnection connection,
InitializeConnectionMessage message,
CancellationToken cancellationToken)
{
ConnectionStatus connectionStatus =
await _socketSessionInterceptor.OnConnectAsync(
connection, message, cancellationToken);
if (connectionStatus.Accepted)
{
await connection.SendAsync(AcceptConnectionMessage.Default, cancellationToken);
await connection.SendAsync(KeepConnectionAliveMessage.Default, cancellationToken);
}
else
{
var rejectMessage = connectionStatus.Extensions == null
? new RejectConnectionMessage(connectionStatus.Message)
: new RejectConnectionMessage(
connectionStatus.Message,
connectionStatus.Extensions);
await connection.SendAsync(
rejectMessage.Serialize(),
cancellationToken);
await connection.CloseAsync(
connectionStatus.Message,
SocketCloseStatus.PolicyViolation,
cancellationToken);
}
}
private async Task SendResultsAsync()
{
try
{
await foreach (IQueryResult result in
_responseStream.ReadResultsAsync().WithCancellation(_cts.Token))
{
using (result)
{
await _connection.SendAsync(new DataResultMessage(Id, result), _cts.Token);
}
}
if (!_cts.IsCancellationRequested)
{
await _connection.SendAsync(new DataCompleteMessage(Id), _cts.Token);
Completed?.Invoke(this, EventArgs.Empty);
}
}
catch (OperationCanceledException) { }
catch (ObjectDisposedException) { }
catch (Exception ex)
{
if (!_cts.IsCancellationRequested)
{
IError error =
ErrorBuilder
.New()
.SetException(ex)
.SetCode(ErrorCodes.Execution.TaskProcessingError)
.SetMessage("Unexpected Execution Error")
.Build();
IQueryResult result = QueryResultBuilder.CreateError(error);
try
{
await _connection.SendAsync(new DataResultMessage(Id, result), _cts.Token);
}
finally
{
await _connection.SendAsync(new DataCompleteMessage(Id), _cts.Token);
Completed?.Invoke(this, EventArgs.Empty);
}
}
}
finally
{
Dispose();
}
}
private static async Task HandleQueryResultAsync(
ISocketConnection connection,
DataStartMessage message,
IQueryResult queryResult,
CancellationToken cancellationToken)
{
await connection.SendAsync(
new DataResultMessage(message.Id, queryResult).Serialize(),
cancellationToken);
await connection.SendAsync(
new DataCompleteMessage(message.Id).Serialize(),
cancellationToken);
}
private async Task KeepConnectionAliveAsync(
CancellationToken cancellationToken)
{
try
{
while (!_connection.Closed && !cancellationToken.IsCancellationRequested)
{
await Task.Delay(_timeout, cancellationToken);
if (!_connection.Closed)
{
await _connection.SendAsync(
KeepConnectionAliveMessage.Default.Serialize(),
cancellationToken);
}
}
}
catch (OperationCanceledException) when(cancellationToken.IsCancellationRequested)
{
// the message processing was canceled.
}
catch (WebSocketException)
{
// we will just stop receiving
}
}
private async Task KeepConnectionAliveAsync(
CancellationToken cancellationToken)
{
try
{
while (!_connection.Closed &&
!cancellationToken.IsCancellationRequested)
{
await Task.Delay(_timeout, cancellationToken)
.ConfigureAwait(false);
if (!_connection.Closed)
{
await _connection.SendAsync(
KeepConnectionAliveMessage.Default.Serialize(),
cancellationToken)
.ConfigureAwait(false);
}
}
}
catch (TaskCanceledException)
{
// the message processing was canceled.
}
}
private async Task RegisterInternalAsync(
ISubscription subscription,
ISocketConnection connection)
{
if (_subs.TryAdd(subscription.Id, new Sub(subscription, connection)))
{
connection.Disposed += (sender, args) => RemoveSubscription(subscription.Id);
if (connection.IsClosed)
{
_subs.TryRemove(subscription.Id, out _);
return;
}
subscription.OnRegister(() => UnregisterAsync(subscription.Id));
var writer = new SocketMessageWriter();
writer.WriteStartObject();
writer.WriteType(MessageTypes.Subscription.Start);
writer.WriteId(subscription.Id);
writer.WriteStartPayload();
subscription.OperationFormatter.Serialize(subscription.Operation, writer);
writer.WriteEndObject();
await connection.SendAsync(writer.Body).ConfigureAwait(false);
}
}
protected override async Task HandleAsync(
ISocketConnection connection,
InitializeConnectionMessage message,
CancellationToken cancellationToken)
{
ConnectionStatus connectionStatus =
_connectMessageInterceptor == null
? ConnectionStatus.Accept()
: await _connectMessageInterceptor.OnReceiveAsync(
connection, message, cancellationToken)
.ConfigureAwait(false);
if (connectionStatus.Accepted)
{
await connection.SendAsync(
AcceptConnectionMessage.Default.Serialize(),
cancellationToken)
.ConfigureAwait(false);
await connection.SendAsync(
KeepConnectionAliveMessage.Default.Serialize(),
cancellationToken)
.ConfigureAwait(false);
}
else
{
var rejectMessage = connectionStatus.Extensions == null
? new RejectConnectionMessage(
connectionStatus.Message)
: new RejectConnectionMessage(
connectionStatus.Message,
connectionStatus.Extensions);
await connection.SendAsync(
rejectMessage.Serialize(),
cancellationToken)
.ConfigureAwait(false);
// TODO : resources
await connection.CloseAsync(
connectionStatus.Message,
SocketCloseStatus.PolicyViolation,
cancellationToken)
.ConfigureAwait(false);
}
}
private static async Task HandleStreamResultAsync(
ISocketConnection connection,
DataStartMessage message,
IResponseStream responseStream,
CancellationToken cancellationToken)
{
await foreach (IQueryResult queryResult in responseStream.ReadResultsAsync()
.WithCancellation(cancellationToken))
{
await connection.SendAsync(
new DataResultMessage(message.Id, queryResult).Serialize(),
cancellationToken);
}
await connection.SendAsync(
new DataCompleteMessage(message.Id).Serialize(),
cancellationToken);
}
private Task TerminateConnectionAsync(
ISocketConnection connection,
CancellationToken cancellationToken = default)
{
var messageWriter = new SocketMessageWriter();
messageWriter.WriteStartObject();
messageWriter.WriteType(MessageTypes.Connection.Terminate);
messageWriter.WriteEndObject();
return(connection.SendAsync(messageWriter.Body, cancellationToken));
}
private async Task ExecuteTurnAsync(Button selectedButton, Player currPlayer, MainBackground boardForm)
{
var opposedPlayer = currPlayer == DataStatic.Me ? DataStatic.Enemy : DataStatic.Me;
boardForm.SetTurnMsg(opposedPlayer);
SetControlsStatus(selectedButton, currPlayer);
if (currPlayer == DataStatic.Me)
{
await _socketConnection.SendAsync(selectedButton);
}
_judge.Move(currPlayer, selectedButton);
}
public async Task ProcessAsync(
ISocketConnection connection,
ReadOnlySequence <byte> slice,
CancellationToken cancellationToken)
{
if (TryParseMessage(slice, out OperationMessage? message))
{
await HandleMessageAsync(connection, message, cancellationToken);
}
else
{
await connection.SendAsync(
KeepConnectionAliveMessage.Default,
CancellationToken.None);
}
}
public async Task ProcessAsync(
ISocketConnection connection,
ReadOnlySequence <byte> slice,
CancellationToken cancellationToken)
{
try
{
if (TryParseMessage(slice, out OperationMessage? message))
{
await HandleMessageAsync(connection, message, cancellationToken);
}
else
{
await connection.SendAsync(
KeepConnectionAliveMessage.Default,
CancellationToken.None);
}
}
catch (WebSocketException)
{
// we will just stop receiving
}
}
private async Task SendResultsAsync()
{
await using IResponseStream responseStream = _responseStream;
CancellationToken cancellationToken = _sessionToken;
try
{
await foreach (IQueryResult result in
responseStream.ReadResultsAsync().WithCancellation(cancellationToken))
{
using (result)
{
if (!cancellationToken.IsCancellationRequested && !_connection.Closed)
{
await _connection.SendAsync(
new DataResultMessage(Id, result),
cancellationToken);
}
}
}
if (!cancellationToken.IsCancellationRequested && !_connection.Closed)
{
await _connection.SendAsync(new DataCompleteMessage(Id), cancellationToken);
}
}
catch (OperationCanceledException) when(cancellationToken.IsCancellationRequested)
{
}
catch (ObjectDisposedException) { }
catch (Exception ex) when(!cancellationToken.IsCancellationRequested)
{
if (!_connection.Closed)
{
try
{
try
{
await _connection.SendAsync(
new DataResultMessage(Id, UnknownSubscriptionError(ex)),
cancellationToken);
}
finally
{
await _connection.SendAsync(
new DataCompleteMessage(Id),
cancellationToken);
await _sessionInterceptor.OnCloseAsync(_connection, cancellationToken);
}
}
catch
{
// suppress all errors, so original exception can be rethrown
}
}
_diagnosticEvents.SubscriptionTransportError(Subscription, ex);
}
finally
{
// completed should be always invoked to be ensure that disposed subscription is
// removed from subscription manager
Completed?.Invoke(this, EventArgs.Empty);
Dispose();
}
}
public static Task SendAsync(
this ISocketConnection connection,
OperationMessage message,
CancellationToken cancellationToken) =>
connection.SendAsync(message.Serialize(), cancellationToken);
