/// <summary>
/// Continuously reads data from the websocket.
/// </summary>
public async Task HandleSocket()
{
try
{
var buffer = new byte[Utilities.Server.ReceiveBufferSize];
WebSocketReceiveResult result = await ClientSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
await ParseMessage(result, buffer);
while (!ClientSocket.CloseStatus.HasValue)
{
buffer = new byte[Utilities.Server.ReceiveBufferSize];
result = await ClientSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
await ParseMessage(result, buffer);
}
if (Utilities.Server.ClientList.Contains(this))
{
Utilities.Server.ClientList.Remove(this);
}
await ClientSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
catch (Exception ex)
{
if (Utilities.Server.ClientList.Contains(this))
{
Utilities.Server.ClientList.Remove(this);
}
await ClientSocket.CloseOutputAsync(WebSocketCloseStatus.InternalServerError, "An unhandled exception occurred.", CancellationToken.None);
SocketError?.Invoke(this, ex);
SocketClosed?.Invoke(this, EventArgs.Empty);
ClientSocket.Dispose();
}
}
internal override void OnMessage(string method, JsonElement?serverParams)
{
switch (method)
{
case "close":
Close?.Invoke(this, EventArgs.Empty);
break;
case "frameSent":
FrameSent?.Invoke(
this,
new WebSocketFrame(
serverParams?.GetProperty("data").ToObject <string>(),
serverParams?.GetProperty("opcode").ToObject <int>() == OpcodeBase64));
break;
case "frameReceived":
FrameReceived?.Invoke(
this,
new WebSocketFrame(
serverParams?.GetProperty("data").ToObject <string>(),
serverParams?.GetProperty("opcode").ToObject <int>() == OpcodeBase64));
break;
case "socketError":
SocketError?.Invoke(this, serverParams?.GetProperty("error").ToObject <string>());
break;
}
}
/// <summary>
/// Worker method for sending commands
/// </summary>
private async void CommandWorker()
{
while (!_commandCancellationToken.IsCancellationRequested)
{
try
{
CurrentCommand = null;
if (_queueSize == 0)
{
_queueEmptyEvent.Set();
}
try
{
if (_commandQueue.TryTake(out CurrentCommand, 10, _commandCancellationToken.Token))
{
Interlocked.Decrement(ref _queueSize);
Logger?.WriteLine("Writing Command: '" + CurrentCommand.CommandText.Replace('\r', '\'') + "'", OBDLogLevel.Verbose);
if (Connection.IsAsync)
{
await Connection.WriteAsync(Encoding.ASCII.GetBytes(CurrentCommand.CommandText));
}
else
{
// ReSharper disable once MethodHasAsyncOverload
Connection.Write(Encoding.ASCII.GetBytes(CurrentCommand.CommandText));
}
//wait for command to finish
if (CurrentCommand.WaitForResponse)
{
if (CurrentCommand.Timeout.HasValue)
{
_commandFinishedEvent.WaitOne(CurrentCommand.Timeout.Value);
}
else
{
_commandFinishedEvent.WaitOne();
}
}
}
}
catch (OperationCanceledException)
{
/*ignore, because it is thrown when the cancellation token is canceled*/
}
}
catch (Exception ex)
{
SocketError?.Invoke(this, new SocketErrorEventArgs(ex));
Connection.Dispose();
}
}
}
/// <summary>
/// Raises the SocketError event.
/// </summary>
/// <param name="ex">The socket exception.</param>
protected void InvokeSocketError(Exception ex)
{
var prevSocketOpenedEventCount = Interlocked.CompareExchange(ref _socketOpenedEventCount, 0, 1);
if (prevSocketOpenedEventCount == 1)
{
SocketError?.Invoke(this, ex);
}
}
private void OnSocketError(SocketError error)
{
SocketError?.Invoke(this, new SocketErrorEventArgs(error));
// OperationAborted comes up when we closed the socket manually.
if (error != System.Net.Sockets.SocketError.OperationAborted)
{
Stop();
}
}
internal WebSocket(IChannelOwner parent, string guid, WebSocketInitializer initializer) : base(parent, guid)
{
_channel = new(guid, parent.Connection, this);
_initializer = initializer;
_channel.Close += (_, _) =>
{
IsClosed = true;
Close?.Invoke(this, this);
};
_channel.FrameReceived += (_, e) => FrameReceived?.Invoke(this, e);
_channel.FrameSent += (_, e) => FrameSent?.Invoke(this, e);
_channel.SocketError += (_, e) => SocketError?.Invoke(this, e);
}
internal override void OnMessage(string method, JsonElement?serverParams)
{
bool IsTextOrBinaryFrame(out int opcode)
{
opcode = serverParams?.GetProperty("opcode").ToObject <int>() ?? 0;
return(opcode != 1 && opcode != 2);
}
int opcode;
switch (method)
{
case "close":
Close?.Invoke(this, EventArgs.Empty);
break;
case "frameSent":
if (IsTextOrBinaryFrame(out opcode))
{
break;
}
FrameSent?.Invoke(
this,
new WebSocketFrame(
serverParams?.GetProperty("data").ToObject <string>(),
opcode == OpcodeBase64));
break;
case "frameReceived":
if (IsTextOrBinaryFrame(out opcode))
{
break;
}
FrameReceived?.Invoke(
this,
new WebSocketFrame(
serverParams?.GetProperty("data").ToObject <string>(),
opcode == OpcodeBase64));
break;
case "socketError":
SocketError?.Invoke(this, serverParams?.GetProperty("error").ToObject <string>());
break;
}
}
protected int CallFunction(string name, IArguments args, ICaller caller)
{
try {
CallBody call = new CallBody()
{
Call = name, Args = args as Arguments
};
MessageBody message = new MessageBody()
{
Flag = MessageFlag.Message,
Guid = this.Guid,
Content = AESHelper.Encrypt(this.JsonSerialzation.Serialize(call), this.AESKey)
};
string text = this.JsonSerialzation.Serialize(message);
this.Send(text, this.TcpClient);
return(0);
} catch (SocketException ex) {
SocketError?.Invoke(this, new SocketExcptionEventArgs(this.Guid, ex));
return(-1);
}
}
/// <summary>
/// Hooks up events to automatically be redirected to the interface's events.
/// </summary>
private void HookupEvents()
{
Socket.OnMessage += (sender, e) =>
{
SocketMessageEventArgs args = new SocketMessageEventArgs
{
Message = e.Data
};
MessageReceived?.Invoke(this, args);
};
Socket.OnError += (sender, e) =>
{
SocketErrorEventArgs args = new SocketErrorEventArgs
{
Exception = e.Exception,
Message = e.Message
};
SocketError?.Invoke(this, args);
};
Socket.OnClose += (sender, e) =>
{
SocketClosedEventArgs args = new SocketClosedEventArgs
{
Code = e.Code,
Reason = e.Reason,
WasClean = e.WasClean
};
SocketClosed?.Invoke(this, args);
};
Socket.OnOpen += (sender, e) =>
{
SocketOpened?.Invoke(this, null);
};
}
internal override void OnMessage(string method, JsonElement?serverParams)
{
switch (method)
{
case "close":
Close?.Invoke(this, EventArgs.Empty);
break;
case "frameSent":
FrameSent?.Invoke(
this,
new WebSocketFrameEventArgs
{
Payload = serverParams?.GetProperty("data").ToObject <string>(),
});
break;
case "frameReceived":
FrameReceived?.Invoke(
this,
new WebSocketFrameEventArgs
{
Payload = serverParams?.GetProperty("data").ToObject <string>(),
});
break;
case "error":
SocketError?.Invoke(
this,
new WebSocketErrorEventArgs
{
ErrorMessage = serverParams?.GetProperty("error").ToObject <string>(),
});
break;
}
}
private async void ReceiveCore()
{
try
{
var ws = _WebSocket;
var ct = _WebSocketCancellationTokenSource?.Token ?? default(CancellationToken);
if (ws?.State == WebSocketState.Open)
{
var buf = new byte[1024];
var js = new JsonSerializer();
while (ws?.State == WebSocketState.Open)
{
using (var ms = new MemoryStream())
{
while (ws?.State == WebSocketState.Open)
{
ct.ThrowIfCancellationRequested();
var res = await ws.ReceiveAsync(new ArraySegment <byte>(buf, 0, buf.Length), ct).ConfigureAwait(false);
ms.Write(buf, 0, res.Count);
if (ms.Length > 0 && res.EndOfMessage)
{
break;
}
await Task.Delay(1).ConfigureAwait(false);
}
ms.Position = 0;
using (var sr = new StreamReader(ms, Encoding.UTF8))
using (var jtr = new JsonTextReader(sr))
{
var jo = js.Deserialize <JObject>(jtr);
switch (jo?.Property("type")?.Value?.Value <string>())
{
case "welcome":
await SendSubscribeAsync(ws, ct).ConfigureAwait(false);
continue;
case "ping":
LastPingAt = DateTime.Now;
continue;
case "confirm_subscription":
_Connected?.TrySetResult(0);
_Connected = null;
continue;
}
try
{
var msg = jo?.Property("message")?.Value?.Value <JObject>();
var eventName = msg?.Property("event")?.Value?.Value <string>();
switch (eventName)
{
case "message_created":
DispatchEvent(msg, MessageCreated);
break;
case "message_updated":
DispatchEvent(msg, MessageUpdated);
break;
case "profile_updated":
DispatchEvent(msg, ProfileUpdated);
break;
case "channels_updated":
DispatchEvent(msg, ChannelsUpdated);
break;
case "channel_archived":
DispatchEvent(msg, ChannelArchived);
break;
case "channel_unarchived":
DispatchEvent(msg, ChannelUnarchived);
break;
case "member_joined":
DispatchEvent(msg, MemberJoined);
break;
case "member_leaved":
DispatchEvent(msg, MemberLeaved);
break;
}
}
catch (Exception ex2)
{
try
{
SocketError?.Invoke(this, new EventArgs <Exception>(ex2));
}
catch { }
}
}
}
}
}
}
catch (Exception ex)
{
try
{
SocketError?.Invoke(this, new EventArgs <Exception>(ex));
}
catch { }
DisposeWebSocket();
}
finally
{
LastPingAt = null;
Disconnected?.Invoke(this, EventArgs.Empty);
}
}
private void WebSocket_OnError(object sender, WebSocketSharp.ErrorEventArgs e)
{
var eventArgs = new ErrorEventArgs(e.Message, e.Exception);
SocketError?.Invoke(this, eventArgs);
}
// Error
protected virtual void OnSocketError(SocketException ex)
{
SocketError?.Invoke(this, new SocketErrorEventArgs(ex));
}
private void OnSocketError(object sender, SocketErrorEventArgs e)
{
SocketError?.Invoke(this, e);
}
protected void OnSocketError(SocketResultCode result, SocketResultCode nativeError)
{
SocketError?.Invoke(this, result, nativeError);
}
private void WebSocket_OnError(object sender, ErrorEventArgs e)
{
SocketError?.Invoke(sender,
new WebSocketErrorEventArgs(e.Exception, e.Message));
}
/// <summary>
/// Called when an error is raised by the WebSocket.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="ErrorEventArgs"/> instance containing the event data.</param>
private void OnWebSocketError(object sender, ErrorEventArgs e)
{
Logger.Debug(Log("[{0}] Socket error: {1}", SessionId, e.Exception.Message), e.Exception);
SocketError?.Invoke(this, e.Exception);
}
