protected override void AcceptCallback(IAsyncResult ar)
{
// Get the socket that handles the client request.
Socket listener = (Socket)ar.AsyncState;
if (listener != null)
{
Socket handler = listener.EndAccept(ar);
Log.Trace("Connection accepted");
// Create the state object.
Log.Trace("Waiting for Hello packet...");
// FIXME: Add error handling when client doesn't send a hello packet
handler.Receive(_buffer);
TPacket receivedPacket = ISerializablePacket.FromBytes <TPacket>(_buffer);
Log.Debug($"Received: {receivedPacket}");
Log.Trace("Adding Connection");
string portAlias = receivedPacket.GetKey();
ConnectionRegisteredEvent?.Invoke((portAlias, _clientWorkerFactory.GetClientWorker(portAlias, handler)));
listener.BeginAccept(AcceptCallback, listener);
}
else
{
Log.Fatal("listener is null in AcceptCallback");
}
}
protected override void AcceptCallback(IAsyncResult ar)
{
// Get the socket that handles the client request.
Socket listener = (Socket)ar.AsyncState;
if (listener != null)
{
Socket handler = listener.EndAccept(ar);
Log.Trace("Connection accepted");
Log.Trace("Waiting for a packet...");
handler.Receive(_buffer);
TRequestPacket receivedRequestPacket = ISerializablePacket.FromBytes <TRequestPacket>(_buffer);
Log.Trace($"Received: {receivedRequestPacket}");
TResponsePacket responsePacket = OnRequestReceivedEvent(receivedRequestPacket);
handler.Send(responsePacket.ToBytes());
handler.Shutdown(SocketShutdown.Both);
handler.Close();
listener.BeginAccept(AcceptCallback, listener);
}
else
{
Log.Fatal("listener is null in AcceptCallback");
}
}
protected override void ReceiveCallback(IAsyncResult ar)
{
try
{
byte[] buffer = (byte[])ar.AsyncState;
int bytesRead = ClientSocket.EndReceive(ar);
if (bytesRead > 0)
{
TPacket packet = ISerializablePacket.FromBytes <TPacket>(buffer);
Log.Debug($"Received: {packet}");
OnMessageReceivedEvent(packet);
}
}
catch (MessagePackSerializationException e)
{
Log.Warn(e, $"Could not deserialize MessagePack ({typeof(TPacket).Name}) from received bytes");
}
catch (Exception e)
{
Log.Error(e, "Error in data receiving");
}
finally
{
byte[] buffer = new byte[BufferSize];
ClientSocket.BeginReceive(buffer, 0, BufferSize, SocketFlags.None, ReceiveCallback, buffer);
}
}
private void ReadCallback(IAsyncResult ar)
{
// Retrieve the state object and the handler socket
// from the asynchronous state object.
try
{
_buffer = (byte[])ar.AsyncState;
if (_buffer != null)
{
Socket handler = _socket;
// Read data from the client socket.
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
TPacket packet = ISerializablePacket.FromBytes <TPacket>(_buffer);
_log.Trace($"Received: {packet}");
OnMessageReceived(packet);
handler.BeginReceive(_buffer, 0, BufferSize, 0, ReadCallback, _buffer);
}
else
{
Disconnect();
}
}
else
{
_log.Fatal("_buffer.WorkSocket is null in ReadCallback");
}
}
catch (Exception e)
{
_log.Debug(e);
// If exception is thrown, check if socket is connected, because you can start receiving again. If not - Disconnect.
if (!_socket.Connected)
{
Disconnect();
}
else
{
// HERE
_socket.BeginReceive(_buffer, 0, BufferSize, 0, ReadCallback, _buffer);
}
}
}
protected override void ReceiveCallback(IAsyncResult ar)
{
Log.Trace("ReceiveCallback");
try
{
byte[] buffer = (byte[])ar.AsyncState;
int bytesRead = ClientSocket.EndReceive(ar);
if (bytesRead > 0)
{
TResponsePacket packet = ISerializablePacket.FromBytes <TResponsePacket>(buffer);
Log.Trace($"Received: {packet}");
OnMessageReceivedEvent(packet);
}
}
catch (MessagePackSerializationException e)
{
Log.Warn(e, $"Could not deserialize MessagePack ({typeof(TResponsePacket).Name}) from received bytes");
}
catch (Exception e)
{
Log.Error(e, "Error in data receiving");
}
}