private void UnderlyingChannel_OnReceive(object arg1, byte[] data) { _receiveMessageAssembler.Enqueue(data); while (true) { var message = _receiveMessageAssembler.DequeueOrNull(); if (message == null) { return; } OnReceive?.Invoke(this, message); } }
void ReplyData(byte[] data) { var dt = SAEASerialize.Deserialize <DataInfo>(data); OnReceive?.Invoke(dt); var userIDs = _storage.GetChannelUsers(dt.ChannelID); Parallel.ForEach(userIDs, (id) => { BaseReply(id, ProtocalType.Data, dt.Data); }); }
private void Receive(IAsyncResult result) { IPEndPoint endpoint = null; byte[] packet = _client.EndReceive(result, ref endpoint); OnReceive rcv = ReceiveEvent; if (rcv != null) { rcv(endpoint, packet, 0, packet.Length); } _client.BeginReceive(_runner, null); }
private void SocketArgs_Completed(object sender, SocketAsyncEventArgs e) { try { // SocketError err; if (state == SocketState.Closed || state == SocketState.Terminated) { return; } if (e.BytesTransferred == 0) { Close(); return; } //if (receiveNetworkBuffer.Protected) // Console.WriteLine(); //lock (receiveNetworkBuffer.SyncLock) receiveNetworkBuffer.Write(receiveBuffer, 0, (uint)e.BytesTransferred); //Console.WriteLine("TC IN: " + (uint)e.BytesTransferred + " " + DC.ToHex(receiveBuffer, 0, (uint)e.BytesTransferred)); OnReceive?.Invoke(receiveNetworkBuffer); if (state == SocketState.Established) { if (!sock.ReceiveAsync(socketArgs)) { //Console.WriteLine("Sync"); SocketArgs_Completed(sender, e); } } } catch (Exception ex) { if (state != SocketState.Closed && !sock.Connected) { state = SocketState.Terminated; Close(); } Global.Log("TCPSocket", LogType.Error, ex.ToString()); } }
private async Task Receive(Context context) { var stream = context.TcpClient.GetStream(); while (_running) { // First time the client connects, an opening statement of 4 bytes is sent that needs to be ignored if (!context.Initialized) { var openingStatementBuffer = new byte[4]; await stream.ReadAsync(openingStatementBuffer, 0, openingStatementBuffer.Length); context.InitializeClient(); } // Header determines size of message var headerBuffer = new byte[2]; var read = await stream.ReadAsync(headerBuffer, 0, headerBuffer.Length); if (read == 0) { OnDisconnection?.Invoke(context); break; } var messageLength = BitConverter.ToInt16(headerBuffer, 0) - headerBuffer.Length; var messageBuffer = new byte[messageLength]; read = await stream.ReadAsync(messageBuffer, 0, messageLength); Debug.WriteLine("RECEIVED RAW: " + BitConverter.ToString(messageBuffer)); try { IMessage message = MessageSerializer.Deserialize(messageBuffer); Console.WriteLine("Recv message[{0},{1}]: {2}", context.User != null ? context.User.Username : "******", context.User != null ? context.User.UserId : -1, message); OnReceive?.Invoke(context, message); } catch (UnknownMessageTypeException messageTypeEx) { Debug.WriteLine(messageTypeEx.ToString()); } catch (UnknownXFireAttributeTypeException attributeTypeEx) { Debug.WriteLine(attributeTypeEx.ToString()); } } }
private void CallReceive(ClientContainer client, byte[] value) { try { OnReceive?.Invoke(this, new ReceivedArgs(client.ClientId, client.RemoteEndPoint, value)); } catch (Exception ex) { if (_showFail) { Debug.Fail(ex.Message, ex.StackTrace); } } }
public override async Task ReceiveAsync() { try { byte[] message = await request.Content.ReadAsByteArrayAsync(); OnReceive?.Invoke(this, new ChannelReceivedEventArgs(Id, message)); //OnObserve?.Invoke(this, new ChannelObserverEventArgs(resource, contentType, message)); } catch (Exception ex) { OnError.Invoke(this, new ChannelErrorEventArgs(Id, ex)); } }
private void execute() { while (!terminated) { while (true) { Thread.Sleep(25); if (!IsConnected && !AutoReconnect) { break; } if (!IsConnected) { if (!Connect()) { Thread.Sleep(2000); continue; } } try { if (DateTime.Now - lastPing > TimeSpan.FromSeconds(3)) { lastPing = DateTime.Now; writer.WriteLine("ping"); writer.Flush(); } } catch { Disconnect(); continue; } try { string json = reader.ReadLine(); if (json == "ping") { continue; } OnReceive?.Invoke(this, BasicData.FromJson(json)); } catch { } } } }
public async Task StartAsync(CancellationToken cancellationToken = default) { var clientSocket = await clientWebSocket.ConnectAsync(webSocketUri, cancellationToken); if (clientSocket.State != WebSocketState.Open) { return; } var arraySegment = new ArraySegment <byte>(buffer); var graphQlSubscriptionRequest = new GraphQLSubscriptionRequest { Id = "1", Type = "start", Payload = graphQLRequest }; var jsonRequest = JsonConvert.SerializeObject(graphQlSubscriptionRequest); var payload = new ArraySegment <byte>(Encoding.UTF8.GetBytes(jsonRequest)); await clientSocket.SendAsync( payload, messageType : WebSocketMessageType.Text, endOfMessage : true, cancellationToken : cancellationToken); try { while (clientSocket.State == WebSocketState.Open) { cancellationToken.ThrowIfCancellationRequested(); var webSocketReceiveResult = await clientSocket.ReceiveAsync(arraySegment, cancellationToken); var response = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count); var subscriptionResponse = JsonConvert.DeserializeObject <GraphQLSubscriptionResponse>(response); if (subscriptionResponse != null) { LastResponse = subscriptionResponse.Payload; OnReceive?.Invoke(subscriptionResponse.Payload); } } } catch (OperationCanceledException) { } }
private void ModuleReceived(string resource, string contentType, byte[] message) { //received a message from subscription try { MbapHeader header = MbapHeader.Decode(message); diag?.PublishInput(header).GetAwaiter(); logger?.LogDebug("Diagnostics sent input."); OnReceive?.Invoke(this, new ChannelReceivedEventArgs(channel.Id, message)); } catch (Exception ex) { logger?.LogError(ex, "Unable to decode MBAP header module channel input."); } }
void HandleReceiveQueue() { byte[] msg; _receiveQueue.TryDequeue(out msg); if (msg == null) { return; } if (!IsConnected) { return; } _bytesReceived += msg.Length; OnReceive?.Invoke(this, msg); }
public void Connect() { _connection = Factory.CreateConnection(); _channel = _connection.CreateModel(); _channel.QueueDeclare("chat", false, false, false, null); var consumer = new EventingBasicConsumer(_channel); consumer.Received += (model, ea) => { OnReceive?.Invoke(this, ea.Body); }; _channel.BasicConsume("chat", true, consumer); }
protected bool InitKcpClient(IPEndPoint ep) { kcpClient = KcpHostClient.Create(ep); kcpClient.OnReceive += (kcp, buffer) => { OnReceive?.Invoke(this, buffer); }; kcpClient.OnClose += (kcp) => { OnClose?.Invoke(this); }; kcpClient.OnException += (ch, ex) => { OnException?.Invoke(this, ex); }; Log.Info(string.Format("init_kcp_client_localaddr@{0}", kcpClient.LocalAddress)); return(true); }
private async Task startReceive() { var messages = await _queryHandler.Handle(new ReceiveMessageQuery()); if (OnReceive != null) { foreach (var message in messages) { OnReceive.Invoke(this, new MessageEventArgs { Message = message.Body }); await _deleteCommandHandler.Handle(new DeleteMessageCommand(message.ReceiptHandle)); } } }
public virtual void SetOnReceiveCallback(OnReceive recv) { if (recv != null) { OnReceiveCallback = new OnReceive(recv); SDK_OnReceiveCallback = new HPSocketSdk.OnReceive(SDK_OnReceive); } else { OnReceiveCallback = null; SDK_OnReceiveCallback = null; } HPSocketSdk.HP_Set_FN_Client_OnReceive(pListener, SDK_OnReceiveCallback); }
public static void CallReceive(string message) { if (latencyOverride > 0 && !IsHost) { CallDelayMain(() => { OnReceive?.Invoke(message); var pkt = StringToPacket(message); if (pkt == null) { return; } if (tcpDistributors.ContainsKey(pkt.t)) { tcpDistributors[pkt.t]?.Invoke(pkt); } if (pkt.IsSubclassOf(typeof(Pktid))) { var pktTid = pkt as Pktid; if (tcpIdDistributors.ContainsKey(pktTid.id)) { tcpIdDistributors[pktTid.id]?.Invoke(pktTid); } } }); } else { OnReceive?.Invoke(message); var pkt = StringToPacket(message); if (pkt == null) { return; } if (tcpDistributors.ContainsKey(pkt.t)) { tcpDistributors[pkt.t]?.Invoke(pkt); } if (pkt.IsSubclassOf(typeof(Pktid))) { var pktTid = pkt as Pktid; if (tcpIdDistributors.ContainsKey(pktTid.id)) { tcpIdDistributors[pktTid.id]?.Invoke(pktTid); } } } }
public override async Task StartRecv() { while (true) { if (!netStream.CanRead) { return; } try { var count = await netStream.ReadAsync(RecvParser.Buffer.Last, RecvParser.Buffer.LastOffset, RecvParser.Buffer.LastCount); if (count <= 0) { throw new SocketException((int)SocketError.SocketError); } RecvParser.Buffer.UpdateWrite(count); recvTime = DateTime.Now; while (true) { var packet = RecvParser.ReadBuffer(); if (!packet.IsSuccess) { break; } if (!packet.IsHeartbeat) { if (packet.IsRpc) { if (rpcActions.TryRemove(packet.RpcId, out Action <Packet> action)) { action(packet); } } else { OnReceive?.Invoke(packet); } } } } catch { OnError?.Invoke(this, SocketError.SocketError); } } }
private void TcpClients_OnReceive(byte[] data, int offset, int length) { byte[] r = new byte[length]; Buffer.BlockCopy(data, offset, r, 0, length); queue.AddRange(r); bool isContinueGetData = false; while (queue.Count > 8 && !isContinueGetData) { byte[] datas = Read(out isContinueGetData); if (datas != null && datas.Length > 0) { OnReceive?.Invoke(datas); } } }
public void AsyncReceive(byte [] buffer, OnReceive onReceive) { try { // Create the state object. StateObject state = new StateObject(); state.workSocket = sock; state.buffer = buffer; state.onReceive = onReceive; // Begin receiving the data from the remote device. sock.BeginReceive(state.buffer, 0, buffer.Length, 0, new AsyncCallback(ReceiveCallback), state); } catch (Exception e) { LogUtil.Error("ClientSocket.AsyncReceive: " + e.ToString()); } }
/// <summary> /// 连接到MQTT /// </summary> /// <param name="host"></param> /// <param name="port"></param> /// <param name="username"></param> /// <param name="password"></param> /// <returns></returns> public bool Connect() { try { if (mqttClient == null) { mqttClient = new MqttFactory().CreateMqttClient(); mqttClient.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(arg => Task.Run(() => { try { OnDisconnected?.Invoke(arg.Exception); } catch (Exception ex) { OnException?.Invoke(ex); } })); mqttClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(obj => { try { OnReceive?.Invoke(obj.ApplicationMessage.Topic, obj.ApplicationMessage.Payload); } catch (Exception ex) { OnException?.Invoke(ex); } }); } if (!mqttClient.IsConnected) { options = new MqttClientOptionsBuilder() //实例化一个MqttClientOptionsBulider .WithTcpServer(HostName, Port) .WithCredentials(UserName, Password) .WithClientId(Guid.NewGuid().ToString()) .Build(); var result = mqttClient.ConnectAsync(options).Result; } return(mqttClient.IsConnected); } catch (Exception ex) { OnException?.Invoke(ex); return(false); } }
private void execute() { while (!terminated) { try { while (true) { if (!IsConnected) { throw new SocketException(); } try { if (DateTime.Now - lastPing > TimeSpan.FromSeconds(3)) { lastPing = DateTime.Now; writer.WriteLine("ping"); writer.Flush(); } } catch { throw new SocketException(); } try { string json = reader.ReadLine(); if (json == "ping") { continue; } OnReceive?.Invoke(this, BasicData.FromJson(json)); } catch { } Thread.Sleep(10); } } catch (SocketException) { terminated = true; OnDisconnect?.Invoke(this, EventArgs.Empty); } catch { } } }
/// <summary> /// 接收回调 /// </summary> /// <param name="e">操作对象</param> private void ProcessReceive(SocketAsyncEventArgs e) { if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success) { OnReceive?.Invoke(e.RemoteEndPoint, e.Buffer, e.Offset, e.BytesTransferred); } if (listenSocket == null) { return; } if (e.SocketError != SocketError.Success && e.SocketError != SocketError.ConnectionReset) { return; } StartReceive(e); }
private void HandleReceiveData(string clientId) { while (clients.ContainsKey(clientId)) { if (clients[clientId].Poll(1, SelectMode.SelectRead) && clients[clientId].Available == 0) { Disconnect(clientId); OnDisconnect?.Invoke(this, clientId); return; } if (clients[clientId].Available > 0) { OnReceive?.Invoke(this, clientId, clients[clientId].Available); } Thread.Sleep(50); } }
private async Task ReceiveAsync() { try { while (Volatile.Read(ref _refIsUsable) && _socket.State == WebSocketState.Open && !_tokenSource.IsCancellationRequested) { var buffer = new byte[_lavaConfig.BufferSize]; var result = await _socket.ReceiveAsync(buffer, _tokenSource.Token) .ConfigureAwait(false); switch (result.MessageType) { case WebSocketMessageType.Close: Volatile.Write(ref _refIsUsable, false); OnDisconnected?.Invoke("Server closed the connection!"); await RetryConnectionAsync() .ConfigureAwait(false); break; case WebSocketMessageType.Text: if (!result.EndOfMessage) { continue; } var startLength = buffer.Length - 1; while (buffer[startLength] == 0) { --startLength; } var cleaned = new byte[startLength + 1]; Array.Copy(buffer, cleaned, startLength + 1); OnReceive?.Invoke(cleaned); break; } } } catch (Exception ex) { OnDisconnected?.Invoke(ex.Message); await ConnectAsync() .ConfigureAwait(false); } }
public async void StartReceive() { isEnable = true; while (isEnable) { try { string res = await Receive(); OnReceive?.Invoke(res); } catch { OnError?.Invoke(Ws.State.ToString()); ChkConnection(); return; } } }
void Receive(MessageWebSocket FromSocket, MessageWebSocketMessageReceivedEventArgs InputMessage) { try { using (var reader = InputMessage.GetDataReader()) { var messageLength = InputMessage.GetDataReader().UnconsumedBufferLength; byte[] receivedMessage = new byte[messageLength]; reader.UnicodeEncoding = UnicodeEncoding.Utf8; reader.ReadBytes(receivedMessage); OnReceive.Invoke(this, new MessageEventArgs(receivedMessage)); } } catch { return; } }
private void Client_OnMessageReceive(object sender, Message e) { var msg = JsonRpc.Message.Parse(e.Data); TaskCompletionSource <IMessage> promise; if (msg.IsResponse()) { if (requestPending.TryRemove(msg.Id, out promise)) { promise.SetResult(msg); } } else { OnReceive?.Invoke(this, msg); } }
private void MqttOnMessageReceive(object sender, MqttMsgPublishEventArgs e) { var msg = Message.Parse(e.Message); TaskCompletionSource <IMessage> promise; if (msg.IsResponse()) { if (requestPending.TryRemove(msg.Id, out promise)) { promise.SetResult(msg); } } else { OnReceive?.Invoke(this, msg); } }
private void _udpClient_OnReceive(byte[] data) { _baseUnpacker.Unpack(data, (p) => { var protocalType = (ProtocalType)p.Type; switch (protocalType) { case ProtocalType.Ping: break; case ProtocalType.Pong: break; case ProtocalType.Invite: var ii = SerializeHelper.Deserialize <InvitedInfo>(Encoding.UTF8.GetString(p.Content)); OnInvited?.Invoke(ii); Channel = ii.ChannelID; break; case ProtocalType.Agree: var ai = SerializeHelper.Deserialize <AgreeInfo>(Encoding.UTF8.GetString(p.Content)); OnAgree?.Invoke(ai); Channel = ai.ChannelID; break; case ProtocalType.Disagree: OnDisagree?.Invoke(Encoding.UTF8.GetString(p.Content)); break; case ProtocalType.Join: var ji = SerializeHelper.Deserialize <JoinInfo>(Encoding.UTF8.GetString(p.Content)); OnJoin?.Invoke(ji); Channel = ji.ChannelID; break; case ProtocalType.Data: OnReceive?.Invoke(p.Content); break; } }, null, null); }
public void Complete() { if (Conn != null) { Conn.OnReceive -= Conn_OnReceive; OnComplete?.Invoke(); foreach (var handler in OnReceive?.GetInvocationList()) { OnReceive -= (MWEventHandler <Message>)handler; } foreach (var handler in OnComplete?.GetInvocationList()) { OnComplete -= (MWEventHandler)handler; } InternalComplete(); } }
public static extern void HP_Set_FN_Server_OnReceive(IntPtr pListener, OnReceive fn);