public async Task <IOrder> CreateOrder(string clientUsername, DateTime orderDate, Dictionary <uint, uint> productIdQuantityMap, DateTime?deliveryDate) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.AddOrder, new OrderDTO { ClientUsername = clientUsername, OrderDate = orderDate, ProductIdQuantityMap = productIdQuantityMap, DeliveryDate = deliveryDate }); await WebSocketConnection.SendAsync(msg); string responseMsg; try { responseMsg = ReadMessage(); } catch (Exception e) { Debug.WriteLine($"Failed to add order! {e}"); return(null); } WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(responseMsg); if (!(response.Data is OrderDTO orderData)) { throw new ApplicationException("Provided order data object is invalid!"); } return(orderData.ToIOrder()); }
private async Task WriteAsync(WebSocketConnection ws, Message message) { string _messageAsString = message.Stringify <Message>(); Log($"Writing message {_messageAsString}"); await ws.SendAsync(_messageAsString); }
public async Task <IClient> CreateClient(string username, string firstName, string lastName, string street, uint streetNumber, string phoneNumber) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.AddClient, new ClientDTO { Username = username, FirstName = firstName, LastName = lastName, Street = street, StreetNumber = streetNumber, PhoneNumber = phoneNumber }); await WebSocketConnection.SendAsync(msg); string responseMsg; try { responseMsg = ReadMessage(); } catch (Exception e) { Debug.WriteLine($"Failed to add client! {e}"); return(null); } WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(responseMsg); if (!(response.Data is ClientDTO clientData)) { throw new ApplicationException("Provided client data object is invalid!"); } return(clientData.ToIClient()); }
public async Task ConnectToPeersTestMethod() { WebSocketConnection _connection = null; List <string> _log = new List <string>(); Task _server = WebSocketServer.Server(3001, x => { _connection = x; x.onMessage = m => _log.Add($"received message by test WS: {m}"); }); TestRepositoryNetwork _repository = new TestRepositoryNetwork(); using (CommunicationEngine _new = new CommunicationEngine(_repository, -1, x => _log.Add(x))) { Assert.AreEqual <int>(2, _log.Count); Assert.IsTrue(_repository.IsCosistent); Uri[] _peers = new Uri[] { new Uri("ws://localhost:3001") }; _new.ConnectToPeers(_peers); await Task.Delay(200); Assert.IsNotNull(_connection); Assert.AreEqual <int>(5, _log.Count); Message _requestLast = new Message() { data = string.Empty, type = Message.MessageType.QUERY_LATEST }; await _connection.SendAsync(_requestLast.Stringify <Message>()); await Task.Delay(300); Assert.AreEqual <int>(8, _log.Count); Assert.IsTrue(_log[7].Contains("received message by test")); } foreach (string _message in _log.ToArray()) { Debug.WriteLine(_message); } }
private async void PushFromOutputToWebSocket() { while (true) { var data = await _output.ReadAsync(); if (data.IsEmpty) { if (_output.Reading.IsCompleted) { break; } _output.Advance(data.End); } else { // note we don't need to create a mask here - is created internally var message = new Message(data, mask: 0, isFinal: true); var send = _webSocket.SendAsync(WebSocketsFrame.OpCodes.Binary, ref message); // can free up one lock on the data *before* we await... _output.Advance(data.End); await send; } } }
public async Task <IProduct> CreateProduct(string name, double price, ProductType productType) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.AddProduct, new ProductDTO { Name = name, Price = price, ProductType = productType }); await WebSocketConnection.SendAsync(msg); string responseMsg; try { responseMsg = ReadMessage(); } catch (Exception e) { Debug.WriteLine($"Failed to add product! {e}"); return(null); } WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(responseMsg); if (!(response.Data is ProductDTO productData)) { throw new ApplicationException("Provided product data object is invalid!"); } return(productData.ToIProduct()); }
public async Task TwoWayCommunication_MessagesReceivedAndValid() { const string MSG1 = "abcd", MSG2 = "ASDF123", MSG3 = "qwerty", MSG4 = "¹³œæÊÓÆŒ¥£"; ConcurrentQueue <string> serverMessages = new ConcurrentQueue <string>(), clientMessages = new ConcurrentQueue <string>(); using AutoResetEvent serverMsgEvent = new AutoResetEvent(false), clientConnEvent = new AutoResetEvent(false), clientMsgEvent = new AutoResetEvent(false); using ServerWebSocketConnection server = WebSocketServer.CreateServer(TEST_CONNECTION_PORT); server.OnMessage += (o, a) => { serverMessages.Enqueue(a.Message); serverMsgEvent.Set(); }; server.OnClientConnected += (o, a) => clientConnEvent.Set(); _ = Task.Run(server.RunServerLoop); using WebSocketConnection client = await WebSocketClient.ConnectAsync(TEST_CONNECTION_URI); client.OnMessage += (o, a) => { clientMessages.Enqueue(a.Message); clientMsgEvent.Set(); }; Assert.IsTrue(clientConnEvent.WaitOne(TEST_TIMEOUT)); await client.SendAsync(MSG1); Assert.IsTrue(serverMsgEvent.WaitOne(TEST_TIMEOUT)); await client.SendAsync(MSG2); Assert.IsTrue(serverMsgEvent.WaitOne(TEST_TIMEOUT)); await server.SendAsync(MSG3); Assert.IsTrue(clientMsgEvent.WaitOne(TEST_TIMEOUT)); await server.SendAsync(MSG4); Assert.IsTrue(clientMsgEvent.WaitOne(TEST_TIMEOUT)); Assert.AreEqual(2, serverMessages.Count); Assert.AreEqual(2, clientMessages.Count); Assert.IsTrue(serverMessages.TryDequeue(out string msg)); Assert.AreEqual(MSG1, msg); Assert.IsTrue(serverMessages.TryDequeue(out msg)); Assert.AreEqual(MSG2, msg); Assert.IsTrue(clientMessages.TryDequeue(out msg)); Assert.AreEqual(MSG3, msg); Assert.IsTrue(clientMessages.TryDequeue(out msg)); Assert.AreEqual(MSG4, msg); }
public async Task SendItems() { var fakeSocket = new FakeWebSocket(); var socketConnection = new WebSocketConnection(fakeSocket); await socketConnection.SendAsync("test", CancellationToken.None); Assert.IsNotNull(fakeSocket.FakeSendItems.LastOrDefault()); Assert.AreEqual("test", fakeSocket.FakeSendItems.LastOrDefault()); }
public async Task <HashSet <IProduct> > GetAllProducts() { await WebSocketConnection.SendAsync(WebSimpleMessageType.GetAllProducts.ToString()); WebMessageDTO <object> msg = WebSerializer.DeserializeWebMessage(ReadMessage()); if (!(msg.Data is HashSet <ProductDTO> productData)) { throw new ApplicationException("Provided product data object is invalid!"); } return(new HashSet <IProduct>(productData.Select(p => p.ToIProduct()))); }
public async Task <HashSet <IOrder> > GetAllOrders() { await WebSocketConnection.SendAsync(WebSimpleMessageType.GetAllOrders.ToString()); WebMessageDTO <object> msg = WebSerializer.DeserializeWebMessage(ReadMessage()); if (!(msg.Data is HashSet <OrderDTO> orderData)) { throw new ApplicationException("Provided order data object is invalid!"); } return(new HashSet <IOrder>(orderData.Select(o => o.ToIOrder()))); }
private async Task ServerSetup(WebSocketConnection connection) { Sockets.Add(connection); connection.onMessage = async(data) => { Log($"[Message]: {data}"); await connection.SendAsync(Resolve(data)); }; connection.onClose = () => { Log($"[Closing connection]: {connection}"); Sockets.Remove(connection); }; connection.onError = () => { Log($"[Error! Closing connection]: {connection}"); Sockets.Remove(connection); }; Log("[Sending message] Connected"); await connection.SendAsync("Connected"); }
public async Task <IProduct> GetProduct(uint id) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.GetProduct, id); await WebSocketConnection.SendAsync(msg); WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(ReadMessage()); if (!(response.Data is ProductDTO productData)) { throw new ApplicationException("Provided product data object is invalid!"); } return(productData.ToIProduct()); }
public async Task <IOrder> GetOrder(uint id) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.GetOrder, id); await WebSocketConnection.SendAsync(msg); WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(ReadMessage()); if (!(response.Data is OrderDTO orderData)) { throw new ApplicationException("Provided order data object is invalid!"); } return(orderData.ToIOrder()); }
public async Task <IClient> GetClient(string username) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.GetClient, username); await WebSocketConnection.SendAsync(msg); WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(ReadMessage()); if (!(response.Data is ClientDTO clientData)) { throw new ApplicationException("Provided client data object is invalid!"); } return(clientData.ToIClient()); }
public async Task <bool> RemoveProduct(IProduct product) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.RemoveProduct, new ProductDTO(product)); await WebSocketConnection.SendAsync(msg); string response = ReadMessage(); if (WebSerializer.TryParseRequest(response, out WebSimpleMessageType req) && req == WebSimpleMessageType.Success) { return(true); } Debug.WriteLine($"Failed to remove product! {response}"); return(false); }
public async Task <bool> Update(IOrder order) { string msg = WebSerializer.SerializeWebMessage(WebMessageType.UpdateOrder, new OrderDTO(order)); await WebSocketConnection.SendAsync(msg); string response = ReadMessage(); if (WebSerializer.TryParseRequest(response, out WebSimpleMessageType req) && req == WebSimpleMessageType.Success) { return(true); } Debug.WriteLine($"Failed to update order! {response}"); return(false); }
public override void OnOpened(WebSocketConnection socket) { Console.WriteLine("Connected socket: " + socket.ID); Task.Run(async() => { var rand = new Random(Environment.TickCount); while (true) { string quote = (rand.NextDouble() * 100.0).ToString("0.00"); await socket.SendAsync(quote); Thread.Sleep(1000); } }); }
public static Task SerializeAsync <T, U>(this ISerializer <T> serializer, WebSocketConnection <U> socket, T value) where U : WebSocket { if (serializer is null) { throw new ArgumentNullException(nameof(serializer)); } if (socket is null) { throw new ArgumentNullException(nameof(socket)); } var data = serializer.Serialize(value); return(socket.SendAsync(data)); }
public static Task SerializeAsync <T, U>(this ISerializer <T> serializer, WebSocketConnection <U> socket, string message, T value) where U : WebSocket { if (serializer is null) { throw new ArgumentNullException(nameof(serializer)); } if (socket is null) { throw new ArgumentNullException(nameof(socket)); } if (message is null) { throw new ArgumentNullException(nameof(message)); } return(socket.SendAsync(message, value, serializer)); }
public async Task Invoke(HttpContext context) { if (context.WebSockets.IsWebSocketRequest) { if (ValidateOrigin(context)) { var textSubProtocol = NegotiateSubProtocol(context.WebSockets.WebSocketRequestedProtocols); var webSocketCompressionProvider = _compressionService.NegotiateCompression(context); var webSocket = await context.WebSockets.AcceptWebSocketAsync(textSubProtocol?.SubProtocol); var webSocketConnection = new WebSocketConnection(webSocket, webSocketCompressionProvider, textSubProtocol ?? _options.DefaultSubProtocol, _options.ReceivePayloadBufferSize); webSocketConnection.ReceiveText += async(sender, message) => { await webSocketConnection.SendAsync(message, CancellationToken.None); }; _connectionsService.AddConnection(webSocketConnection); await webSocketConnection.ReceiveMessagesUntilCloseAsync(); if (webSocketConnection.CloseStatus.HasValue) { await webSocket.CloseAsync(webSocketConnection.CloseStatus.Value, webSocketConnection.CloseStatusDescription, CancellationToken.None); } _connectionsService.RemoveConnection(webSocketConnection.Id); } else { context.Response.StatusCode = StatusCodes.Status403Forbidden; } } else { context.Response.StatusCode = StatusCodes.Status400BadRequest; } }
private async void Channel_OnReceive(object sender, ChannelReceivedEventArgs e) { logger?.LogDebug("SCADA client channel starting receive."); try { MbapHeader header = MbapHeader.Decode(e.Message); RtuPiSystem piSystem = map.GetItem(header.UnitId); if (piSystem == null) { logger?.LogWarning("SCADA client receive cannot find RTU pi-system."); throw new InvalidOperationException("RTU pi-system was not found."); } if (!subscribed.Contains(header.UnitId)) { //subscribe to pi-system for unit id await connection.AddSubscriptionAsync(piSystem.RtuOutputEvent.ToLowerInvariant(), ReceiveOutput); subscribed.Add(header.UnitId); } byte[] msg = mapper.MapIn(e.Message); await connection.SendAsync(piSystem.RtuInputEvent.ToLowerInvariant(), CONTENT_TYPE, msg); MbapHeader mheader = MbapHeader.Decode(msg); //await connection.Monitor.SendInAsync(ModuleType.VRTU.ToString(), e.Message, mheader.TransactionId); } catch (Exception ex) { logger?.LogError($"SCADA client receive error - {ex.Message}"); OnError?.Invoke(this, new AdapterErrorEventArgs(Id, ex)); } }
private async Task ProcessClientMessage(WebSocketConnection connection, string message) { Console.WriteLine($"{connection}> {message}"); if (WebSerializer.TryParseRequest(message, out WebSimpleMessageType msgType)) { switch (msgType) { case WebSimpleMessageType.GetAllClients: { string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideAllClients, new HashSet <ClientDTO>( (await DataRepository.GetAllClients()) .Select(c => new ClientDTO(c)))); await connection.SendAsync(response); break; } case WebSimpleMessageType.GetAllProducts: { string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideAllProducts, new HashSet <ProductDTO>( (await DataRepository.GetAllProducts()) .Select(p => new ProductDTO(p)))); await connection.SendAsync(response); break; } case WebSimpleMessageType.GetAllOrders: { string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideAllOrders, new HashSet <OrderDTO>( (await DataRepository.GetAllOrders()) .Select(o => new OrderDTO(o)))); await connection.SendAsync(response); break; } } } else { try { WebMessageDTO <object> msgDto = WebSerializer.DeserializeWebMessage(message); switch (msgDto.MessageType) { case WebMessageType.AddClient: { if (msgDto.Data is ClientDTO clt) { IClient client = await DataRepository.CreateClient( clt.Username, clt.FirstName, clt.LastName, clt.Street, clt.StreetNumber, clt.PhoneNumber); if (client == null) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); } else { ClientDTO newDto = new ClientDTO(client); await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.ProvideClient, newDto)); await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.AddClient, newDto)); } } else { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); } break; } case WebMessageType.UpdateClient: { bool result = false; if (msgDto.Data is ClientDTO clt) { try { result = await DataRepository.Update(clt.ToIClient()); } catch (Exception e) { await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString())); } } await connection.SendAsync(result ?WebSimpleMessageType.Success.ToString() : WebSimpleMessageType.Failure.ToString()); if (result) { await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.UpdateClient, msgDto.Data)); } break; } case WebMessageType.RemoveClient: { bool result = false; if (msgDto.Data is ClientDTO clt) { try { result = await DataRepository.RemoveClient(clt.ToIClient()); } catch (Exception e) { await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString())); } } await connection.SendAsync(result ?WebSimpleMessageType.Success.ToString() : WebSimpleMessageType.Failure.ToString()); if (result) { await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.RemoveClient, msgDto.Data)); } break; } case WebMessageType.AddProduct: { if (msgDto.Data is ProductDTO prd) { IProduct product = await DataRepository.CreateProduct( prd.Name, prd.Price, prd.ProductType); if (product == null) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); } else { ProductDTO newDto = new ProductDTO(product); await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.ProvideProduct, newDto)); await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.AddProduct, newDto)); } } else { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); } break; } case WebMessageType.UpdateProduct: { bool result = false; if (msgDto.Data is ProductDTO prd) { try { result = await DataRepository.Update(prd.ToIProduct()); } catch (Exception e) { await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString())); } } await connection.SendAsync(result ?WebSimpleMessageType.Success.ToString() : WebSimpleMessageType.Failure.ToString()); if (result) { await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.UpdateProduct, msgDto.Data)); } break; } case WebMessageType.RemoveProduct: { bool result = false; if (msgDto.Data is ProductDTO prd) { try { result = await DataRepository.RemoveProduct(prd.ToIProduct()); } catch (Exception e) { await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString())); } } await connection.SendAsync(result ?WebSimpleMessageType.Success.ToString() : WebSimpleMessageType.Failure.ToString()); if (result) { await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.RemoveProduct, msgDto.Data)); } break; } case WebMessageType.AddOrder: { if (msgDto.Data is OrderDTO ord) { IOrder order = await DataRepository.CreateOrder( ord.ClientUsername, ord.OrderDate, ord.ProductIdQuantityMap, ord.DeliveryDate); if (order == null) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); } else { OrderDTO newDto = new OrderDTO(order); await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.ProvideOrder, newDto)); await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.AddOrder, newDto)); } } else { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); } break; } case WebMessageType.UpdateOrder: { bool result = false; if (msgDto.Data is OrderDTO ord) { try { result = await DataRepository.Update(ord.ToIOrder()); } catch (Exception e) { await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString())); } } await connection.SendAsync(result ?WebSimpleMessageType.Success.ToString() : WebSimpleMessageType.Failure.ToString()); if (result) { await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.UpdateOrder, msgDto.Data)); } break; } case WebMessageType.RemoveOrder: { bool result = false; if (msgDto.Data is OrderDTO ord) { try { result = await DataRepository.RemoveOrder(ord.ToIOrder()); } catch (Exception e) { await connection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString())); } } await connection.SendAsync(result ?WebSimpleMessageType.Success.ToString() : WebSimpleMessageType.Failure.ToString()); if (result) { await ServerWebSocketConnection.SendAsync( WebSerializer.SerializeWebMessage(WebMessageType.RemoveOrder, msgDto.Data)); } break; } case WebMessageType.GetClient: { if (!(msgDto.Data is string username)) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); break; } IClient client = await DataRepository.GetClient(username); if (client == null) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); break; } string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideClient, new ClientDTO(client)); await connection.SendAsync(response); break; } case WebMessageType.GetProduct: { if (!(msgDto.Data is uint id)) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); break; } IProduct product = await DataRepository.GetProduct(id); if (product == null) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); break; } string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideProduct, new ProductDTO(product)); await connection.SendAsync(response); break; } case WebMessageType.GetOrder: { if (!(msgDto.Data is uint id)) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); break; } IOrder order = await DataRepository.GetOrder(id); if (order == null) { await connection.SendAsync(WebSimpleMessageType.Failure.ToString()); break; } string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideOrder, new OrderDTO(order)); await connection.SendAsync(response); break; } } } catch (Exception e) { Console.WriteLine($"Failed to parse message '{message}' from a client! {e}"); } } }
public async Task MultipleClients_MessagesDistributedProperly() { const string MSG = "123"; List <WebSocketConnection> serverSideClients = new List <WebSocketConnection>(); uint serverMessages = 0U, c1Messages = 0U, c2Messages = 0U, c3Messages = 0U; using AutoResetEvent serverMsgEvent = new AutoResetEvent(false), clientConnEvent = new AutoResetEvent(false), client1MsgEvent = new AutoResetEvent(false), client2MsgEvent = new AutoResetEvent(false), client3MsgEvent = new AutoResetEvent(false); using (ServerWebSocketConnection server = WebSocketServer.CreateServer(TEST_CONNECTION_PORT)) { _ = Task.Run(server.RunServerLoop); server.OnMessage += (o, a) => { ++serverMessages; serverMsgEvent.Set(); }; server.OnClientConnected += (o, a) => { serverSideClients.Add(a.ClientConnection); clientConnEvent.Set(); }; using WebSocketConnection client1 = await WebSocketClient.ConnectAsync(TEST_CONNECTION_URI); client1.OnMessage += (o, a) => { ++c1Messages; client1MsgEvent.Set(); }; Assert.IsTrue(clientConnEvent.WaitOne(TEST_TIMEOUT)); using WebSocketConnection client2 = await WebSocketClient.ConnectAsync(TEST_CONNECTION_URI); client2.OnMessage += (o, a) => { ++c2Messages; client2MsgEvent.Set(); }; Assert.IsTrue(clientConnEvent.WaitOne(TEST_TIMEOUT)); using WebSocketConnection client3 = await WebSocketClient.ConnectAsync(TEST_CONNECTION_URI); client3.OnMessage += (o, a) => { ++c3Messages; client3MsgEvent.Set(); }; Assert.IsTrue(clientConnEvent.WaitOne(TEST_TIMEOUT)); await serverSideClients[0].SendAsync(MSG); Assert.IsTrue(client1MsgEvent.WaitOne(TEST_TIMEOUT)); await serverSideClients[1].SendAsync(MSG); Assert.IsTrue(client2MsgEvent.WaitOne(TEST_TIMEOUT)); await serverSideClients[2].SendAsync(MSG); Assert.IsTrue(client3MsgEvent.WaitOne(TEST_TIMEOUT)); await server.SendAsync(MSG); Assert.IsTrue(client1MsgEvent.WaitOne(TEST_TIMEOUT)); Assert.IsTrue(client2MsgEvent.WaitOne(TEST_TIMEOUT)); Assert.IsTrue(client3MsgEvent.WaitOne(TEST_TIMEOUT)); await client1.SendAsync(MSG); Assert.IsTrue(serverMsgEvent.WaitOne(TEST_TIMEOUT)); await client2.SendAsync(MSG); Assert.IsTrue(serverMsgEvent.WaitOne(TEST_TIMEOUT)); await client3.SendAsync(MSG); Assert.IsTrue(serverMsgEvent.WaitOne(TEST_TIMEOUT)); } Assert.AreEqual(3U, serverMessages); Assert.AreEqual(2U, c1Messages); Assert.AreEqual(2U, c2Messages); Assert.AreEqual(2U, c3Messages); }
public async Task Invoke(HttpContext context) { if (ValidateOrigin(context)) { if (context.WebSockets.IsWebSocketRequest) { WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(); if (!context.User.Identity.IsAuthenticated) { // Status Code 1008 PolicyViolation await webSocket.CloseOutputAsync(WebSocketCloseStatus.PolicyViolation, "Please login first", CancellationToken.None); return; } WebSocketConnection webSocketConnection = new WebSocketConnection(webSocket, _options.ReceivePayloadBufferSize); async void OnWebSocketConnectionOnNewConnection(object sender, EventArgs message) { await Task.Delay(150); try { var welcomeMessage = new ApiNotificationResponseModel <HeartbeatModel>(new HeartbeatModel(null)) { Type = ApiNotificationType.Welcome, }; await webSocketConnection.SendAsync(JsonSerializer.Serialize(welcomeMessage, DefaultJsonSerializer.CamelCase), CancellationToken.None); } catch (WebSocketException) { // if the client is closing the socket the wrong way } } webSocketConnection.NewConnection += OnWebSocketConnectionOnNewConnection; _connectionsService.AddConnection(webSocketConnection); await webSocketConnection.ReceiveMessagesUntilCloseAsync(); if (webSocketConnection.CloseStatus.HasValue) { await webSocket.CloseOutputAsync(webSocketConnection.CloseStatus.Value, webSocketConnection.CloseStatusDescription, CancellationToken.None); } _connectionsService.RemoveConnection(webSocketConnection.Id); } else { context.Response.StatusCode = StatusCodes.Status400BadRequest; } } else { context.Response.StatusCode = StatusCodes.Status403Forbidden; } }
private void SendRequestMessage(MESSAGE_TYPE messageType, List <string> value = null) { // value is a parameters separated by $ CommunicationType cmd = new CommunicationType(messageType, "", value); switch (messageType) { case MESSAGE_TYPE.GET_MENU_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ACTIVE_ORDERS_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_COMPLETED_ORDERS_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ACTIVE_DELIVERIES_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_COMPLETED_DELIVERIES_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ALL_CLIENTS_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_ORDER_BYID_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.GET_DELIVERY_BYID_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.CREATE_CLIENT_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.CREATE_DISH_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.CREATE_ORDER_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.COMPLETE_ORDER_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; case MESSAGE_TYPE.COMPLETE_DELIVERY_REQ: socketConnection.SendAsync(Communication.Serializer.SerializeCommunicationType(cmd)); break; } }