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