public TcpChannel(IPipeline pipeline, BufferPool pool)
 {
     _pipeline = pipeline;
     Pipeline.SetChannel(this);
     _readBuffer = pool.PopSlice();
     _stream = new PeekableMemoryStream(_readBuffer.Buffer, _readBuffer.StartOffset, _readBuffer.Capacity);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="BodyDecoder"/> class.
 /// </summary>
 /// <param name="decoderService">The decoder service.</param>
 /// <param name="bufferSize">Buffer size of each buffer in the pool. Read the remarks at <see cref="BodyDecoder"/></param>
 /// <param name="sizeLimit">Maximum size of the body in bytes. Larger content will generate a <see cref="HttpStatusCode.RequestEntityTooLarge"/> response which will
 /// be sent back to the client.</param>
 public BodyDecoder(IBodyDecoder decoderService, int bufferSize, int sizeLimit)
 {
     if (decoderService == null) throw new ArgumentNullException("decoderService");
     _decoderService = decoderService;
     _bufferSize = bufferSize;
     _sizeLimit = sizeLimit;
     _bufferPool = new BufferPool(_bufferSize, 10, 1000);
 }
Esempio n. 3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="BufferPoolStream"/> class.
 /// </summary>
 /// <param name="pool">The pool.</param>
 /// <param name="slice">The slice.</param>
 public BufferPoolStream(BufferPool pool, BufferSlice slice)
     : base(slice.Buffer, slice.StartOffset, slice.Capacity, true, true)
 {
     _slize = slice;
     _pool = pool;
     SetLength(slice.Count);
     Position = slice.Position;
 }
        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        /// <filterpriority>2</filterpriority>
        public void Dispose()
        {
            if (_pool == null)
                return;

            _pool.Push(Buffer);
            _pool = null;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="ContentDecoder"/> class.
 /// </summary>
 /// <param name="mapper">Used to determine which packets to deserialize.</param>
 /// <param name="bufferPool">Used to store packet bytes before deserialization.</param>
 /// <param name="decoder">Used to deserialize the backet bytes..</param>
 public ContentDecoder(ContentMapper mapper, BufferPool bufferPool, IContentDecoder decoder)
 {
     if (mapper == null) throw new ArgumentNullException("mapper");
     if (bufferPool == null) throw new ArgumentNullException("bufferPool");
     if (decoder == null) throw new ArgumentNullException("decoder");
     _mapper = mapper;
     _bufferPool = bufferPool;
     _decoder = decoder;
 }
Esempio n. 6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TcpChannel"/> class.
 /// </summary>
 /// <param name="pipeline">The pipeline used to send messages upstream.</param>
 /// <param name="pool">Buffer pool.</param>
 public TcpChannel(IPipeline pipeline, BufferPool pool)
 {
     _pipeline = pipeline;
     _pool = pool;
     Pipeline.SetChannel(this);
     if (pool == null)
         _readBuffer = new BufferSlice(new byte[65535], 0, 65535, 0);
     else
         _readBuffer = pool.PopSlice();
     _stream = new PeekableMemoryStream(_readBuffer.Buffer, _readBuffer.StartOffset, _readBuffer.Capacity);
 }
        public void FillBuffers()
        {
            LogManager.Assign(new SimpleSystemDebugLogManager());

            var pool = new BufferPool(100, 2, 2);
            _target = new TcpServerClientChannel(_pipeline, pool);
            _target.AssignSocket(_sockets.Client);
            _target.StartChannel();

            var sb = new StringBuilder();
            for (int i = 0; i < 1000; i++)
            {
                sb.Append(i.ToString());
                sb.Append("|");
                if ((i % 25) == 0)
                    sb.AppendLine();
            }
            var sendBuffer = Encoding.ASCII.GetBytes(sb.ToString());
            var sent = 0;
            while (sent < sendBuffer.Length)
            {
                sent += _sockets.Server.Send(sendBuffer, sent, sendBuffer.Length - sent, SocketFlags.None);
            }

            Assert.True(_pipeline.WaitOnUpstream<Received>(TimeSpan.FromMilliseconds(1000)), "Incoming message timeout");

            var receivedBuffer = new byte[sendBuffer.Length];
            var stream= new MemoryStream(receivedBuffer);
            foreach (var msg in _pipeline.UpstreamMessages)
            {
                var m = msg as Received;
                if (m == null)
                    continue;

                stream.Write(m.BufferSlice.Buffer, m.BufferSlice.CurrentOffset, m.BufferSlice.RemainingLength);
            }
            stream.Flush();

            Assert.Equal(sendBuffer.Length, receivedBuffer.Length);
            for (int i = 0; i < sendBuffer.Length; i++)
            {
                if (sendBuffer[i] != receivedBuffer[i])
                    throw new InvalidOperationException("First difference at " + i);
            }
            
        }
 public TcpServerClientChannel(IPipeline pipeline, BufferPool pool) : base(pipeline, pool)
 {
 }
 public BufferPoolStream(BufferPool pool)
     : base(pool.Pop())
 {
     _pool = pool;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ReusableBufferSlice"/> class.
 /// </summary>
 /// <param name="pool">Pool that the buffer should be released to.</param>
 /// <param name="buffer">The buffer.</param>
 /// <param name="startOffset">Offset in buffer where the slice starts.</param>
 /// <param name="capacity">Number of bytes allocated for this slice.</param>
 /// <param name="count">Number of bytes written to the buffer (if any)</param>
 public ReusableBufferSlice(BufferPool pool, byte[] buffer, int startOffset, int capacity, int count)
     : base(buffer, startOffset, capacity, count)
 {
     _pool = pool;
 }