示例#1
0
        private async Task GetMarket(HttpContext context, WebSocket socket)
        {
            string userName = context.Request.Query["u"];

            Console.WriteLine("连接人:" + userName);

            _webSocketHandler.OnConnected(socket, userName);
            try
            {
                while (socket.State == WebSocketState.Open)
                {
                    await _webSocketHandler.ReceiveEntity <MessageEntity>(socket, async (result, messageEntity) =>
                    {
                        if (result.MessageType == WebSocketMessageType.Close)
                        {
                            await _webSocketHandler.OnDisconnected(socket);
                            return;
                        }

                        var customSocket = _webSocketHandler.GetCustomWebSocket(userName);
                        if (customSocket == null)
                        {
                            return;
                        }
                        if (!customSocket.IsSubscribe)
                        {
                            _timer = new Timer(q =>
                            {
                                foreach (var stock in _stocks.Values)
                                {
                                    TryUpdateStockPrice(stock);

                                    _webSocketHandler.SendMessageAsync(socket, stock).ConfigureAwait(false);
                                }
                            }, null, _updateInterval, _updateInterval);

                            customSocket.IsSubscribe = true;
                            _webSocketHandler.UpdateCustomWebSocket(customSocket);
                        }
                    });
                }
                if (Enum.IsDefined(typeof(WebSocketCloseStatus), socket.CloseStatus))
                {
                    await _webSocketHandler.OnDisconnected(socket);
                }
                await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", default(CancellationToken));

                socket.Dispose();
            }
            catch (Exception ex)
            {
            }
        }
示例#2
0
        public async Task Invoke(HttpContext context)
        {
            if (!context.WebSockets.IsWebSocketRequest)
            {
                // Not a web socket request
                await _next.Invoke(context);

                return;
            }

            var socket = await context.WebSockets.AcceptWebSocketAsync();

            await _webSocketHandler.OnConnected(socket);

            await Receive(socket, async (result, buffer) =>
            {
                if (result.MessageType == WebSocketMessageType.Text)
                {
                    await _webSocketHandler.ReceiveAsync(socket, result, buffer);
                }
                else if (result.MessageType == WebSocketMessageType.Close)
                {
                    await _webSocketHandler.OnDisconnected(socket);
                }
            });

            //TODO - investigate the Kestrel exception thrown when this is the last middleware
            await _next.Invoke(context);
        }
示例#3
0
        public async Task Invoke(HttpContext context)
        {
            if (!context.WebSockets.IsWebSocketRequest)
            {
                return;
            }

            var socket = await context.WebSockets.AcceptWebSocketAsync();

            await _webSocketHandler.OnConnected(socket);

            await Receive(socket, async (result, buffer) =>
            {
                if (result.MessageType == WebSocketMessageType.Text)
                {
                    await _webSocketHandler.ReceiveAsync(socket, result, buffer);
                }

                else if (result.MessageType == WebSocketMessageType.Close)
                {
                    await _webSocketHandler.OnDisconnected(socket);
                }
            });

            await _next.Invoke(context);
        }
示例#4
0
        public async Task Get()
        {
            var context         = ControllerContext.HttpContext;
            var isSocketRequest = context.WebSockets.IsWebSocketRequest;

            if (!isSocketRequest)
            {
                context.Response.StatusCode = 401;
            }
            else
            {
                WebSocket socket = await context.WebSockets.AcceptWebSocketAsync();

                _webSocketHandler.OnConnected(socket);
                var buffer = new byte[_BUFFER_SIZE];
                WebSocketReceiveResult result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer),
                                                                          CancellationToken.None);

                while (!result.CloseStatus.HasValue)
                {
                    await _webSocketHandler.OnMessage(socket, result, buffer);

                    result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
                }
                _webSocketHandler.OnDisconnected(socket);
            }
        }
示例#5
0
        public static async Task TakeWebSocketRequest(WebSocketHandler webSocketHandler, HttpContext context, string name)
        {
            if (!context.WebSockets.IsWebSocketRequest)
            {
                return;
            }

            var socket = await context.WebSockets.AcceptWebSocketAsync();

            await webSocketHandler.OnConnected(socket, name.GetWebSocketName());

            await Receive(socket, async (result, buffer) =>
            {
                if (result.MessageType == WebSocketMessageType.Text)
                {
                    await webSocketHandler.ReceiveAsync(socket, result, buffer);
                    return;
                }

                else if (result.MessageType == WebSocketMessageType.Close)
                {
                    await webSocketHandler.OnDisconnected(socket);
                    return;
                }
            });
        }
