public async Task Write(MessageCode messageCode)
{
const int sizeSize = sizeof(int);
const int codeSize = sizeof(byte);
var buffer = _blockingBufferManager.GetBuffer();
try
{
var size = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(codeSize));
var messageBody = new ArraySegment <byte>(
buffer.Array,
buffer.Offset,
sizeSize + codeSize);
Array.Copy(size, 0, messageBody.Array, messageBody.Offset, sizeSize);
messageBody.Array[messageBody.Offset + sizeSize] = (byte)messageCode;
await GetConnectedSocket().ConfigureAwait(false);
await SendAsync(messageBody).ConfigureAwait(false);
}
catch (RiakException)
{
if (_socket != null)
{
_socket.Close();
_socket = null;
}
throw;
}
catch (SocketException)
{
if (_socket != null)
{
_socket.Close();
_socket = null;
}
throw;
}
finally
{
_blockingBufferManager.ReleaseBuffer(buffer);
}
}
public void TestDisposingBeforeReleasingBuffer()
{
var count = 4000;
var manager = new BlockingBufferManager(300, count);
var buffer = manager.GetBuffer();
manager.Dispose();
manager.ReleaseBuffer(buffer);
}
public async Task SendAsyncImmediatelly(byte[] packetBytes)
{
int totalBytesSent = 0;
var socketAwaitable = socketAwaitablePool.Take();
var sendBuffer = bufferManager.GetBuffer();
var sendBufferMaxSize = sendBuffer.Count;
try
{
while (totalBytesSent < packetBytes.Length)
{
socketAwaitable.Clear();
var writeCount = Math.Min(packetBytes.Length - totalBytesSent, sendBufferMaxSize);
Buffer.BlockCopy(packetBytes, totalBytesSent, sendBuffer.Array, sendBuffer.Offset, writeCount);
socketAwaitable.Buffer = new ArraySegment <byte>(sendBuffer.Array, sendBuffer.Offset, writeCount);
var result = await Socket.SendAsync(socketAwaitable);
if (result != SocketError.Success || socketAwaitable.Transferred.Count == 0)
{
if (Logger.IsDebugEnabled && result != SocketError.Success)
{
Logger.Debug("Socket did not succeed when sending a packet socketError[{0}] IP[{1}]", result, RemoteIP);
}
return;
}
totalBytesSent += socketAwaitable.Transferred.Count;
}
}
// Ignore cases where we accidentally send to the socket after its been disposed
catch (ObjectDisposedException) { }
catch (Exception e)
{
Logger.Warn(e, "Unexpected exception in send IP[{0}]", RemoteIP);
}
finally
{
socketAwaitable.Clear();
socketAwaitablePool.Add(socketAwaitable);
bufferManager.ReleaseBuffer(sendBuffer);
}
}
public void TestTakingAndReleasing()
{
var count = 4000;
var manager = new BlockingBufferManager(300, count);
// Take all buffers.
var buffers = new ArraySegment<byte>[count];
Parallel.For(0, count, i => buffers[i] = manager.GetBuffer());
Assert.AreEqual(manager.AvailableBuffers, 0);
// Start releasing every buffer after one second.
Task.Delay(1000).ContinueWith(t => Parallel.For(0, count, i => manager.ReleaseBuffer(buffers[i])));
Assert.AreEqual(manager.AvailableBuffers, 0);
// Take buffers as they become available, block the thread as needed.
var buffers2 = new ArraySegment<byte>[count];
Parallel.For(0, count, i => buffers2[i] = manager.GetBuffer());
Assert.AreEqual(manager.AvailableBuffers, 0);
}
public void TestTakingAndReleasing()
{
var count = 4000;
var manager = new BlockingBufferManager(300, count);
// Take all buffers.
var buffers = new ArraySegment <byte> [count];
Parallel.For(0, count, i => buffers[i] = manager.GetBuffer());
Assert.AreEqual(manager.AvailableBuffers, 0);
// Start releasing every buffer after one second.
Task.Delay(1000).ContinueWith(t => Parallel.For(0, count, i => manager.ReleaseBuffer(buffers[i])));
Assert.AreEqual(manager.AvailableBuffers, 0);
// Take buffers as they become available, block the thread as needed.
var buffers2 = new ArraySegment <byte> [count];
Parallel.For(0, count, i => buffers2[i] = manager.GetBuffer());
Assert.AreEqual(manager.AvailableBuffers, 0);
}
private async Task ListenerHandler()
{
listener.Listen(int.MaxValue);
while (!isStopped)
{
SocketAwaitable socketAwaitable = null;
ArraySegment <byte> buffer = new ArraySegment <byte>();
try
{
socketAwaitable = socketAwaitablePool.Take();
socketAwaitable.Clear();
buffer = bufferManager.GetBuffer();
socketAwaitable.Buffer = buffer;
var result = await listener.AcceptAsync(socketAwaitable);
if (result != SocketError.Success || socketAwaitable.AcceptSocket == null)
{
if (logger.IsDebugEnabled)
{
logger.Debug("Received error when accepting connection result[{0}]", result);
}
continue;
}
var socket = socketAwaitable.AcceptSocket;
logger.Info("Received connection from {0}", socket.RemoteEndPoint.ToString());
socket.NoDelay = true;
socket.SendTimeout = 1000;
var session = socketSessionFactory.CreateAsyncSocketSession(socket.RemoteEndPoint.ToString(), socket);
session.PacketMaker.Append(socketAwaitable.Transferred);
Add(session);
}
catch (SocketException e)
{
logger.Info(e, "SocketException in ListenerHandler. Ignoring...");
continue;
}
catch (Exception e)
{
logger.Warn(e, "Exception in ListenerHandler");
throw;
}
finally
{
if (socketAwaitable != null)
{
socketAwaitable.Clear();
socketAwaitablePool.Add(socketAwaitable);
}
if (buffer.Array != null)
{
bufferManager.ReleaseBuffer(buffer);
}
}
}
}
public void TestDisposingBeforeReleasingBuffer()
{
var count = 4000;
var manager = new BlockingBufferManager(300, count);
var buffer = manager.GetBuffer();
manager.Dispose();
manager.ReleaseBuffer(buffer);
}
