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);
