TestSuite (#5)

cuteant · Jul 26, 2020 · 53a2935 · 53a2935
1 parent cdef32c
commit 53a2935
Show file tree

Hide file tree

Showing 51 changed files with 6,286 additions and 77 deletions.
diff --git a/src/DotNetty.Buffers/ArrayPooledByteBuffer.cs b/src/DotNetty.Buffers/ArrayPooledByteBuffer.cs
@@ -29,9 +29,10 @@ internal void Reuse(ArrayPooledByteBufferAllocator allocator, ArrayPool<byte> ar
         {
             _allocator = allocator;
             _arrayPool = arrayPool;
-            SetArray(AllocateArray(initialCapacity));
 
             SetMaxCapacity(maxCapacity);
+            SetArray(AllocateArray(initialCapacity), maxCapacity);
+
             SetReferenceCount(1);
             SetIndex0(0, 0);
             DiscardMarks();
@@ -41,9 +42,10 @@ internal void Reuse(ArrayPooledByteBufferAllocator allocator, ArrayPool<byte> ar
         {
             _allocator = allocator;
             _arrayPool = arrayPool;
-            SetArray(buffer);
 
             SetMaxCapacity(maxCapacity);
+            SetArray(buffer, maxCapacity);
+
             SetReferenceCount(1);
             SetIndex0(0, length);
             DiscardMarks();
@@ -67,10 +69,10 @@ protected virtual void FreeArray(byte[] bytes)
 #endif
         }
 
-        protected void SetArray(byte[] initialArray)
+        protected void SetArray(byte[] initialArray, int maxCapacity)
         {
             Memory = initialArray;
-            _capacity = initialArray.Length;
+            _capacity = Math.Min(initialArray.Length, maxCapacity);
         }
 
         public sealed override IByteBuffer AdjustCapacity(int newCapacity)
@@ -97,7 +99,7 @@ public sealed override IByteBuffer AdjustCapacity(int newCapacity)
             byte[] newArray = AllocateArray(newCapacity);
             PlatformDependent.CopyMemory(oldArray, 0, newArray, 0, bytesToCopy);
 
-            SetArray(newArray);
+            SetArray(newArray, MaxCapacity);
             FreeArray(oldArray);
             return this;
         }

diff --git a/src/DotNetty.Transport.Libuv/ITcpChannelFactory.cs b/src/DotNetty.Transport.Libuv/ITcpChannelFactory.cs
@@ -6,6 +6,6 @@ namespace DotNetty.Transport.Libuv
 {
     public interface ITcpChannelFactory
     {
-        ISocketChannel CreateChannel<TServerChannel>(TServerChannel channel, Tcp tcp) where TServerChannel : IServerChannel;
+        IChannel CreateChannel<TServerChannel>(TServerChannel channel, Tcp tcp) where TServerChannel : IServerChannel;
     }
 }
diff --git a/src/DotNetty.Transport.Libuv/TcpChannel.cs b/src/DotNetty.Transport.Libuv/TcpChannel.cs
@@ -6,7 +6,6 @@ namespace DotNetty.Transport.Libuv
     using System.Net;
     using DotNetty.Transport.Channels;
     using DotNetty.Transport.Libuv.Native;
-    using DotNetty.Transport.Channels.Sockets;
 
     public sealed class TcpChannel : TcpChannel<TcpChannel>
     {
@@ -15,7 +14,7 @@ public TcpChannel() : base() { }
         internal TcpChannel(IChannel parent, Tcp tcp) : base(parent, tcp) { }
     }
 
-    public partial class TcpChannel<TChannel> : NativeChannel<TChannel, TcpChannel<TChannel>.TcpChannelUnsafe>, ISocketChannel
+    public partial class TcpChannel<TChannel> : NativeChannel<TChannel, TcpChannel<TChannel>.TcpChannelUnsafe>
         where TChannel : TcpChannel<TChannel>
     {
         private static readonly ChannelMetadata TcpMetadata = new ChannelMetadata(false);

diff --git a/src/DotNetty.Transport.Libuv/TcpChannelFactory.cs b/src/DotNetty.Transport.Libuv/TcpChannelFactory.cs
@@ -6,7 +6,7 @@ namespace DotNetty.Transport.Libuv
 {
     public sealed class TcpChannelFactory : ITcpChannelFactory
     {
-        public ISocketChannel CreateChannel<TServerChannel>(TServerChannel channel, Tcp tcp) where TServerChannel : IServerChannel
+        public IChannel CreateChannel<TServerChannel>(TServerChannel channel, Tcp tcp) where TServerChannel : IServerChannel
         {
             return new TcpChannel(channel, tcp);
         }

diff --git a/src/DotNetty.Transport.Libuv/TcpServerChannelConfig.cs b/src/DotNetty.Transport.Libuv/TcpServerChannelConfig.cs
@@ -1,9 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-// ReSharper disable ConvertToAutoProperty
-// ReSharper disable ConvertToAutoPropertyWithPrivateSetter
-// ReSharper disable SuggestBaseTypeForParameter
 namespace DotNetty.Transport.Libuv
 {
     using System;

diff --git a/src/DotNetty.Transport/Channels/DefaultChannelPipeline.cs b/src/DotNetty.Transport/Channels/DefaultChannelPipeline.cs
@@ -1313,11 +1313,13 @@ public void ChannelReadComplete(IChannelHandlerContext ctx)
                 ReadIfIsAutoRead();
             }
 
+            [MethodImpl(InlineMethod.AggressiveInlining)]
             private void ReadIfIsAutoRead()
             {
-                if (_pipeline._channel.Configuration.IsAutoRead)
+                var channel = _pipeline._channel;
+                if (channel.Configuration.IsAutoRead)
                 {
-                    _ = _pipeline._channel.Read();
+                    _ = channel.Read();
                 }
             }
 

diff --git a/src/DotNetty.Transport/Channels/Groups/DefaultChannelGroup.cs b/src/DotNetty.Transport/Channels/Groups/DefaultChannelGroup.cs
@@ -24,13 +24,18 @@ public class DefaultChannelGroup : IChannelGroup, IComparable<IChannelGroup>
         private readonly bool _stayClosed;
         private int _closed;
 
-        public DefaultChannelGroup(IEventExecutor executor)
-            : this(executor, false)
+        public DefaultChannelGroup()
+            : this(false)
         {
         }
 
-        public DefaultChannelGroup(string name, IEventExecutor executor)
-            : this(name, executor, false)
+        public DefaultChannelGroup(bool stayClosed)
+            : this(executor: null, stayClosed)
+        {
+        }
+
+        public DefaultChannelGroup(IEventExecutor executor)
+            : this(executor, false)
         {
         }
 
@@ -39,6 +44,16 @@ public DefaultChannelGroup(IEventExecutor executor, bool stayClosed)
         {
         }
 
+        public DefaultChannelGroup(string name, bool stayClosed)
+            : this(name, null, stayClosed)
+        {
+        }
+
+        public DefaultChannelGroup(string name, IEventExecutor executor)
+            : this(name, executor, false)
+        {
+        }
+
         public DefaultChannelGroup(string name, IEventExecutor executor, bool stayClosed)
         {
             if (name is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.name); }

diff --git a/src/DotNetty.Transport/Channels/IDuplexChannel.cs b/src/DotNetty.Transport/Channels/IDuplexChannel.cs
@@ -0,0 +1,33 @@
+namespace DotNetty.Transport.Channels
+{
+    using System.Threading.Tasks;
+    using DotNetty.Common.Concurrency;
+
+    public interface IDuplexChannel : IChannel
+    {
+        /// <summary>
+        /// Returns <c>true</c> if and only if the remote peer shut down its output so that no more
+        /// data is received from this channel.
+        /// </summary>
+        bool IsInputShutdown { get; }
+
+        Task ShutdownInputAsync();
+
+        /// <summary>
+        /// Will shutdown the input and notify <see cref="IPromise"/>.
+        /// </summary>
+        Task ShutdownInputAsync(IPromise promise);
+
+        bool IsOutputShutdown { get; }
+
+        Task ShutdownOutputAsync();
+
+        Task ShutdownOutputAsync(IPromise promise);
+
+        bool IsShutdown { get; }
+
+        Task ShutdownAsync();
+
+        Task ShutdownAsync(IPromise promise);
+    }
+}
diff --git a/src/DotNetty.Transport/Channels/Sockets/AbstractSocketByteChannel.Unsafe.cs b/src/DotNetty.Transport/Channels/Sockets/AbstractSocketByteChannel.Unsafe.cs
@@ -21,7 +21,6 @@ public SocketByteChannelUnsafe() //(AbstractSocketByteChannel channel)
             void CloseOnRead()
             {
                 var ch = _channel;
-                if (!ch.IsOpen) { return; }
 
                 if (!ch.IsInputShutdown)
                 {

diff --git a/src/DotNetty.Transport/Channels/Sockets/AbstractSocketByteChannel.cs b/src/DotNetty.Transport/Channels/Sockets/AbstractSocketByteChannel.cs
@@ -44,7 +44,7 @@ protected AbstractSocketByteChannel(IChannel parent, Socket socket)
         /// <summary>
         /// Shutdown the input side of the channel.
         /// </summary>
-        protected abstract Task ShutdownInputAsync();
+        public abstract Task ShutdownInputAsync();
 
         public virtual bool IsInputShutdown => false;
 

diff --git a/src/DotNetty.Transport/Channels/Sockets/IServerSocketChannel.cs b/src/DotNetty.Transport/Channels/Sockets/IServerSocketChannel.cs
@@ -8,5 +8,6 @@ namespace DotNetty.Transport.Channels.Sockets
     /// </summary>
     public interface IServerSocketChannel : IServerChannel
     {
+        new IServerSocketChannelConfiguration Configuration { get; }
     }
 }
diff --git a/src/DotNetty.Transport/Channels/Sockets/ISocketChannel.cs b/src/DotNetty.Transport/Channels/Sockets/ISocketChannel.cs
@@ -3,7 +3,8 @@
 
 namespace DotNetty.Transport.Channels.Sockets
 {
-    public interface ISocketChannel : IChannel
+    public interface ISocketChannel : IDuplexChannel
     {
+        new ISocketChannelConfiguration Configuration { get; }
     }
 }
diff --git a/src/DotNetty.Transport/Channels/Sockets/TcpServerSocketChannel.cs b/src/DotNetty.Transport/Channels/Sockets/TcpServerSocketChannel.cs
@@ -62,6 +62,7 @@ public TcpServerSocketChannel(Socket socket)
             _channelFactory = new TChannelFactory();
         }
 
+        IServerSocketChannelConfiguration IServerSocketChannel.Configuration => _config;
         public override IChannelConfiguration Configuration => _config;
 
         public override bool IsActive

diff --git a/src/DotNetty.Transport/Channels/Sockets/TcpSocketChannel.cs b/src/DotNetty.Transport/Channels/Sockets/TcpSocketChannel.cs
@@ -43,6 +43,7 @@ public partial class TcpSocketChannel<TChannel> : AbstractSocketByteChannel<TCha
     {
         private static readonly Action<object, object> ShutdownOutputAction = OnShutdownOutput;
         private static readonly Action<object, object> ShutdownInputAction = OnShutdownInput;
+        private static readonly Action<object, object> ShutdownAction = OnShutdown;
 
         private static readonly ChannelMetadata METADATA = new ChannelMetadata(false, 16);
 
@@ -92,6 +93,7 @@ protected TcpSocketChannel(IChannel parent, Socket socket, bool connected)
 
         public override ChannelMetadata Metadata => METADATA;
 
+        ISocketChannelConfiguration ISocketChannel.Configuration => _config;
         public override IChannelConfiguration Configuration => _config;
 
         protected override EndPoint LocalAddressInternal => Socket.LocalEndPoint;
@@ -104,19 +106,20 @@ protected TcpSocketChannel(IChannel parent, Socket socket, bool connected)
 
         public bool IsShutdown => (IsInputShutdown && IsOutputShutdown) || !IsActive;
 
-        protected override Task ShutdownInputAsync()
+        public override Task ShutdownInputAsync() => ShutdownInputAsync(NewPromise());
+
+        public Task ShutdownInputAsync(IPromise promise)
         {
-            var tcs = NewPromise();
             IEventLoop loop = EventLoop;
             if (loop.InEventLoop)
             {
-                ShutdownInput0(tcs);
+                ShutdownInput0(promise);
             }
             else
             {
-                loop.Execute(ShutdownInputAction, this, tcs);
+                loop.Execute(ShutdownInputAction, this, promise);
             }
-            return tcs.Task;
+            return promise.Task;
         }
 
         void ShutdownInput0(IPromise promise)
@@ -125,11 +128,11 @@ void ShutdownInput0(IPromise promise)
             {
                 Socket.Shutdown(SocketShutdown.Receive);
                 _ = Interlocked.Exchange(ref v_inputShutdown, SharedConstants.True);
-                promise.Complete();
+                promise.TryComplete();
             }
             catch (Exception ex)
             {
-                promise.SetException(ex);
+                promise.TrySetException(ex);
             }
         }
 
@@ -138,19 +141,20 @@ private static void OnShutdownInput(object channel, object promise)
             ((TcpSocketChannel<TChannel>)channel).ShutdownInput0((IPromise)promise);
         }
 
-        public Task ShutdownOutputAsync()
+        public Task ShutdownOutputAsync() => ShutdownOutputAsync(NewPromise());
+
+        public Task ShutdownOutputAsync(IPromise promise)
         {
-            var tcs = NewPromise();
             IEventLoop loop = EventLoop;
             if (loop.InEventLoop)
             {
-                ShutdownOutput0(tcs);
+                ShutdownOutput0(promise);
             }
             else
             {
-                loop.Execute(ShutdownOutputAction, this, tcs);
+                loop.Execute(ShutdownOutputAction, this, promise);
             }
-            return tcs.Task;
+            return promise.Task;
         }
 
         void ShutdownOutput0(IPromise promise)
@@ -159,11 +163,11 @@ void ShutdownOutput0(IPromise promise)
             {
                 Socket.Shutdown(SocketShutdown.Send);
                 _ = Interlocked.Exchange(ref v_outputShutdown, SharedConstants.True);
-                promise.Complete();
+                promise.TryComplete();
             }
             catch (Exception ex)
             {
-                promise.SetException(ex);
+                promise.TrySetException(ex);
             }
         }
 
@@ -172,6 +176,42 @@ private static void OnShutdownOutput(object channel, object promise)
             ((TcpSocketChannel<TChannel>)channel).ShutdownOutput0((IPromise)promise);
         }
 
+        public Task ShutdownAsync() => ShutdownAsync(NewPromise());
+
+        public Task ShutdownAsync(IPromise promise)
+        {
+            IEventLoop loop = EventLoop;
+            if (loop.InEventLoop)
+            {
+                Shutdown0(promise);
+            }
+            else
+            {
+                loop.Execute(ShutdownAction, this, promise);
+            }
+            return promise.Task;
+        }
+
+        void Shutdown0(IPromise promise)
+        {
+            try
+            {
+                Socket.Shutdown(SocketShutdown.Both);
+                _ = Interlocked.Exchange(ref v_inputShutdown, SharedConstants.True);
+                _ = Interlocked.Exchange(ref v_outputShutdown, SharedConstants.True);
+                promise.TryComplete();
+            }
+            catch (Exception ex)
+            {
+                promise.TrySetException(ex);
+            }
+        }
+
+        private static void OnShutdown(object channel, object promise)
+        {
+            ((TcpSocketChannel<TChannel>)channel).ShutdownOutput0((IPromise)promise);
+        }
+
         protected override void DoBind(EndPoint localAddress) => Socket.Bind(localAddress);
 
         protected override bool DoConnect(EndPoint remoteAddress, EndPoint localAddress)

diff --git a/test/DotNetty.Buffers.Tests/ByteBufferAllocatorTests.cs b/test/DotNetty.Buffers.Tests/ByteBufferAllocatorTests.cs
@@ -33,8 +33,8 @@ public void Buffer(bool preferDirect)
         }
 
         [Theory]
-        [InlineData(true, 8)]
-        [InlineData(false, 8)]
+        [InlineData(true, 16)]
+        [InlineData(false, 16)]
         public void BufferWithCapacity(bool preferDirect, int maxCapacity)
         {
             IByteBufferAllocator allocator = this.NewAllocator(preferDirect);
@@ -69,8 +69,8 @@ public void HeapBuffer(bool preferDirect)
         protected abstract bool IsDirectExpected(bool preferDirect);
 
         [Theory]
-        [InlineData(true, 8)]
-        [InlineData(false, 8)]
+        [InlineData(true, 16)]
+        [InlineData(false, 16)]
         public void HeapBufferWithCapacity(bool preferDirect, int maxCapacity)
         {
             IByteBufferAllocator allocator = this.NewAllocator(preferDirect);
@@ -103,8 +103,8 @@ public void DirectBuffer(bool preferDirect)
         }
 
         [Theory]
-        [InlineData(true, 8)]
-        [InlineData(false, 8)]
+        [InlineData(true, 16)]
+        [InlineData(false, 16)]
         public void DirectBufferWithCapacity(bool preferDirect, int maxCapacity)
         {
             IByteBufferAllocator allocator = this.NewAllocator(preferDirect);