/// <inheritdoc />
public async Task ConnectAsync(ISession session, CancellationToken ct = default(CancellationToken),
bool appearOnline = false, int connectTimeout = 5000)
{
if (_listener != null)
{
await _listener.CloseAsync();
_messageReplies.Clear();
_listener.Dispose();
_listener = null;
}
var addr = new UriBuilder(_baseUri)
{
Path = "/ws",
Query = string.Concat("lang=en&status=", appearOnline, "&token=", session.AuthToken)
};
var timeoutTask = Task.Delay(TimeSpan.FromMilliseconds(connectTimeout), ct);
var connectTask = _client.ConnectAsync(addr.Uri, ct);
// Limit time (msec) allowed for connect attempts.
if (await Task.WhenAny(connectTask, timeoutTask).ConfigureAwait(false) == timeoutTask)
{
throw new TimeoutException($"Socket connect timed out after '{connectTimeout}' milliseconds.");
}
_listener = await connectTask.ConfigureAwait(false);
ReadSocketAsync(ct);
WriteSocketAsync(ct);
}
private async Task HandleWebSocketAsync(WebSocket websocket)
{
try
{
if (OnConnect != null)
OnConnect.Invoke(websocket);
while (websocket.IsConnected)
{
var message = await websocket.ReadStringAsync(CancellationToken.None)
.ConfigureAwait(false);
if (message != null && OnMessage != null)
OnMessage.Invoke(websocket, message);
}
if (OnDisconnect != null)
OnDisconnect.Invoke(websocket);
}
catch (Exception ex)
{
if (OnError != null)
OnError.Invoke(websocket, ex);
}
finally
{
websocket.Dispose();
}
}
public void Disconnect()
{
Log.Print(LogType.Game, "Client disconnected.");
if (Socket.IsConnected)
{
Socket.Close();
}
isReady = false;
Socket.Dispose();
}
private static async Task EchoAllIncomingMessagesAsync(WebSocket webSocket, CancellationToken cancellation)
{
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' connected.");
var sw = new Stopwatch();
try
{
while (webSocket.IsConnected && !cancellation.IsCancellationRequested)
{
try
{
var messageText = await webSocket.ReadStringAsync(cancellation).ConfigureAwait(false);
if (messageText == null)
{
break; // webSocket is disconnected
}
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' recived: " + messageText + ".");
sw.Restart();
messageText = WebSocketHandler(messageText);
await webSocket.WriteStringAsync(messageText, cancellation).ConfigureAwait(false);
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' sent: " + messageText + ".");
sw.Stop();
}
catch (TaskCanceledException)
{
break;
}
catch (Exception readWriteError)
{
Console.WriteLine("An error occurred while reading/writing echo message.", readWriteError);
await webSocket.CloseAsync().ConfigureAwait(false);
}
}
}
finally
{
webSocket.Dispose();
Console.WriteLine("Client '" + webSocket.RemoteEndpoint + "' disconnected.");
}
}
static async Task HandleConnectionAsync(WebSocket ws, CancellationToken cancellation)
{
try
{
while (ws.IsConnected && !cancellation.IsCancellationRequested)
{
String msg = await ws.ReadStringAsync(cancellation).ConfigureAwait(false);
Log("Message: " + msg);
ws.WriteString(msg);
}
}
catch (Exception aex)
{
Log("Error Handling connection: " + aex.GetBaseException().Message);
try { ws.Close(); }
catch { }
}
finally
{
ws.Dispose();
}
}
private static void DisconnectWebSocket(WebSocket con)
{
Task.Run(() => con.Dispose());
}
static async Task HandleConnectionAsync(WebSocket ws, CancellationToken cancellation)
{
try
{
IWebSocketLatencyMeasure l = ws as IWebSocketLatencyMeasure;
PerformanceCounters.Connected.Increment();
while (ws.IsConnected && !cancellation.IsCancellationRequested)
{
String msg = await ws.ReadStringAsync(cancellation).ConfigureAwait(false);
PerformanceCounters.MessagesIn.Increment();
ws.WriteString(msg);
PerformanceCounters.MessagesOut.Increment();
PerformanceCounters.Delay.IncrementBy(l.Latency.Ticks * Stopwatch.Frequency / 10000);
PerformanceCounters.DelayBase.Increment();
}
}
catch (TaskCanceledException)
{
}
catch (Exception aex)
{
Log("Error Handling connection: " + aex.GetBaseException().Message);
try { ws.Close(); }
catch { }
}
finally
{
ws.Dispose();
PerformanceCounters.Connected.Decrement();
}
}
private async Task HandleWebSocketAsync(WebSocket websocket)
{
try
{
OnConnect?.Invoke(websocket);
while (websocket.IsConnected)
{
var messageReadStream = await websocket.ReadMessageAsync(CancellationToken.None);
if (messageReadStream != null)
{
switch (messageReadStream.MessageType)
{
case WebSocketMessageType.Text:
using (var sr = new StreamReader(messageReadStream, Encoding.UTF8))
{
var stringMessage = await sr.ReadToEndAsync();
if (!string.IsNullOrEmpty(stringMessage))
{
OnPlainTextMessage?.Invoke(websocket, stringMessage);
}
}
break;
case WebSocketMessageType.Binary:
using (var ms = new MemoryStream())
{
await messageReadStream.CopyToAsync(ms);
var data = ms.ToArray();
if (data.Length > 0)
{
OnEncryptedMessage?.Invoke(websocket, data);
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
OnDisconnect?.Invoke(websocket);
}
catch (Exception ex)
{
OnError?.Invoke(websocket, ex);
}
finally
{
websocket.Dispose();
}
}
public void Dispose()
{
_webSocket.Dispose();
}
static async Task HandleConnectionAsync(WebSocket ws, CancellationToken cancellation)
{
bool isAuthenticated = false;
try
{
Interlocked.Increment(ref PerformanceCounters.Connected);
Console.WriteLine("Connected " + PerformanceCounters.Connected);
await WaitForAuthenticateMessage(ws, cancellation).ConfigureAwait(false);
isAuthenticated = true;
await WaitForMessage(ws, cancellation).ConfigureAwait(false);
}
catch (TaskCanceledException)
{
}
catch (Exception aex)
{
Log("Error Handling connection: " + aex.GetBaseException().Message);
try { ws.Close(); }
catch { }
}
finally
{
ws.Dispose();
Interlocked.Increment(ref PerformanceCounters.Connected);
Interlocked.Increment(ref PerformanceCounters.Accepted);
if (isAuthenticated)
{
Interlocked.Increment(ref PerformanceCounters.Authenticated);
}
Console.WriteLine("Connected " + PerformanceCounters.Connected);
Console.WriteLine("Accepted " + PerformanceCounters.Accepted);
Console.WriteLine("Authenticated " + PerformanceCounters.Authenticated);
}
}
static async Task HandleConnectionAsync(WebSocket ws, CancellationToken token)
{
try
{
PerformanceCounters.Connected.Increment();
Byte[] buffer = new Byte[2046];
Int32 readed;
IWebSocketLatencyMeasure l = ws as IWebSocketLatencyMeasure;
while (ws.IsConnected && !token.IsCancellationRequested)
{
// await a message
using (var messageReader = await ws.ReadMessageAsync(token).ConfigureAwait(false))
{
if (messageReader == null)
continue; // disconnection
switch (messageReader.MessageType)
{
case WebSocketMessageType.Text:
PerformanceCounters.MessagesIn.Increment();
using (var messageWriter = ws.CreateMessageWriter(WebSocketMessageType.Text))
{
readed = -1;
Int32 r = 0;
while(readed!=0)
{
readed = messageReader.Read(buffer, 0, buffer.Length);
if (readed != 0)
{
messageWriter.Write(buffer, 0, readed);
r += readed;
}
}
await messageWriter.CloseAsync(token).ConfigureAwait(false);
}
PerformanceCounters.MessagesOut.Increment();
break;
case WebSocketMessageType.Binary:
using (var messageWriter = ws.CreateMessageWriter(WebSocketMessageType.Binary))
await messageReader.CopyToAsync(messageWriter).ConfigureAwait(false);
break;
}
}
PerformanceCounters.Delay.IncrementBy(l.Latency.Ticks * Stopwatch.Frequency / 10000);
PerformanceCounters.DelayBase.Increment();
}
}
catch (TaskCanceledException)
{
}
catch (Exception aex)
{
var ex = aex.GetBaseException();
_log.Error("HandleConnectionAsync", ex);
Log("Error Handling connection: " + ex.GetType().Name + ": " + ex.Message);
try { ws.Close(); }
catch { }
}
finally
{
ws.Dispose();
PerformanceCounters.Connected.Decrement();
}
}
private async Task HandleWebSocketAsync(WebSocket websocket, ConnectionPrincipal connectionPrincipal)
{
VtortWebsocket soWebsocket = new VtortWebsocket(websocket, connectionPrincipal);
try
{
Trace.TraceInformation("Server onConnect()");
connectionPrincipal.OperationMessageListener.OnConnect(soWebsocket);
while (websocket.IsConnected)
{
var message = await websocket.ReadMessageAsync(CancellationToken.None)
.ConfigureAwait(false);
if (message != null)
{
switch (message.MessageType)
{
case WebSocketMessageType.Text:
using (var sr = new StreamReader(message, Encoding.UTF8))
{
String msgContent = await sr.ReadToEndAsync();
connectionPrincipal.OperationMessageListener.OnMessage(soWebsocket, msgContent);
}
break;
case WebSocketMessageType.Binary:
using (var ms = new MemoryStream())
{
await message.CopyToAsync(ms);
if (ms.Length > 0)
{
connectionPrincipal.OperationMessageListener.OnMessage(soWebsocket, ms.ToArray());
}
}
break;
}
}
}
}
catch (Exception ex)
{
connectionPrincipal.OperationMessageListener.OnError(ex);
}
finally
{
connectionPrincipal.OperationMessageListener.OnClose(soWebsocket, 1000, "");
//Dispose before onClose is complete ???
websocket.Dispose();
}
}
public void Dispose()
{
_messageReplies.Clear();
_listener?.Dispose();
OnDisconnect?.Invoke(this, EventArgs.Empty);
}
async Task HandleConnectionAsync(WebSocket ws, CancellationToken cancellation)
{
try
{
while (ws.IsConnected && !cancellation.IsCancellationRequested)
{
// Get the JSON Message.
String msg = await ws.ReadStringAsync(cancellation).ConfigureAwait(false);
if (msg != null)
{
// Convert the JSON String to a dictionary
Dictionary<string, dynamic> msgDict = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(msg); ;
// If the dictionary contains a uniqueId, the message is a log-in request.
if (msgDict.ContainsKey("uniqueId"))
{
this.HandleMatchQueue(ws, msgDict);
}
// Message doesn't contain a UniqueId field.
else
{
// Make sure the websocket is in a match
if (wsToIdDictionary.ContainsKey(ws))
{
idToPlayerDictionary[wsToIdDictionary[ws]].currentMatch.AcceptMessage(ws, msgDict);
}
}
}
}
}
catch (Exception aex)
{
Console.WriteLine("Error Handling connection: " + aex.GetBaseException().Message);
try { ws.Close(); }
catch { }
}
// Theoretically, this happens when the ws disconnected, right?
finally
{
if (wsToIdDictionary.ContainsKey(ws))
{
if (attackerQueue.Contains(wsToIdDictionary[ws]))
{
string tempId = wsToIdDictionary[ws];
// loop ends when we find the id matching the ws we want to remove.
while (tempId != attackerQueue.Peek())
{
attackerQueue.Enqueue(attackerQueue.Dequeue());
}
attackerQueue.Dequeue();
}
}
if (wsToIdDictionary.ContainsKey(ws))
{
if (defenderQueue.Contains(wsToIdDictionary[ws]))
{
string tempId = wsToIdDictionary[ws];
// loop ends when we find the id matching the ws we want to remove.
while (tempId != defenderQueue.Peek())
{
defenderQueue.Enqueue(attackerQueue.Dequeue());
}
defenderQueue.Dequeue();
}
}
if (wsToIdDictionary.ContainsKey(ws))
{
if (idToPlayerDictionary.ContainsKey(wsToIdDictionary[ws]))
{
idToPlayerDictionary[wsToIdDictionary[ws]].currentMatch.ws_disconnected(ws);
}
}
if (ws.IsConnected)
{
ws.Dispose();
}
}
}