示例#6
0
        //private async Task Echo(HttpContext context, WebSocket webSocket)
        //{
        //    var buffer = new ArraySegment<byte>(new byte[1024 * 4]) ;
        //    //连接
        //    WebSocketReceiveResult result = await webSocket.ReceiveAsync(buffer, CancellationToken.None);

        //    while (webSocket.State == WebSocketState.Open)
        //    {
        //        //返回的消息
        //        var resultMsg = Encoding.ASCII.GetString(buffer.Array);

        //        var abuffer = Encoding.ASCII.GetBytes(DateTime.Now.ToLongTimeString());
        //        //发给客户端
        //        await webSocket.SendAsync(new ArraySegment<byte>(abuffer, 0, abuffer.Length), result.MessageType, result.EndOfMessage, CancellationToken.None);

        //        result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer.Array), CancellationToken.None);
        //    }
        //    //关闭连接
        //    await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
        //}

        private async Task RedisSubscribe(HttpContext context, WebSocket socket)
        {
            string userName = context.Request.Query["u"];

            _webSocketHandler.OnConnected(socket, userName);
            try
            {
                while (socket.State == WebSocketState.Open)
                {
                    await _webSocketHandler.ReceiveEntity <MessageEntity>(socket, async (result, messageEntity) =>
                    {
                        if (result.MessageType == WebSocketMessageType.Close)
                        {
                            await _webSocketHandler.OnDisconnected(socket);
                            return;
                        }

                        switch (messageEntity.Type)
                        {
                        case MessageType.Quote:
                            {
                                var customSocket = _webSocketHandler.GetCustomWebSocket(messageEntity.Sender);
                                if (customSocket == null)
                                {
                                    break;
                                }
                                if (!customSocket.IsSubscribe)
                                {
                                    //$"{customSocket.UserName}.{subscribeQuote}"
                                    await _redisSubscribeHandler.SubscribeAsync(subscribeQuote, (channel, message) =>
                                    {
                                        var msgEntity = new MessageEntity
                                        {
                                            Message  = message,
                                            Type     = MessageType.Quote,
                                            Receiver = userName,
                                            Sender   = "system"
                                        };
                                        _webSocketHandler.SendMessageAsync(socket, msgEntity).ConfigureAwait(false);
                                    });
                                    customSocket.IsSubscribe = true;
                                    _webSocketHandler.UpdateCustomWebSocket(customSocket);
                                }
                                break;
                            }

                        case MessageType.KLine:

                            break;
                        }
                    });
                }
                if (Enum.IsDefined(typeof(WebSocketCloseStatus), socket.CloseStatus))
                {
                    //userName = _webSocketHandler.GetId(socket);
                    //await _redisSubscribeHandler.Unsubscribe($"{subscribeQuote}");
                    await _webSocketHandler.OnDisconnected(socket);
                }
                await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", default(CancellationToken));

                socket.Dispose();
            }
            catch (Exception ex)
            {
                // _logger.LogError(ex.StackTrace);
            }
        }
示例#7
0
        public async Task Invoke(HttpContext context)
        {
            if (!(context.WebSockets.IsWebSocketRequest || context.Request.Path == routePostfix))
            {
                await _next.Invoke(context);
            }
            string uuId = context.Request.Query["u"];

            if (string.IsNullOrEmpty(uuId))
            {
                await _next.Invoke(context);

                context.Response.StatusCode = 401;
                return;
            }
            string ip    = string.Empty;
            var    count = _webSocketHandler.GetCount();

            _logger.LogInformation($"连接uuId:{uuId},ip:{ip},count:{count}");
            if (count >= MaxConnection)
            {
                await _next.Invoke(context);

                context.Response.StatusCode = 501;
                return;
            }
            //创建webSocket连接
            var socket = await context.WebSockets.AcceptWebSocketAsync();

            _webSocketHandler.OnConnected(socket, uuId, string.Empty, ip);
            try
            {
                while (socket.State == WebSocketState.Open)//socket.State == WebSocketState.Open
                {
                    await _webSocketHandler.ReceiveEntity <MessageEntity>(socket, async (result, messageEntity) =>
                    {
                        if (result.MessageType == WebSocketMessageType.Close)
                        {
                            await _webSocketHandler.OnDisconnected(socket);
                            await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", default(CancellationToken));
                            return;
                        }
                        var customSocket = _webSocketHandler.GetCustomWebSocket(socket);
                        if (customSocket == null)
                        {
                            await _webSocketHandler.OnDisconnected(socket);
                            await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", default(CancellationToken));
                            _logger.LogInformation($"未找到相应连接:{JsonConvert.SerializeObject(messageEntity)},State={socket?.State}");
                            return;
                        }
                        var code   = (MessageType)messageEntity.T;
                        var method = code.ToString();
                        if (this.GetType().GetMethods().Where(p => p.Name == method).FirstOrDefault() == null)
                        {
                            messageEntity.D = "指令错误";
                            messageEntity.T = (int)MessageType.Fail;
                            await _webSocketHandler.SendMessageAsync(socket, messageEntity);
                            return;
                        }
                        var pars = new object[3];
                        pars[0]  = socket;
                        pars[1]  = customSocket;
                        pars[2]  = messageEntity;
                        InvokeInstruction(code.ToString(), pars);
                        var dynamic = this;
                    });
                }
            }
            catch (WebSocketException ex) when(ex.WebSocketErrorCode == WebSocketError.ConnectionClosedPrematurely)
            {
                await _webSocketHandler.OnDisconnected(socket);
            }
            catch (OperationCanceledException)
            {
                // Ignore aborts, don't treat them like transport errors
            }
            catch (Exception ex)
            {
                var customId = _webSocketHandler.GetId(socket);
                _logger.LogError(ex, $"DSB(-2)系统接收({customId}:{socket.State})消息出现异常:{ex.StackTrace}");
            }
        }