async void MessageReceived(byte[] buffer, IPEndPoint endpoint) { await DhtEngine.MainLoop; // Don't handle new messages if we have already stopped the dht engine. if (Listener.Status == ListenerStatus.NotListening) { return; } // I should check the IP address matches as well as the transaction id // FIXME: This should throw an exception if the message doesn't exist, we need to handle this // and return an error message (if that's what the spec allows) try { if (DhtMessageFactory.TryDecodeMessage((BEncodedDictionary)BEncodedValue.Decode(buffer, false), out DhtMessage message)) { Monitor.ReceiveMonitor.AddDelta(buffer.Length); ReceiveQueue.Enqueue(new KeyValuePair <IPEndPoint, DhtMessage> (endpoint, message)); } } catch (MessageException) { // Caused by bad transaction id usually - ignore } catch (Exception) { //throw new Exception("IP:" + endpoint.Address.ToString() + "bad transaction:" + e.Message); } }
protected virtual void OnReceive(TCPClient client, int numberOfBytesReceived) { if (numberOfBytesReceived <= 0) { this.Status = SocketStatus.SOCKET_STATUS_NO_CONNECT; this.OnDisconnect(client); } else { #if DEBUG //CrestronConsole.PrintLine("{0}.OnReceive() numberOfBytesReceived = {1}, Enqueuing...", this.GetType().Name, numberOfBytesReceived); #endif for (int b = 0; b < numberOfBytesReceived; b++) { ReceiveQueue.Enqueue(client.IncomingDataBuffer[b]); if (_receiveThread == null || _receiveThread.ThreadState == Thread.eThreadStates.ThreadFinished) { _receiveThread = new Thread(ReceiveThreadProcess, null, Thread.eThreadStartOptions.CreateSuspended); _receiveThread.Priority = Thread.eThreadPriority.UberPriority; _receiveThread.Name = string.Format("{0} Rx Handler", this.GetType().Name); _receiveThread.Start(); } } if (client.ClientStatus == SocketStatus.SOCKET_STATUS_CONNECTED) { client.ReceiveDataAsync(OnReceive); } } }
private void PortThread() { while (true) { if (_port.IsOpen) { try { var receive = _port.ReadLine().Replace("\r", "").Replace("\n", ""); if (receive == _heartbeatPhrase) { LastHeartbeatAt = DateTime.Now; } else { ReceiveQueue.Enqueue(receive); } } catch (Exception e) { Debug.WriteLine("PortThread exception: {0}", e); Thread.Sleep(1); } } else { Thread.Sleep(1); } } }
public virtual void MessageReceived(I2NPMessage msg, int recvdatasize) { #if LOG_ALL_TUNNEL_TRANSFER Logging.LogDebug($"{this}: MessageReceived {msg.Message}"); #endif Bandwidth.DataReceived(recvdatasize); //Logging.LogDebug( $"{this}: MessageReceived {msg.MessageType} TDM len {recvsize}" ); ReceiveQueue.Enqueue(msg); }
private void M_SocketManager_ReceiveClientData(Net.AsyncUserToken token, byte[] buff) { if (buff.Length > 0 && buff[0] == 0x5a) { ReceiveQueue.Enqueue(new WHQueueModel(buff, token.IPAddress.ToString())); string vOutInfo = string.Format("电源收到一组数据,IP地址({0}):{1}", token.IPAddress.ToString(), BitConverter.ToString(buff)); Console.WriteLine(vOutInfo); LogHelper.WriteLog_Debug(typeof(PowerControl), vOutInfo); } }
public void EnqueueTest1() { ReceiveQueue target = new ReceiveQueue(); // TODO: 初始化为适当的值 IntPtr byteBuffer = new IntPtr(); // TODO: 初始化为适当的值 long iOffset = 0; // TODO: 初始化为适当的值 long iSize = 0; // TODO: 初始化为适当的值 target.Enqueue(byteBuffer, iOffset, iSize); Assert.Inconclusive("无法验证不返回值的方法。"); }
/// <summary> /// Receive from one of the contained streams /// </summary> /// <param name="ct"></param> /// <returns></returns> public async Task ReceiveAsync(CancellationToken ct) { if (!Links.Any()) { throw new SocketException(SocketError.Closed); } // Fill receive queue from any of the link's receive queue. If queue is empty // replenish it from all streams... Message message; while (true) { foreach (var link in Links) { while (link.ReceiveQueue.TryDequeue(out message)) { if (message.TypeId == MessageContent.Close) { // Remote side closed, close link Links.Remove(link); try { await link.CloseAsync(CancellationToken.None).ConfigureAwait(false); } catch { } if (!Links.Any()) { throw new SocketException("Remote side closed", null, SocketError.Closed); } } else { ReceiveQueue.Enqueue(message); } } } if (ReceiveQueue.Any()) { return; } else { try { var tasks = Links.Select(i => i.ReceiveAsync(ct)); await Task.WhenAny(tasks).ConfigureAwait(false); } catch (AggregateException ae) { throw new SocketException("Receive await failed", ae, ae.GetSocketError()); } } } }
/// <summary> /// Process new GameMessage from MessageController /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected void OnMessageControllerNewMessageAvailable(object sender, GameMessageEventArgs e) { if (e.Message is LoginModeMessage) { HandleLoginModeMessage((LoginModeMessage)e.Message); } else if (e.Message is GameModeMessage) { HandleGameModeMessage((GameModeMessage)e.Message); } // Add the message to the received Message queue ReceiveQueue.Enqueue(e.Message); }
public void BinaryListenTask( ) { try { byte currentSequence = 0; while (IsRunning) { if (UnderlyingStream.ReadByte( ) == DatagramHeaderInt) { byte sequence = ( byte )UnderlyingStream.ReadByte( ); if (sequence == currentSequence) { currentSequence++; } else { //Todo:??? } BinaryDatagramType type = ( BinaryDatagramType )( byte )UnderlyingStream.ReadByte( ); //todo:if not throw byte crc = ( byte )UnderlyingStream.ReadByte( ); byte length = ( byte )UnderlyingStream.ReadByte( ); byte [] data = new byte[length]; UnderlyingStream.Read(data, 0, length); if (data.CaluCrc8( ) == crc) { if (Datagram.Parse(type, data) is ReceiveDatagram datagram) { ReceiveQueue.Enqueue(datagram); } } else { //todo:Warning? } } } } catch (ThreadAbortException) { } }
/// <summary> /// Sync Receive producer loop /// </summary> /// <param name="stream"></param> /// <param name="ct"></param> private void ReceiveProducer(CancellationToken ct) { Message message; while (true) { try { TaskCompletionSource <bool> tcs = null; if (_consumerQueue.TryTake(out tcs, -1, ct)) { if (!tcs.Task.IsCanceled) { try { message = _codec.ReadAsync <Message>(ct).Result; ReceiveQueue.Enqueue(message); if (message.TypeId == MessageContent.Close) { // Remote side closed, close the stream _open.Cancel(); break; } } catch (Exception e) { ProxyEventSource.Log.StreamException( this, _codec.Stream, e); // Exit break; } finally { // Caller will retry if the queue is empty tcs.TrySetResult(true); } } } } catch (OperationCanceledException) { // Stream closing break; } if (_streaming.IsCancellationRequested || _open.IsCancellationRequested || _consumerQueue.IsAddingCompleted) { break; } } }
/// <summary> /// Process new GameMessage from MessageController /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected void OnMessageControllerNewMessageAvailable(object sender, GameMessageEventArgs e) { // Internally process some of the messages that are linked to the connection switch (messageController.Mode) { case ProtocolMode.Login: HandleLoginModeMessage(e.Message); break; case ProtocolMode.Game: HandleGameModeMessage(e.Message); break; } // Add the message to the received Message queue ReceiveQueue.Enqueue(e.Message); }
// the thread function void ReceiveThreadFunction(string ip, int port) { // absolutely must wrap with try/catch, otherwise thread // exceptions are silent try { // connect (blocking) client.Connect(ip, port); _connecting = false; // start send thread only after connected _sendThread = new Thread(() => { SendLoop(0, client, sendQueue, sendPending); }); _sendThread.IsBackground = true; _sendThread.Start(); // run the receive loop ReceiveLoop(0, client, ReceiveQueue, MaxMessageSize); } catch (SocketException exception) { // this happens if (for example) the ip address is correct // but there is no server running on that ip/port // add 'Disconnected' event to message queue so that the caller // knows that the Connect failed. otherwise they will never know ReceiveQueue.Enqueue(new Packet(0, PacketType.Disconnection, null)); throw new Exception("Client Recv: failed to connect to ip=" + ip + " port=" + port + " reason=" + exception); } catch (Exception exception) { // something went wrong. probably important. throw new Exception("Client Recv Exception: " + exception); } // sendthread might be waiting on ManualResetEvent, // so let's make sure to end it if the connection // closed. // otherwise the send thread would only end if it's // actually sending data while the connection is // closed. _sendThread?.Interrupt(); // Connect might have failed. thread might have been closed. // let's reset connecting state no matter what. _connecting = false; // if we got here then we are done. ReceiveLoop cleans up already, // but we may never get there if connect fails. so let's clean up // here too. client.Close(); }
private async void RunReceive() { Debug.Log("WebSocket Message Receiver looping."); string result; while (true) { result = await Receive(); if (result != null && result.Length > 0) { ReceiveQueue.Enqueue(result); } else { Task.Delay(50).Wait(); } } }
public void XmlListenTask( ) { try { StreamReader reader = new StreamReader(UnderlyingStream); while (IsRunning) { string datagramString = reader.ReadLine( ); XElement element = XElement.Parse(datagramString); if (Datagram.Parse(element) is ReceiveDatagram datagram) { ReceiveQueue.Enqueue(datagram); } } } catch (ThreadAbortException) { } }
async void MessageReceived(byte[] buffer, IPEndPoint endpoint) { await DhtEngine.MainLoop; // I should check the IP address matches as well as the transaction id // FIXME: This should throw an exception if the message doesn't exist, we need to handle this // and return an error message (if that's what the spec allows) try { DhtMessage message; if (DhtMessageFactory.TryDecodeMessage((BEncodedDictionary)BEncodedValue.Decode(buffer, 0, buffer.Length, false), out message)) { ReceiveQueue.Enqueue(new KeyValuePair <IPEndPoint, DhtMessage>(endpoint, message)); } } catch (MessageException) { // Caused by bad transaction id usually - ignore } catch (Exception) { //throw new Exception("IP:" + endpoint.Address.ToString() + "bad transaction:" + e.Message); } }
/// <summary> /// Receive from one of the contained streams /// </summary> /// <param name="ct"></param> /// <returns></returns> public async Task ReceiveAsync(CancellationToken ct) { if (!Links.Any()) { throw new SocketException(SocketError.Closed); } // Fill receive queue from any of the link's receive queue. If queue is empty // replenish it from all streams... while (true) { foreach (var link in Links) { Message message; var queue = link.ReceiveQueue; if (queue == null) { Links.Remove(link); } else { while (queue.TryDequeue(out message)) { if (message.TypeId == MessageContent.Close) { // Remote side closed, close link Links.Remove(link); try { await link.CloseAsync(ct).ConfigureAwait(false); } catch { } } else { ReceiveQueue.Enqueue(message); } } } if (!Links.Any()) { throw new SocketException("Remote side closed", null, SocketError.Closed); } } if (ReceiveQueue.Any()) { return; } else { try { var tasks = Links.Select(i => i.ReceiveAsync(ct)); var selected = await Task.WhenAny(tasks).ConfigureAwait(false); await selected.ConfigureAwait(false); } catch (OperationCanceledException) { throw; } catch (Exception e) { ct.ThrowIfCancellationRequested(); throw new SocketException("Receive await failed", e, e.GetSocketError()); } } } }