public void TestDisposingWhileGettingBuffer()
{
var manager = new BlockingBufferManager(300, 1);
// Take the only buffer.
manager.GetBuffer();
// Dispose after one second.
Task.Delay(1000).ContinueWith(t => manager.Dispose());
// Wait for a buffer to become available.
manager.GetBuffer();
}
public void TestDisposingBeforeGettingBuffer()
{
var count = 4000;
var manager = new BlockingBufferManager(300, count);
manager.Dispose();
manager.GetBuffer();
}
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 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 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);
}
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 async Task <string> AsyncConversation(string msgOut)
{
// Data buffer for incoming data.
byte[] bytes = new byte[1024];
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
// This example uses port 11000 on the local computer.
//IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
//IPAddress ipAddress;
//IPAddress.TryParse("10.200.90.7", out ipAddress);
IPEndPoint remoteEP = new IPEndPoint(oServer.IP, 17011);
// Create a TCP/IP socket.
Socket sender = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
// Connect the socket to the remote endpoint. Catch any errors.
try
{
Status = SocksStatus.TRYCONNECT;
sender.Connect(remoteEP);
Status = SocksStatus.CONNECTED;
//RunOnUiThread(() => txtConsole.Text += String.Format("Socket connected to {0}\n", sender.RemoteEndPoint.ToString()));
//Console.WriteLine("Socket connected to {0}",
// sender.RemoteEndPoint.ToString());
// Encode the data string into a byte array.
var awaitable = awaitables.Take();
awaitable.Buffer = new ArraySegment <byte>(Encoding.ASCII.GetBytes(msgOut));
while (true)
{
if (await sender.SendAsync(awaitable) != SocketError.Success)
{
throw(new Exception("Error lala")); // or log and throw an exception.
}
if (awaitable.Buffer.Count == awaitable.Transferred.Count)
{
break; // Break if all the data is sent.
}
// Set the buffer to send the remaining data.
awaitable.Buffer = new ArraySegment <byte>(
awaitable.Buffer.Array,
awaitable.Buffer.Offset + awaitable.Transferred.Count,
awaitable.Buffer.Count - awaitable.Transferred.Count);
}
awaitable.Clear();
// Receive the response from the remote device.
string _result = "";
// Get a buffer from the pool.
var buffer = buffers.GetBuffer();
while (true)
{
awaitable.Buffer = buffer;
// Receive data from the client.
var result = await sender.ReceiveAsync(awaitable);
if (result != SocketError.Success)
{
// Something went wrong.
// Check `result` and break the loop.
break;
}
_result += Encoding.ASCII.GetString(buffer.ToArray <byte>(), 0, awaitable.Transferred.Count);
// Received data is now in `awaitable.Transferred`.
if (awaitable.Transferred.Count == 0)
{
// The client "gracefully" closed the connection.
break;
}
}
sender.Shutdown(SocketShutdown.Both);
sender.Close();
Status = SocksStatus.OFFLINE;
return(_result);
}
catch (ArgumentNullException ane)
{
Status = SocksStatus.ERROR;
_ErrorMsg = string.Format("ArgumentNullException : {0}", ane.Message);
throw (ane);
//Console.WriteLine("ArgumentNullException : {0}", ane.ToString());
}
catch (SocketException se)
{
Status = SocksStatus.ERROR;
_ErrorMsg = string.Format("SocketException : {0}", se.Message);
throw (se);
//Console.WriteLine("SocketException : {0}", se.ToString());
}
catch (Exception e)
{
Status = SocksStatus.ERROR;
_ErrorMsg = string.Format("Unexpected exception : {0}", e.Message);
throw (e);
//Console.WriteLine("Unexpected exception : {0}", e.ToString());
}
}
catch (Exception e)
{
Status = SocksStatus.ERROR;
_ErrorMsg = string.Format("General exception : {0}", e.Message);
return("");
throw (e);
//Console.WriteLine(e.ToString());
}
}
public void TestDisposingBeforeGettingBuffer()
{
var count = 4000;
var manager = new BlockingBufferManager(300, count);
manager.Dispose();
manager.GetBuffer();
}
public void TestDisposingWhileGettingBuffer()
{
var manager = new BlockingBufferManager(300, 1);
// Take the only buffer.
manager.GetBuffer();
// Dispose after one second.
Task.Delay(1000).ContinueWith(t => manager.Dispose());
// Wait for a buffer to become available.
manager.GetBuffer();
}
public void TestDisposingBeforeReleasingBuffer()
{
var count = 4000;
var manager = new BlockingBufferManager(300, count);
var buffer = manager.GetBuffer();
manager.Dispose();
manager.ReleaseBuffer(buffer);
}
