public WebSocketMessageReadStream ExtendReader(WebSocketMessageReadStream message)
{
if (message.Flags.Rsv1)
return new WebSocketDeflateReadStream(message);
else
return message;
}
public async Task HandleWebSocketAsync()
{
try
{
RaiseConnectionOpen();
while (IsConnected)
{
WebSocketMessageReadStream message =
await mWebsocket.ReadMessageAsync(CancellationToken.None)
.ConfigureAwait(false);
if (message != null)
{
using (message)
{
WampMessage <TMessage> parsed = await ParseMessage(message).ConfigureAwait(false);
RaiseMessageArrived(parsed);
}
}
}
RaiseConnectionClosed();
}
catch (Exception ex)
{
RaiseConnectionError(ex);
}
}
public WebSocketDeflateReadStream(WebSocketMessageReadStream inner)
{
if (inner == null)
{
throw new ArgumentNullException(nameof(inner));
}
_inner = inner;
_deflate = new DeflateStream(_inner, CompressionMode.Decompress, true);
}
public WebSocketDeflateReadStream([NotNull] WebSocketMessageReadStream innerStream)
{
if (innerStream == null)
{
throw new ArgumentNullException(nameof(innerStream));
}
this.innerStream = innerStream;
this.deflateStream = new DeflateStream(innerStream, CompressionMode.Decompress, leaveOpen: true);
}
protected async override Task <WampMessage <TMessage> > ParseMessage(WebSocketMessageReadStream readStream)
{
using (StreamReader streamReader = new StreamReader(readStream))
{
string raw = await streamReader.ReadToEndAsync();
WampMessage <TMessage> result = mBinding.Parse(raw);
return(result);
}
}
protected override async Task <WampMessage <TMessage> > ParseMessage(WebSocketMessageReadStream readStream)
{
using (MemoryStream memoryStream = new MemoryStream())
{
await readStream.CopyToAsync(memoryStream).ConfigureAwait(false);
byte[] bytes = memoryStream.ToArray();
WampMessage <TMessage> result = mBinding.Parse(bytes);
return(result);
}
}
public WebSocketMessageReadStream ExtendReader(WebSocketMessageReadStream message)
{
if (message.Flags.Rsv1)
{
return(new WebSocketDeflateReadStream(message));
}
else
{
return(message);
}
}
public WebSocketDeflateReadStream([NotNull] WebSocketMessageReadStream innerStream)
{
if (innerStream == null)
{
throw new ArgumentNullException(nameof(innerStream));
}
this.innerStream = innerStream;
this.bufferManager = innerStream.Options.BufferManager;
this.inflaterBuffer = this.bufferManager.TakeBuffer(this.bufferManager.LargeBufferSize);
this.inflater = new Inflater(noHeader: false);
}
public WebSocketMessageReadStream ExtendReader(WebSocketMessageReadStream message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.Flags.Rsv1)
{
return(new WebSocketDeflateReadStream(message));
}
else
{
return(message);
}
}
private async Task <WebCastData> GetStreamInfo(WebSocket webSocket, CancellationToken cancellation)
{
while (webSocket.IsConnected && !cancellation.IsCancellationRequested)
{
WebSocketMessageReadStream message = await webSocket.ReadMessageAsync(cancellation).ConfigureAwait(false);
if (message == null)
{
continue;
}
if (message.MessageType != WebSocketMessageType.Text)
{
throw new Exception("Hello must be said");
}
string messageContent;
using (StreamReader streamReader = new StreamReader(message, Encoding.UTF8))
{
messageContent = await streamReader.ReadToEndAsync();
}
WebCastMessage webCastMessage = messageContent.FromJson <WebCastMessage>();
if (webCastMessage.Type == "hello")
{
WebCastMessage helloMessage = webCastMessage;
_logger.Debug($"Mount point: {webSocket.HttpRequest.RequestUri}");
_logger.Debug($"MIME type: {webCastMessage.Data.Mime}");
_logger.Debug($"Audio channels: {webCastMessage.Data.Audio.Channels}");
if (webCastMessage.Data.Mime == "audio/mpeg")
{
_logger.Debug($"Audio bitrate: {webCastMessage.Data.Audio.BitRate}");
}
helloMessage.Data.MountPoint = Regex.Replace(webSocket.HttpRequest.RequestUri.OriginalString, @"^/", string.Empty);
return(helloMessage.Data);
}
break;
}
_logger.Error("Say hello first!");
throw new Exception("Should have said hello");
}
private static async void HandleClient(object arg)
{
WebSocket client = (WebSocket)arg;
while (true)
{
WebSocketMessageReadStream message = await client.ReadMessageAsync(CancellationToken.None);
if (!client.IsConnected || message == null)
{
Log.Print(LogType.Lobby, "A client disconnected");
client.Dispose();
return;
}
Log.Print(LogType.Debug, $"RECV {message.MessageType} {(message.MessageType == WebSocketMessageType.Text ? message.ReadText() : message.ReadBinary())}");
message.Dispose();
}
}
/// <summary>
/// The main loop of the client. Listens for messages, and detects client disconnection
/// </summary>
/// <returns></returns>
public async Task ProcessConnection()
{
CancellationToken token = _cancellationTokenSource.Token;
// This fixes "deadlock"-ish issue with unit tests, I don't understand why yet
// It probably has to do with the synchronization context that the unit tests run in
await Task.Yield();
try
{
do
{
WebSocketMessageReadStream messageReadStream =
await Socket.ReadMessageAsync(token);
// Client disconnected
if (messageReadStream == null)
{
_logger.Trace("Client {0}'s stream closed", ID);
return;
}
if (messageReadStream.MessageType == WebSocketMessageType.Text)
{
string msgContent;
using (StreamReader sr = new StreamReader(messageReadStream, Encoding.UTF8))
msgContent = await sr.ReadToEndAsync();
MessageReceived?.Invoke(this, msgContent);
}
} while (Socket.IsConnected && !token.IsCancellationRequested);
}
catch (Exception e)
{
_logger.Error(e);
}
finally
{
Socket.Dispose();
_isClosed.SetResult(true);
}
}
public WebSocketDeflateReadStream(WebSocketMessageReadStream inner)
{
_inner = inner;
_deflate = new DeflateStream(_inner, CompressionMode.Decompress, true);
}
public WebSocketSharpDeflateReadStream(WebSocketMessageReadStream inner)
{
_inner = inner;
_deflate = new DeflateStream(_inner, CompressionMode.Decompress, true);
}
public WebSocketMessageReadStream ExtendReader(WebSocketMessageReadStream message)
{
return(message.Flags.Rsv1 ? new WebSocketSharpDeflateReadStream(message) : message);
}
public async void HandleConnection()
{
Log.Print(LogType.Debug, "Handling Connection");
BindingFlags bindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static;
while (true)
{
WebSocketMessageReadStream message = await Socket.ReadMessageAsync(CancellationToken.None);
if (message == null)
{
Log.Print(LogType.Debug, "Message is null");
Disconnect();
return;
}
if (message.MessageType == WebSocketMessageType.Text)
{
var msgContent = string.Empty;
using (var sr = new StreamReader(message, Encoding.UTF8))
msgContent = await sr.ReadToEndAsync();
Log.Print(LogType.Debug, msgContent);
}
else if (message.MessageType == WebSocketMessageType.Binary)
{
using (var ms = new MemoryStream())
{
await message.CopyToAsync(ms);
await ms.FlushAsync();
ms.Seek(0, SeekOrigin.Begin);
object requestData;
try
{
requestData = EvosSerializer.Instance.Deserialize(ms);
}
catch (Exception e)
{
Log.Print(LogType.Error, Convert.ToBase64String(ms.ToArray()));
Log.Print(LogType.Error, e.ToString());
continue;
}
Type requestType = requestData.GetType();
#if DEBUG
//Log data or hide it?
String packetDataToLog = (bool)requestType.GetField("LogData", bindingFlags).GetValue(null) ? JsonConvert.SerializeObject(requestData) :"{...}";
Log.Print(LogType.Network, $"Received {requestType.Name} : {packetDataToLog}");
#endif
// Handle Response
Type responseHandlerType = Type.GetType($"EvoS.LobbyServer.NetworkMessageHandlers.{requestType.Name}Handler");
if (responseHandlerType == null)
{
#if DEBUG
Log.Print(LogType.Warning, $"No Handler for {requestType.Name}");
#endif
continue;
}
object responseHandler = responseHandlerType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
var task = (Task)responseHandlerType.GetMethod("OnMessage").Invoke(responseHandler, new[] { this, requestData });
await task.ConfigureAwait(false);
await task;
}
}
//Console.WriteLine($"RECV {message.MessageType} {(message.MessageType == WebSocketMessageType.Text ? message.ReadText() : message.ReadBinary())}");
message.Dispose();
}
}
protected abstract Task <WampMessage <TMessage> > ParseMessage(WebSocketMessageReadStream readStream);
private IConnectableObservable <byte[]> CreateObserver(WebSocket webSocket)
{
return(Observable.Create <byte[]>(async(observer, cancellation) =>
{
try
{
while (webSocket.IsConnected && !cancellation.IsCancellationRequested)
{
WebSocketMessageReadStream message =
await webSocket.ReadMessageAsync(cancellation)
.ConfigureAwait(false);
if (message == null)
{
continue;
}
switch (message.MessageType)
{
case WebSocketMessageType.Text:
string messageContent;
using (StreamReader streamReader =
new StreamReader(message, Encoding.UTF8))
{
messageContent = await streamReader.ReadToEndAsync();
}
WebCastMessage webCastMessage =
messageContent.FromJson <WebCastMessage>();
switch (webCastMessage.Type)
{
case "metadata":
_logger.Debug("Metadata received: {webCastMessage.Data}");
break;
default:
_logger.Warning("Invalid message");
break;
}
break;
case WebSocketMessageType.Binary:
byte[] bytes = message.ReadFully();
observer.OnNext(bytes);
break;
}
}
observer.OnCompleted();
}
catch (Exception exception)
{
_logger.Error(exception, "Error Handling connection");
observer.OnError(exception);
}
return Disposable.Create(webSocket.Dispose);
})
.Publish());
}
