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()); }