public ReceiveAsync ( System |
||
buffer | System |
|
cancellationToken | System | |
return | System.Threading.Tasks.Task |
private void TestWebSockets() { var socket = new ClientWebSocket(); Console.WriteLine("Connecting"); socket.ConnectAsync(new Uri("wss://echo.websocket.org"), CancellationToken.None).Wait(); Console.WriteLine("Sending"); socket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello")), WebSocketMessageType.Text, true, CancellationToken.None).Wait(); var buffer = new byte[1024]; Console.WriteLine("Receiving"); var result = socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None).Result; Console.WriteLine($"Recieved: {Encoding.UTF8.GetString(buffer, 0, result.Count)}"); }
private async Task ListenAsync() { while (true) { var buffer = new byte[ReceiveChunkSize]; var stringResult = new List <byte>(); var binaryResult = new List <byte>(); WebSocketReceiveResult result = null; while (_ws.State == WebSocketState.Open) { try { //result = await _ws.ReceiveAsync(new ArraySegment<byte>(buffer), _wsWorkTokenSource.Token); result = await _ws.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { Close("io server disconnect"); break; } else if (result.MessageType == WebSocketMessageType.Text) { stringResult.AddRange(buffer.Take(result.Count)); } else if (result.MessageType == WebSocketMessageType.Binary) { binaryResult.AddRange(buffer.Take(result.Count)); } if (result.EndOfMessage) { break; } } catch (WebSocketException e) { Close(e.Message); break; } } if (result == null) { break; } if (result.MessageType == WebSocketMessageType.Text) { string message = Encoding.UTF8.GetString(stringResult.ToArray()); #if DEBUG Trace.WriteLine($"⬇ {DateTime.Now} {message}"); #endif _parser.Unpack(message); } else if (result.MessageType == WebSocketMessageType.Binary) { #if DEBUG Trace.WriteLine($"⬇ {DateTime.Now} Binary message"); #endif _io.InvokeBytesReceived(_io.Options.EIO == 4 ? binaryResult.ToArray() : binaryResult.Skip(1).ToArray()); } } }
public static async Task RunSample() { ClientWebSocket websocket = new ClientWebSocket(); string url = "ws://localhost:5000/"; Console.WriteLine("Connecting to: " + url); await websocket.ConnectAsync(new Uri(url), CancellationToken.None); string message = "Hello World"; Console.WriteLine("Sending message: " + message); byte[] messageBytes = Encoding.UTF8.GetBytes(message); await websocket.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None); byte[] incomingData = new byte[1024]; WebSocketReceiveResult result = await websocket.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None); if (result.CloseStatus.HasValue) { Console.WriteLine("Closed; Status: " + result.CloseStatus + ", " + result.CloseStatusDescription); } else { Console.WriteLine("Received message: " + Encoding.UTF8.GetString(incomingData, 0, result.Count)); } }
private Task PullResponse() { return(Task.Factory.StartNew(async() => { string result = string.Empty; var allBytes = new List <byte>(); while (WebSocketState.Open == socket.State && !this._cancellationTokenSource.Token.IsCancellationRequested) { var rcvBuffer = WebSocket.CreateClientBuffer(4096, 4096); WebSocketReceiveResult webSocketReceiveResult = await socket.ReceiveAsync(rcvBuffer, this._cancellationTokenSource.Token); if (null != webSocketReceiveResult) { allBytes.AddRange(new List <byte>(rcvBuffer).GetRange(0, webSocketReceiveResult.Count)); if (allBytes.Count > 0 && webSocketReceiveResult.EndOfMessage) { result = Encoding.UTF8.GetString(allBytes.ToArray(), 0, allBytes.Count); Console.Write(result); allBytes.Clear(); } } } if (!string.IsNullOrEmpty(result) && PassThru.ToBool()) { WriteObject(result.TrimEnd()); } }, this._cancellationTokenSource.Token)); }
public async Task WebsocketBasic(HostType hostType) { using (ApplicationDeployer deployer = new ApplicationDeployer()) { string applicationUrl = deployer.Deploy(hostType, WebsocketBasicConfiguration); using (var client = new ClientWebSocket()) { await client.ConnectAsync(new Uri(applicationUrl.Replace("http://", "ws://")), CancellationToken.None); var receiveBody = new byte[100]; for (int i = 0; i < 4; i++) { var message = "Message " + i.ToString(); byte[] sendBody = Encoding.UTF8.GetBytes(message); await client.SendAsync(new ArraySegment<byte>(sendBody), WebSocketMessageType.Text, true, CancellationToken.None); var receiveResult = await client.ReceiveAsync(new ArraySegment<byte>(receiveBody), CancellationToken.None); Assert.Equal(WebSocketMessageType.Text, receiveResult.MessageType); Assert.True(receiveResult.EndOfMessage); Assert.Equal(sendBody.Length, receiveResult.Count); Assert.Equal(message, Encoding.UTF8.GetString(receiveBody, 0, receiveResult.Count)); } } } }
public async void TestConnectWebSocket() { if (TestHelper.IsMono) { Assert.Inconclusive("Mono doesn't have support to WebSockets"); } Assert.IsNotNull(WebServer.Module<WebSocketsModule>(), "WebServer has WebSocketsModule"); Assert.AreEqual(WebServer.Module<WebSocketsModule>().Handlers.Count, 1, "WebSocketModule has one handler"); var clientSocket = new ClientWebSocket(); var ct = new CancellationTokenSource(); await clientSocket.ConnectAsync(new Uri(Resources.WsServerAddress + "/test"), ct.Token); Assert.AreEqual(clientSocket.State, WebSocketState.Open, "Connection is open"); var message = new ArraySegment<byte>(System.Text.Encoding.Default.GetBytes("HOLA")); var buffer = new ArraySegment<byte>(new byte[1024]); await clientSocket.SendAsync(message, WebSocketMessageType.Text, true, ct.Token); var result = await clientSocket.ReceiveAsync(buffer, ct.Token); Assert.IsTrue(result.EndOfMessage); Assert.IsTrue(System.Text.Encoding.UTF8.GetString(buffer.Array).TrimEnd((char) 0) == "WELCOME"); }
public static async Task Send(ClientWebSocket websocket) { string message = "Hello World"; //Console.WriteLine("Sending message: " + message); byte[] messageBytes = Encoding.UTF8.GetBytes(message); await websocket.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None); byte[] incomingData = new byte[1024]; WebSocketReceiveResult result = await websocket.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None); }
private static async Task startRunner() { var socketUrl = await getSocketUrl(); ClientWebSocket ws = new ClientWebSocket(); await ws.ConnectAsync(new Uri($"ws://{socketUrl}"), CancellationToken.None); var buffer = new byte[1024 * 10]; await send(ws, new CreateNewGameRequestSocketMessage() { GameType = "sevens" }); while (true) { var segment = new ArraySegment<byte>(buffer); var result = await ws.ReceiveAsync(segment, CancellationToken.None); switch (result.MessageType) { case WebSocketMessageType.Binary: byte[] bytes = new byte[result.Count]; Array.ConstrainedCopy(segment.Array, 0, bytes, 0, result.Count); var obj = Serializer.Deserialize(bytes); if (obj is GameStartedSocketMessage) { totalGames++; games++; } else if (obj is AskQuestionSocketMessage) { var answerQ = (AskQuestionSocketMessage)obj; await send(ws, new AnswerQuestionSocketMessage() { AnswerIndex = (short)(answerQ.Answers.Length > 1 ? 1 : 0) }); totalAnswers++; } else if (obj is GameOverSocketMessage) { await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done", CancellationToken.None); games--; return; } break; case WebSocketMessageType.Close: await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done", CancellationToken.None); break; default: throw new ArgumentOutOfRangeException(); } } }
private async Task ListenAsync() { var buffer = new byte[ReceiveChunkSize]; try { while (_ws.State == WebSocketState.Open) { var stringResult = new StringBuilder(); var binaryResult = new List <byte>(); WebSocketReceiveResult result; do { result = await _ws.ReceiveAsync(new ArraySegment <byte>(buffer), _connectionToken.Token); if (result.MessageType == WebSocketMessageType.Close) { Close(); } else if (result.MessageType == WebSocketMessageType.Text) { string str = Encoding.UTF8.GetString(buffer, 0, result.Count); stringResult.Append(str); } else if (result.MessageType == WebSocketMessageType.Binary) { binaryResult.AddRange(buffer.Take(result.Count)); } } while (!result.EndOfMessage); if (result.MessageType == WebSocketMessageType.Text) { string message = stringResult.ToString(); #if DEBUG Trace.WriteLine($"⬇ {DateTime.Now} {message}"); #endif _parser.Unpack(message); } else if (result.MessageType == WebSocketMessageType.Binary) { #if DEBUG var builder = new StringBuilder(); binaryResult.ForEach(b => builder.Append(b)); Trace.WriteLine($"⬇ {DateTime.Now} {builder}"); #endif _io.InvokeBytesReceived(binaryResult.Skip(1).ToArray()); } } } finally { // _ws.Dispose(); } }
static async Task Run() { var ws = new ClientWebSocket(); await ws.ConnectAsync(new Uri("ws://localhost:8088"), CancellationToken.None); byte[] buf = new byte[4096]; var seg = new ArraySegment<byte>(buf, 0, buf.Length); var r1 = await ws.ReceiveAsync(seg, CancellationToken.None); string id = UTF8Encoding.UTF8.GetString(buf, 0, r1.Count); Console.WriteLine("SessionId=" + id); for (int i = 0; i < 20; i++) { var msg = UTF8Encoding.UTF8.GetBytes("Send(" + i + ")"); await ws.SendAsync(new ArraySegment<byte>(msg, 0, msg.Length), WebSocketMessageType.Text, true, CancellationToken.None); var rcv = await ws.ReceiveAsync(seg, CancellationToken.None); string response = UTF8Encoding.UTF8.GetString(buf, 0, rcv.Count); Console.WriteLine("Response=" + response); Thread.Sleep(2000); } }
private static async Task Receive(ClientWebSocket webSocket) { byte[] buffer = new byte[receiveChunkSize]; while (webSocket.State == WebSocketState.Open) { var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); } else { LogStatus(true, buffer, result.Count); } } }
private async System.Threading.Tasks.Task <Response> ReceiveMessage() { // Receive one web socket message System.Collections.Generic.List <System.Collections.Generic.IEnumerable <byte> > segments = new System.Collections.Generic.List <System.Collections.Generic.IEnumerable <byte> >(); try { while (true) { byte[] buffer = new byte[4096]; var segment = new System.ArraySegment <byte>(buffer, 0, buffer.Length); System.Net.WebSockets.WebSocketReceiveResult rcvResult = await ws.ReceiveAsync(segment, stopServerTokenSource.Token); // Accumulate the byte arrays in a list, we will join them later segments.Add(segment.Skip(segment.Offset).Take(rcvResult.Count)); if (rcvResult.EndOfMessage) { break; } } } catch (System.Net.WebSockets.WebSocketException e) { throw e.InnerException; } catch (System.Exception) { throw new ErrorException("Error receiving response from server."); } try { byte[] bytes = segments.SelectMany(t => t).ToArray <byte>(); string msg = System.Text.Encoding.UTF8.GetString(bytes); return(Parse(msg)); } catch (ErrorException e) { // Dispatch already built error throw e; } catch (System.Exception) { throw new ErrorException("Error while parsing response from server."); } }
private async Task ReadEventsAsync() { var socket = new ClientWebSocket(); await socket.ConnectAsync(new Uri("ws://localhost:7070/events"), CancellationToken.None); while (true) { var buffer = new byte[1024]; var segment = new ArraySegment<byte>(buffer); var result = await socket.ReceiveAsync(segment, CancellationToken.None); var data = Encoding.UTF8.GetString(segment.Array, 0, result.Count); Debug.WriteLine(data); } }
private async Task ListenAsync() { var buffer = new byte[ReceiveChunkSize]; while (_ws.State == WebSocketState.Open && !_wsWorkTokenSource.IsCancellationRequested) { var stringResult = new StringBuilder(); var binaryResult = new List <byte>(); WebSocketReceiveResult result; do { result = await _ws.ReceiveAsync(new ArraySegment <byte>(buffer), _wsWorkTokenSource.Token); if (result.MessageType == WebSocketMessageType.Close) { Close("io server disconnect"); } else if (result.MessageType == WebSocketMessageType.Text) { string str = Encoding.UTF8.GetString(buffer, 0, result.Count); stringResult.Append(str); } else if (result.MessageType == WebSocketMessageType.Binary) { binaryResult.AddRange(buffer.Take(result.Count)); } } while (!result.EndOfMessage); if (result.MessageType == WebSocketMessageType.Text) { string message = stringResult.ToString(); #if DEBUG Trace.WriteLine($"⬇ {DateTime.Now} {message}"); #endif _parser.Unpack(message); } else if (result.MessageType == WebSocketMessageType.Binary) { #if DEBUG Trace.WriteLine($"⬇ {DateTime.Now} Binary message"); #endif _io.InvokeBytesReceived(binaryResult.Skip(1).ToArray()); } } }
// Define other methods and classes here private async Task Receive(ClientWebSocket webSocket) { var buffer = new byte[64]; while (webSocket.State == WebSocketState.Open) { var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); } else { DeserializeAndEnqueue(buffer, result.Count); } //if(Console.KeyAvailable) // break; } }
private static void ReceiveWebsocketMessageAndAppend(ClientWebSocket client, List<String> messages) { var receiveBuffer = new byte[1024]; var receiveBufferSegment = new ArraySegment<byte>(receiveBuffer); try { var result = client.ReceiveAsync(receiveBufferSegment, CancellationToken.None).Result; if (result.Count > 0) { var message = Encoding.Default.GetString(receiveBuffer.Take(result.Count).ToArray()); if (message.Contains("error")) { throw new Exception("websocket returned an error message"); } messages.Add(message); } } catch (Exception) { } }
public async Task EndToEnd_ConnectAndClose_Success() { OwinHttpListener listener = CreateServer(env => { var accept = (WebSocketAccept)env["websocket.Accept"]; Assert.NotNull(accept); accept( null, async wsEnv => { var sendAsync1 = wsEnv.Get<WebSocketSendAsync>("websocket.SendAsync"); var receiveAsync1 = wsEnv.Get<WebSocketReceiveAsync>("websocket.ReceiveAsync"); var closeAsync1 = wsEnv.Get<WebSocketCloseAsync>("websocket.CloseAsync"); var buffer1 = new ArraySegment<byte>(new byte[10]); await receiveAsync1(buffer1, CancellationToken.None); await closeAsync1((int)WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None); }); return TaskHelpers.Completed(); }, HttpServerAddress); using (listener) { using (var client = new ClientWebSocket()) { await client.ConnectAsync(new Uri(WsClientAddress), CancellationToken.None); await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); WebSocketReceiveResult readResult = await client.ReceiveAsync(new ArraySegment<byte>(new byte[10]), CancellationToken.None); Assert.Equal(WebSocketCloseStatus.NormalClosure, readResult.CloseStatus); Assert.Equal("Closing", readResult.CloseStatusDescription); Assert.Equal(0, readResult.Count); Assert.True(readResult.EndOfMessage); Assert.Equal(WebSocketMessageType.Close, readResult.MessageType); } } }
private async Task Receive(ClientWebSocket socket) { var buffer = new byte[2048]; while (socket.State == WebSocketState.Open) { var result = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); } else { var json = Encoding.ASCII.GetString(buffer).TrimEnd('\0'); var notification = JsonConvert.DeserializeObject<WebSocketClientNotification>(json); NotificationReceived?.Invoke(this, new WebSocketClientNotificationEventArgs(notification)); Array.Clear(buffer,0,buffer.Length); } } }
public async Task Subscribe(CancellationToken cancel) { byte[] buffer = new byte[1024 * 1024]; ArraySegment<byte> segment = new ArraySegment<byte>(buffer); ByteString currentRecord = await this.store.GetLastTransaction(); while (!cancel.IsCancellationRequested) { try { ClientWebSocket socket = new ClientWebSocket(); this.endpoint.Query = string.Format("from={0}", currentRecord.ToString()); logger.LogInformation("Connecting to {0}", this.endpoint.Uri); await socket.ConnectAsync(this.endpoint.Uri, cancel); while (true) { WebSocketReceiveResult result = await socket.ReceiveAsync(segment, cancel); if (result.MessageType == WebSocketMessageType.Close) break; ByteString record = new ByteString(buffer.Take(result.Count)); await store.AddTransactions(new[] { record }); currentRecord = new ByteString(MessageSerializer.ComputeHash(record.ToByteArray())); } } catch (Exception exception) { logger.LogError("Error in the stream subscriber: {0}", exception.ToString()); } await Task.Delay(TimeSpan.FromMinutes(1)); } }
public override async Task RunAsync(CancellationToken cancellationToken) { using (var ws = new ClientWebSocket()) { await ws.ConnectAsync(_rtm.WebSocketUri, cancellationToken); while (!cancellationToken.IsCancellationRequested) { using (var ms = new MemoryStream()) { WebSocketReceiveResult result; do { result = await ws.ReceiveAsync(_buffer, cancellationToken); await ms.WriteAsync(_buffer.Array, _buffer.Offset, result.Count, cancellationToken); } while (!result.EndOfMessage); ms.Seek(0, SeekOrigin.Begin); HandleEvent(ms); } } } }
public async Task EndToEnd_EchoData_Success() { OwinHttpListener listener = CreateServer(env => { var accept = (WebSocketAccept)env["websocket.Accept"]; Assert.NotNull(accept); accept( null, async wsEnv => { var sendAsync = wsEnv.Get<WebSocketSendAsync>("websocket.SendAsync"); var receiveAsync = wsEnv.Get<WebSocketReceiveAsync>("websocket.ReceiveAsync"); var closeAsync = wsEnv.Get<WebSocketCloseAsync>("websocket.CloseAsync"); var buffer = new ArraySegment<byte>(new byte[100]); Tuple<int, bool, int> serverReceive = await receiveAsync(buffer, CancellationToken.None); await sendAsync(new ArraySegment<byte>(buffer.Array, 0, serverReceive.Item3), serverReceive.Item1, serverReceive.Item2, CancellationToken.None); await closeAsync((int)WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None); }); return TaskHelpers.Completed(); }, HttpServerAddress); using (listener) { using (var client = new ClientWebSocket()) { await client.ConnectAsync(new Uri(WsClientAddress), CancellationToken.None); byte[] sendBody = Encoding.UTF8.GetBytes("Hello World"); await client.SendAsync(new ArraySegment<byte>(sendBody), WebSocketMessageType.Text, true, CancellationToken.None); var receiveBody = new byte[100]; WebSocketReceiveResult readResult = await client.ReceiveAsync(new ArraySegment<byte>(receiveBody), CancellationToken.None); Assert.Equal(WebSocketMessageType.Text, readResult.MessageType); Assert.True(readResult.EndOfMessage); Assert.Equal(sendBody.Length, readResult.Count); Assert.Equal("Hello World", Encoding.UTF8.GetString(receiveBody, 0, readResult.Count)); } } }
public async Task SubProtocol_SelectLastSubProtocol_Success() { OwinHttpListener listener = CreateServer(env => { var accept = (WebSocketAccept)env["websocket.Accept"]; Assert.NotNull(accept); var requestHeaders = env.Get<IDictionary<string, string[]>>("owin.RequestHeaders"); var responseHeaders = env.Get<IDictionary<string, string[]>>("owin.ResponseHeaders"); // Select the last sub-protocol from the client. string subProtocol = requestHeaders["Sec-WebSocket-Protocol"].Last().Split(',').Last().Trim(); responseHeaders["Sec-WebSocket-Protocol"] = new string[] { subProtocol + "A" }; accept( new Dictionary<string, object>() { { "websocket.SubProtocol", subProtocol } }, async wsEnv => { var sendAsync = wsEnv.Get<WebSocketSendAsync>("websocket.SendAsync"); var receiveAsync = wsEnv.Get<WebSocketReceiveAsync>("websocket.ReceiveAsync"); var closeAsync = wsEnv.Get<WebSocketCloseAsync>("websocket.CloseAsync"); var buffer = new ArraySegment<byte>(new byte[100]); Tuple<int, bool, int> serverReceive = await receiveAsync(buffer, CancellationToken.None); // Assume close received await closeAsync((int)WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None); }); return TaskHelpers.Completed(); }, HttpServerAddress); using (listener) { using (var client = new ClientWebSocket()) { client.Options.AddSubProtocol("protocol1"); client.Options.AddSubProtocol("protocol2"); await client.ConnectAsync(new Uri(WsClientAddress), CancellationToken.None); await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None); var receiveBody = new byte[100]; WebSocketReceiveResult readResult = await client.ReceiveAsync(new ArraySegment<byte>(receiveBody), CancellationToken.None); Assert.Equal(WebSocketMessageType.Close, readResult.MessageType); Assert.Equal("protocol2", client.SubProtocol); } } }
public async Task Receive(ClientWebSocket webSocket) { byte[] buffer = new byte[1024]; string TempString = ""; while (webSocket.State == WebSocketState.Open) { var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); } else { TempString = Encoding.UTF8.GetString(buffer); TempString = TempString.Remove(result.Count); if (TempString.Substring(TempString.Length - 1, 1) == "}" || TempString == "hello") { DecodeServerPacket(TempString); TempString = ""; } } } }
private async Task ListenAsync() { while (true) { var buffer = new byte[ReceiveChunkSize]; int count = 0; WebSocketReceiveResult result = null; while (_ws.State == WebSocketState.Open) { try { //result = await _ws.ReceiveAsync(new ArraySegment<byte>(buffer), _wsWorkTokenSource.Token); var subBuffer = new byte[ReceiveChunkSize]; result = await _ws.ReceiveAsync(new ArraySegment <byte>(subBuffer), CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { Close("io server disconnect"); break; } else if (result.MessageType == WebSocketMessageType.Text || result.MessageType == WebSocketMessageType.Binary) { if (buffer.Length - count < result.Count) { Array.Resize(ref buffer, buffer.Length + result.Count); } Buffer.BlockCopy(subBuffer, 0, buffer, count, result.Count); count += result.Count; } if (result.EndOfMessage) { break; } } catch (WebSocketException e) { Close(e.Message); break; } } if (result == null) { break; } if (result.MessageType == WebSocketMessageType.Text) { string message = Encoding.UTF8.GetString(buffer, 0, count); #if DEBUG Trace.WriteLine($"⬇ {DateTime.Now} {message}"); #endif _parser.Unpack(message); } else if (result.MessageType == WebSocketMessageType.Binary) { #if DEBUG Trace.WriteLine($"⬇ {DateTime.Now} Binary message"); #endif byte[] bytes; if (_io.Options.EIO == 3) { count -= 1; bytes = new byte[count]; Buffer.BlockCopy(buffer, 1, bytes, 0, count); } else { bytes = new byte[count]; Buffer.BlockCopy(buffer, 0, bytes, 0, count); } _io.InvokeBytesReceived(bytes); } } }
public Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> buffer, CancellationToken cancellationToken) { return(webSocket.ReceiveAsync(buffer, cancellationToken)); }
private void RefreshInternal(string debuggerUrl) { if (string.IsNullOrEmpty(debuggerUrl)) return; ClientWebSocket connection = new ClientWebSocket(); connection.ConnectAsync(new Uri(debuggerUrl), _token).Wait(); PageReloadRequest request = new PageReloadRequest(); string rawRequest = request.ToJson(); var data = new ArraySegment<byte>(Encoding.UTF8.GetBytes(rawRequest)); connection.SendAsync(data, WebSocketMessageType.Text, true, _token).Wait(); var buffer = new ArraySegment<byte>(new byte[1024]); Task<WebSocketReceiveResult> receiveAsync = connection.ReceiveAsync(buffer, _token); receiveAsync.Wait(); string rawResponse = Encoding.UTF8.GetString(buffer.Array, 0, receiveAsync.Result.Count); DebugProtocolResponse response = rawResponse.FromJson<DebugProtocolResponse>(); if (null != response.Error) { Trace.TraceWarning("Browser returned an error as a response to reload request: {0}", response.Error.Message); } connection.Dispose(); }
private async Task<string> ReceiveFromSocket(ClientWebSocket theSocket) { // receive var arraySegment = new ArraySegment<byte>(new Byte[1024 * 256]); var res = await theSocket.ReceiveAsync(arraySegment, CancellationToken.None); return Encoding.UTF8.GetString(arraySegment.Actualize(res.Count)); }
private static async void Subscribe(string product, Action<RealtimeMessage> onMessageReceived) { if (String.IsNullOrWhiteSpace(product)) throw new ArgumentNullException("product"); if (onMessageReceived == null) throw new ArgumentNullException("onMessageReceived", "Message received callback must not be null."); var uri = new Uri("wss://ws-feed.exchange.coinbase.com"); var webSocketClient = new ClientWebSocket(); var cancellationToken = new CancellationToken(); var requestString = String.Format(@"{{""type"": ""subscribe"",""product_id"": ""{0}""}}", product); var requestBytes = UTF8Encoding.UTF8.GetBytes(requestString); await webSocketClient.ConnectAsync(uri, cancellationToken); if (webSocketClient.State == WebSocketState.Open) { var subscribeRequest = new ArraySegment<byte>(requestBytes); var sendCancellationToken = new CancellationToken(); await webSocketClient.SendAsync(subscribeRequest, WebSocketMessageType.Text, true, sendCancellationToken); while (webSocketClient.State == WebSocketState.Open) { var receiveCancellationToken = new CancellationToken(); var receiveBuffer = new ArraySegment<byte>(new byte[1024 * 1024 * 5]); // 5MB buffer var webSocketReceiveResult = await webSocketClient.ReceiveAsync(receiveBuffer, receiveCancellationToken); if (webSocketReceiveResult.Count == 0) continue; var jsonResponse = Encoding.UTF8.GetString(receiveBuffer.Array, 0, webSocketReceiveResult.Count); var jToken = JToken.Parse(jsonResponse); var typeToken = jToken["type"]; if (typeToken == null) continue; var type = typeToken.Value<string>(); RealtimeMessage realtimeMessage = null; switch (type) { case "received": realtimeMessage = new RealtimeReceived(jToken); break; case "open": realtimeMessage = new RealtimeOpen(jToken); break; case "done": realtimeMessage = new RealtimeDone(jToken); break; case "match": realtimeMessage = new RealtimeMatch(jToken); break; case "change": realtimeMessage = new RealtimeChange(jToken); break; default: break; } if (realtimeMessage == null) continue; onMessageReceived(realtimeMessage); } } }
public async Task Subscribe(CancellationToken cancel) { byte[] buffer = new byte[1024 * 1024]; ArraySegment<byte> segment = new ArraySegment<byte>(buffer); IServiceScopeFactory scopeFactory = services.GetService<IServiceScopeFactory>(); ILogger logger = services.GetRequiredService<ILogger>(); while (!cancel.IsCancellationRequested) { try { using (IServiceScope scope = scopeFactory.CreateScope()) { IStorageEngine storageEngine = scope.ServiceProvider.GetRequiredService<IStorageEngine>(); await storageEngine.Initialize(); ByteString currentRecord = await storageEngine.GetLastTransaction(); ClientWebSocket socket = new ClientWebSocket(); this.endpoint.Query = string.Format("from={0}", currentRecord.ToString()); logger.LogInformation("Connecting to {0}", this.endpoint.Uri); await socket.ConnectAsync(this.endpoint.Uri, cancel); while (true) { ByteString transaction; using (MemoryStream stream = new MemoryStream(1024)) { WebSocketReceiveResult result; do { result = await socket.ReceiveAsync(segment, cancel); if (result.MessageType == WebSocketMessageType.Close) break; stream.Write(segment.Array, segment.Offset, result.Count); } while (!result.EndOfMessage); stream.Seek(0, SeekOrigin.Begin); using (BinaryReader reader = new BinaryReader(stream)) { transaction = new ByteString(reader.ReadBytes((int)stream.Length)); } } await storageEngine.AddTransactions(new[] { transaction }); currentRecord = new ByteString(MessageSerializer.ComputeHash(transaction.ToByteArray())); } } } catch (Exception exception) { logger.LogError("Error in the stream subscriber: {0}", exception.ToString()); } await Task.Delay(TimeSpan.FromMinutes(1)); } }
protected void SendIntegrationTestMessages() { using (var client1 = new ClientWebSocket()) using (var client2 = new ClientWebSocket()) { client1.ConnectAsync(new Uri("ws://localhost:8989"), CancellationToken.None).Wait(); Task.Delay(100).Wait(); client2.ConnectAsync(new Uri("ws://localhost:8989"), CancellationToken.None).Wait(); Task.Delay(100).Wait(); var bytes2 = new byte[1024]; var segment2 = new ArraySegment<byte>(bytes2); var receive2 = client2.ReceiveAsync(segment2, CancellationToken.None); var message1 = "Hello world"; var bytes1 = Encoding.UTF8.GetBytes(message1); var segment1 = new ArraySegment<byte>(bytes1); client1.SendAsync(segment1, WebSocketMessageType.Text, true, CancellationToken.None).Wait(); Task.Delay(100).Wait(); var result2 = receive2.Result; Assert.AreEqual(WebSocketMessageType.Text, result2.MessageType); var message3 = Encoding.UTF8.GetString(segment2.Array, 0, result2.Count); Assert.AreEqual("User 1: Hello world", message3); client2.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait(); client2.Dispose(); Task.Delay(100).Wait(); client1.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait(); client1.Dispose(); Task.Delay(100).Wait(); } }
public void AuthorizationTest() { using (WebApp.Start(new StartOptions("http://localhost:8989"), startup => { startup.MapOwinFleckRoute("/fleck", connection => { var id = ConfigureIntegrationTestConnectionAndGetId(connection); connection.OnAuthenticateRequest = () => { var result = id % 2 == 1; Send(id, $"Auth {id}: {result}"); return result; }; }); })) using (var client1 = new ClientWebSocket()) using (var client2 = new ClientWebSocket()) using (var client3 = new ClientWebSocket()) { client1.ConnectAsync(new Uri("ws://localhost:8989/fleck"), CancellationToken.None).Wait(); try { client2.ConnectAsync(new Uri("ws://localhost:8989/fleck"), CancellationToken.None).Wait(); Assert.Fail("Client 2 should not be unauthorized"); } catch (AggregateException ex) { Assert.AreEqual("Unable to connect to the remote server", ex.InnerException.Message); } client3.ConnectAsync(new Uri("ws://localhost:8989/fleck"), CancellationToken.None).Wait(); var bytes3 = new byte[1024]; var segment3 = new ArraySegment<byte>(bytes3); var receive3 = client3.ReceiveAsync(segment3, CancellationToken.None); var message1 = "Hello world"; var bytes1 = Encoding.UTF8.GetBytes(message1); var segment1 = new ArraySegment<byte>(bytes1); client1.SendAsync(segment1, WebSocketMessageType.Text, true, CancellationToken.None).Wait(); var result3 = receive3.Result; Assert.AreEqual(WebSocketMessageType.Text, result3.MessageType); var message3 = Encoding.UTF8.GetString(segment3.Array, 0, result3.Count); Assert.AreEqual(message3, "User 1: Hello world"); client3.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait(); client3.Dispose(); Task.Delay(100).Wait(); client1.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait(); client1.Dispose(); Task.Delay(100).Wait(); } var messages = DequeueMessages(); Assert.AreEqual(8, messages.Count); Assert.AreEqual("Auth 1: True", messages[0]); Assert.AreEqual("Open: 1", messages[1]); Assert.AreEqual("Auth 2: False", messages[2]); Assert.AreEqual("Auth 3: True", messages[3]); Assert.AreEqual("Open: 3", messages[4]); Assert.AreEqual("User 1: Hello world", messages[5]); Assert.AreEqual("Close: 3", messages[6]); Assert.AreEqual("Close: 1", messages[7]); }
private async Task ListenAsync(CancellationToken cancellationToken) { while (true) { if (cancellationToken.IsCancellationRequested) { break; } var buffer = new byte[ReceiveChunkSize]; int count = 0; WebSocketReceiveResult result = null; while (_ws.State == WebSocketState.Open) { try { if (cancellationToken.IsCancellationRequested) { break; } var subBuffer = new byte[ReceiveChunkSize]; result = await _ws.ReceiveAsync(new ArraySegment <byte>(subBuffer), cancellationToken); if (result.MessageType == WebSocketMessageType.Close) { OnClosed("io server disconnect"); break; } else if (result.MessageType == WebSocketMessageType.Text || result.MessageType == WebSocketMessageType.Binary) { if (buffer.Length - count < result.Count) { Array.Resize(ref buffer, buffer.Length + result.Count); } Buffer.BlockCopy(subBuffer, 0, buffer, count, result.Count); count += result.Count; } if (result.EndOfMessage) { break; } } catch (WebSocketException e) { OnClosed(e.Message); break; } } if (result == null) { break; } if (result.MessageType == WebSocketMessageType.Text) { string message = Encoding.UTF8.GetString(buffer, 0, count); #if DEBUG System.Diagnostics.Trace.WriteLine($"⬇ {DateTime.Now} {message}"); #endif if (OnTextReceived is null) { throw new ArgumentNullException(nameof(OnTextReceived)); } OnTextReceived(message); } else if (result.MessageType == WebSocketMessageType.Binary) { #if DEBUG System.Diagnostics.Trace.WriteLine($"⬇ {DateTime.Now} Binary message"); #endif if (OnTextReceived is null) { throw new ArgumentNullException(nameof(OnTextReceived)); } byte[] bytes = new byte[count]; Buffer.BlockCopy(buffer, 0, bytes, 0, count); OnBinaryReceived(bytes); //byte[] bytes; //if (_io.Options.EIO == 3) //{ // count -= 1; // bytes = new byte[count]; // Buffer.BlockCopy(buffer, 1, bytes, 0, count); //} //else //{ // bytes = new byte[count]; // Buffer.BlockCopy(buffer, 0, bytes, 0, count); //} //_io.InvokeBytesReceived(bytes); } } }
private void dispatch() { const Int32 bufferSize = 128 * 1024; byte[] buffer = new byte[bufferSize]; bool breakOut = false; try { while (Interlocked.Read(ref state) != CLOSED) { ArraySegment <byte> segment = new ArraySegment <byte>(buffer); System.Net.WebSockets.WebSocketReceiveResult result; System.Threading.Tasks.Task <System.Net.WebSockets.WebSocketReceiveResult> r; try { r = clientWebSocket.ReceiveAsync(segment, System.Threading.CancellationToken.None); r.Wait(CancellationToken.None); result = r.Result; if (result.MessageType == WebSocketMessageType.Close) { Task t1 = clientWebSocket.CloseAsync((System.Net.WebSockets.WebSocketCloseStatus)result.CloseStatus, result.CloseStatusDescription, CancellationToken.None); t1.Wait(CancellationToken.None); notifyClose((int)result.CloseStatus, result.CloseStatusDescription); breakOut = true; break; } } catch (Exception e) { notifyError(e); break; } int count = result.Count; while (!result.EndOfMessage) { if (count > buffer.Length) { Task t1 = clientWebSocket.CloseAsync(WebSocketCloseStatus.InvalidPayloadData, "payload too long", CancellationToken.None); t1.Wait(CancellationToken.None); notifyClose((int)WebSocketCloseStatus.InvalidPayloadData, "payload too long"); return; } segment = new ArraySegment <byte>(buffer, count, buffer.Length - count); r = clientWebSocket.ReceiveAsync(segment, CancellationToken.None); r.Wait(CancellationToken.None); result = r.Result; if (result.MessageType == WebSocketMessageType.Close) { Task t1 = clientWebSocket.CloseAsync((System.Net.WebSockets.WebSocketCloseStatus)result.CloseStatus, result.CloseStatusDescription, CancellationToken.None); t1.Wait(CancellationToken.None); notifyClose((int)result.CloseStatus, result.CloseStatusDescription); breakOut = true; break; } else if (result.Count == 0) { // filled the buffer, resize it var newBuffer = new byte[buffer.Length + bufferSize]; Array.Copy(buffer, newBuffer, buffer.Length); buffer = newBuffer; } if (breakOut) { break; } count += result.Count; } // now invoke the callback. if (count > 0) { notifyMessage(buffer, count); } } } catch (Exception) { return; } return; }
public void RespondToMicrosoftWebSocketClient() { using(var socket = new ClientWebSocket()) { socket.ConnectAsync(new Uri("ws://127.0.0.1:20000/"), CancellationToken.None).Wait(1000); var buffer = Encoding.UTF8.GetBytes("abcdefg"); socket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None).Wait(1000); var receiveBuffer = ClientWebSocket.CreateClientBuffer(1024, 1024); var result = socket.ReceiveAsync(receiveBuffer, CancellationToken.None); result.Wait(1000); var msg = Encoding.UTF8.GetString(receiveBuffer.Array, 0, result.Result.Count); Assert.AreEqual("gfedcba", msg); } }
public async Task TestConnectWebSocket() { var wsUrl = Resources.WsServerAddress + "test"; Assert.IsNotNull(WebServer.Module<WebSocketsModule>(), "WebServer has WebSocketsModule"); Assert.AreEqual(WebServer.Module<WebSocketsModule>().Handlers.Count, 1, "WebSocketModule has one handler"); #if NET46 var clientSocket = new ClientWebSocket(); var ct = new CancellationTokenSource(); await clientSocket.ConnectAsync(new Uri(wsUrl), ct.Token); Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open"); var message = new ArraySegment<byte>(System.Text.Encoding.Default.GetBytes("HOLA")); var buffer = new ArraySegment<byte>(new byte[1024]); await clientSocket.SendAsync(message, WebSocketMessageType.Text, true, ct.Token); var result = await clientSocket.ReceiveAsync(buffer, ct.Token); Assert.IsTrue(result.EndOfMessage, "End of message is true"); Assert.IsTrue(System.Text.Encoding.UTF8.GetString(buffer.Array).TrimEnd((char) 0) == "WELCOME", "Final message is WELCOME"); #else var clientSocket = new WebSocket(wsUrl); clientSocket.Connect(); Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open"); clientSocket.Send("HOLA"); await Task.Delay(100); #endif }
private async Task ReceiveMessages(ClientWebSocket socket,string msg, int total) { var maxMessageSize = 1024; var receiveBuffer = new byte[maxMessageSize]; for (var i = 0; i < 10; i++) { var ret = await socket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); if (ret.MessageType != WebSocketMessageType.Text) continue; var count = ret.Count; while (!ret.EndOfMessage) { ret = await socket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer, count, maxMessageSize - count), CancellationToken.None); count += ret.Count; } var receivedString = Encoding.UTF8.GetString(receiveBuffer, 0, count); Trace.WriteLine(receivedString); Interlocked.Increment(ref _counter); } }