Example #1
0
        public static async Task ProcessIncomingMessages(
            this WebSocket webSocket,
            PagingMessageQueue messageQueue,
            Guid connectionId,
            Action <StringMessageReceivedEventArgs> messageBehavior,
            Action <BinaryMessageReceivedEventArgs> binaryBehavior,
            Action <WebSocketReceivedResultEventArgs> closeBehavior,
            Action <string> logInfo,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            //  await Task.Factory.StartNew(async () => {
            byte[] messageBufferBytes         = new byte[1048576];
            ArraySegment <byte> messageBuffer = new ArraySegment <byte>(messageBufferBytes);

            while (!cancellationToken.IsCancellationRequested)
            {
                var msg = await webSocket.ReceiveMessageAsync(messageBuffer, connectionId, cancellationToken).ConfigureAwait(false);

                if (msg.IsDisconnect)
                {
                    logInfo($"Websocket Connection Disconnected Stat:{msg.WebSocketCloseStatus} Desc:{msg.CloseStatDesc}, msg: {msg.ExceptionMessage} ex:{msg.Exception}");
                    closeBehavior(new WebSocketClosedEventArgs(connectionId, msg.WebSocketCloseStatus, msg.CloseStatDesc));
                    break;
                }

                msg.SetMessageHandlers(messageBehavior, binaryBehavior, webSocket);

                messageQueue.Push(msg);
            }
            //  });
        }
Example #2
0
        public async Task ConnectAsync(string url, CancellationToken tok = default(CancellationToken))
        {
            _client = new ClientWebSocket();
            ConfigureOptionsBeforeConnect(_client.Options);

            await _client.ConnectAsync(new Uri(url), tok);

            var messageBehavior = MakeSafe(MessageHandler, "MessageHandler");
            var binaryBehavior  = MakeSafe(BinaryHandler, "BinaryHandler");

            _closeBehavior = MakeSafe(CloseHandler, "CloseHandler");

            _messageQueue = new PagingMessageQueue("WebSocketClient", _logError, _recieveQueueLimitBytes);

            _incomingMessagesTask = Task.Factory.StartNew(async() => await _client.ProcessIncomingMessages(_messageQueue, _clientId, messageBehavior, binaryBehavior, _closeBehavior, _logInfo, _cancellationTokenSource.Token));
        }
Example #3
0
        public Task StartAsync(string listenerPrefix, CancellationToken listeningToken = default(CancellationToken))
        {
            stopListeningThread();

            var listenerThredStarted = new TaskCompletionSource <bool>();

            _cancellationTokenSource = new CancellationTokenSource();
            _webListener             = new WebListener();
            _webListener.Settings.UrlPrefixes.Add(listenerPrefix);
            _webListener.Start();
            _logInfo($"Listener started on {listenerPrefix}.");
            _messageQueue = new PagingMessageQueue("WebSocketServer", _logError, _queueThrottleLimit);

            _listenTask = Task.Run(async() =>
            {
                try
                {
                    if (listeningToken.IsCancellationRequested)
                    {
                        listenerThredStarted.TrySetCanceled();
                    }
                    else
                    {
                        listenerThredStarted.TrySetResult(true);

                        using (_webListener)
                            await listenLoop(_webListener, _cancellationTokenSource.Token);
                    }
                }
                catch (Exception e)
                {
                    _logError("WebSocketServer exception in the listenTask: " + e.ToString());
                }
            });

            return(listenerThredStarted.Task);
        }