private async Task Accept()
{
try
{
while (IsListening)
{
var saea = _acceptSaeaPool.Take();
var socketError = await _listener.AcceptAsync(saea);
if (socketError == SocketError.Success)
{
var acceptedSocket = saea.Saea.AcceptSocket;
Task.Run(async() =>
{
await Process(acceptedSocket);
})
.Forget();
}
else
{
// _log.ErrorFormat("Error occurred when accept incoming socket [{0}].", socketError);
}
_acceptSaeaPool.Return(saea);
}
}
catch (Exception ex) when(!ShouldThrow(ex))
{
}
catch (Exception ex)
{
// _log.Error(ex.Message, ex);
}
}
public void Send(Package package)
{
if (Status == ListenerStatus.Stopped)
{
return;
}
var saea = SaeaPool.Take();
saea.Completed += IOSendCompleted;
saea.SetBuffer(package.Data, 0, package.Data.Length);
saea.RemoteEndPoint = package.EndPoint;
var async = Listener.SendToAsync(saea);
if (!async)
{
IOSendCompleted(null, saea);
}
}
private async Task Process()
{
try
{
int frameLength;
byte[] payload;
int payloadOffset;
int payloadCount;
int consumedLength = 0;
var saea = _saeaPool.Take();
saea.Saea.SetBuffer(_receiveBuffer, _receiveBufferOffset, _receiveBuffer.Length - _receiveBufferOffset);
while (State == TcpSocketConnectionState.Connected)
{
saea.Saea.SetBuffer(_receiveBuffer, _receiveBufferOffset, _receiveBuffer.Length - _receiveBufferOffset);
var socketError = await _socket.ReceiveAsync(saea);
if (socketError != SocketError.Success)
{
break;
}
var receiveCount = saea.Saea.BytesTransferred;
if (receiveCount == 0)
{
break;
}
BufferDeflector.ReplaceBuffer(_bufferManager, ref _receiveBuffer, ref _receiveBufferOffset, receiveCount);
consumedLength = 0;
while (true)
{
frameLength = 0;
payload = null;
payloadOffset = 0;
payloadCount = 0;
if (_configuration.FrameBuilder.Decoder.TryDecodeFrame(_receiveBuffer, consumedLength, _receiveBufferOffset - consumedLength,
out frameLength, out payload, out payloadOffset, out payloadCount))
{
try
{
await _dispatcher.OnSessionDataReceived(this, payload, payloadOffset, payloadCount);
}
catch (Exception ex)
{
HandleUserSideError(ex);
}
finally
{
consumedLength += frameLength;
}
}
else
{
break;
}
}
try
{
BufferDeflector.ShiftBuffer(_bufferManager, consumedLength, ref _receiveBuffer, ref _receiveBufferOffset);
}
catch (ArgumentOutOfRangeException) { }
}
}
catch (Exception ex) when(!ShouldThrow(ex))
{
}
finally
{
await Close();
}
}
public async Task Connect()
{
int origin = Interlocked.CompareExchange(ref _state, _connecting, _none);
if (origin == _disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
else if (origin != _none)
{
throw new InvalidOperationException("This tcp socket client has already connected to server.");
}
try
{
_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
if (_localEndPoint != null)
{
_socket.Bind(_localEndPoint);
}
var saea = _saeaPool.Take();
saea.Saea.RemoteEndPoint = _remoteEndPoint;
var socketError = await _socket.ConnectAsync(saea);
if (socketError != SocketError.Success)
{
throw new SocketException((int)socketError);
}
ConfigureSocket();
_receiveBuffer = _bufferManager.BorrowBuffer();
_receiveBufferOffset = 0;
if (Interlocked.CompareExchange(ref _state, _connected, _connecting) != _connecting)
{
throw new ObjectDisposedException(GetType().FullName);
}
/*_log.DebugFormat("Connected to server [{0}] with dispatcher [{1}] on [{2}].",
* this.RemoteEndPoint,
* _dispatcher.GetType().Name,
* DateTime.UtcNow.ToString(@"yyyy-MM-dd HH:mm:ss.fffffff"));*/
bool isErrorOccurredInUserSide = false;
try
{
await _dispatcher.OnServerConnected(this);
}
catch (Exception ex)
{
isErrorOccurredInUserSide = true;
HandleUserSideError(ex);
}
if (!isErrorOccurredInUserSide)
{
Task.Run(async() =>
{
await Process();
})
.Forget();
}
else
{
await Close();
}
}
catch (ObjectDisposedException) { }
catch (Exception ex)
{
// _log.Error(ex.Message, ex);
throw;
}
}
