v4.0.0 (#1357)

2026-10-20 03:24:33 +08:00 · 2022-02-20 21:10:46 +01:00
parent 47e674e4d3
commit 2ce9b94ec9
608 changed files with 22364 additions and 19420 deletions
@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp3.1</TargetFramework>
+        <IsPackable>false</IsPackable>
+        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
+        <EnableNETAnalyzers>false</EnableNETAnalyzers>
+        <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.0" />
+        <PackageReference Include="MSTest.TestAdapter" Version="2.1.2" />
+        <PackageReference Include="MSTest.TestFramework" Version="2.1.2" />
+        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
+        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
+    </ItemGroup>
+
+    <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' ">
+        <PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.2.7" />
+        <PackageReference Include="Microsoft.AspNetCore.Server.Kestrel" Version="2.2.0" />
+    </ItemGroup>
+
+    <ItemGroup Condition=" '$(TargetFramework)' != 'netcoreapp3.1' ">
+        <PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.1.1" />
+        <PackageReference Include="Microsoft.AspNetCore.Server.Kestrel" Version="2.1.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\MQTTnet\MQTTnet.csproj" />
+        <ProjectReference Include="..\MQTTnet.AspnetCore\MQTTnet.AspNetCore.csproj" />
+        <ProjectReference Include="..\MQTTnet.Tests\MQTTnet.Tests.csproj" />
+    </ItemGroup>
+
+</Project>
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.IO.Pipelines;
+using Microsoft.AspNetCore.Connections;
+using Microsoft.AspNetCore.Http.Features;
+
+namespace MQTTnet.AspNetCore.Tests.Mockups
+{
+    public class ConnectionContextMockup : ConnectionContext
+    {
+        public override string ConnectionId { get; set; }
+
+        public override IFeatureCollection Features { get; }
+
+        public override IDictionary<object, object> Items { get; set; }
+        public override IDuplexPipe Transport { get; set; }
+
+        public ConnectionContextMockup()
+        {
+            //Transport = new DefaultConnectionContext
+        }
+    }
+}
@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.AspNetCore.Connections;
+using MQTTnet.Adapter;
+using MQTTnet.Formatter;
+using MQTTnet.Server;
+using System;
+using System.Threading.Tasks;
+using MQTTnet.Diagnostics;
+
+namespace MQTTnet.AspNetCore.Tests.Mockups
+{
+    public class ConnectionHandlerMockup: IMqttServerAdapter
+    {
+        public TaskCompletionSource<MqttConnectionContext> Context { get; } = new TaskCompletionSource<MqttConnectionContext>();
+        public Func<IMqttChannelAdapter, Task> ClientHandler { get; set; }
+
+        public async Task OnConnectedAsync(ConnectionContext connection)
+        {
+            try
+            {
+                var formatter = new MqttPacketFormatterAdapter(new MqttBufferWriter(4096, 65535));
+                var context = new MqttConnectionContext(formatter, connection);
+                Context.TrySetResult(context);
+
+                await ClientHandler(context);
+            }
+            catch (Exception ex)
+            {
+                Context.TrySetException(ex);
+            }
+        }
+
+        public Task StartAsync(MqttServerOptions options, IMqttNetLogger logger)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+}
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.IO.Pipelines;
+
+namespace MQTTnet.AspNetCore.Tests.Mockups
+{
+    public class DuplexPipeMockup : IDuplexPipe
+    {
+        public DuplexPipeMockup()
+        {
+            var pool = new LimitedMemoryPool();
+            var pipeOptions = new PipeOptions(pool);
+            Receive = new Pipe(pipeOptions);
+            Send = new Pipe(pipeOptions);
+        }
+
+        PipeReader IDuplexPipe.Input => Receive.Reader;
+
+        PipeWriter IDuplexPipe.Output => Send.Writer;
+
+
+        public Pipe Receive { get; set; } 
+
+        public Pipe Send { get; set; }
+    }
+}
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+
+namespace MQTTnet.AspNetCore.Tests.Mockups
+{
+    public class LimitedMemoryPool : MemoryPool<byte>
+    {
+        protected override void Dispose(bool disposing)
+        {
+        }
+
+        public override IMemoryOwner<byte> Rent(int minBufferSize = -1)
+        {
+            return new MemoryOwner(minBufferSize);
+        }
+
+        public override int MaxBufferSize { get; }
+    }
+}
@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Buffers;
+
+namespace MQTTnet.AspNetCore.Tests.Mockups
+{
+    public class MemoryOwner : IMemoryOwner<byte>
+    {
+        private readonly byte[] _raw;
+
+        public MemoryOwner(int size)
+        {
+            if (size <= 0)
+            {
+                size = 1024;
+            }
+
+            if (size > 4096)
+            {
+                size = 4096;
+            }
+
+            _raw = ArrayPool<byte>.Shared.Rent(size);
+            Memory = _raw;
+        }
+
+        public void Dispose()
+        {
+            ArrayPool<byte>.Shared.Return(_raw);
+        }
+
+        public Memory<byte> Memory { get; }
+    }
+}
@@ -0,0 +1,136 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Connections;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using System;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Adapter;
+using MQTTnet.AspNetCore.Tests.Mockups;
+using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
+using MQTTnet.Packets;
+using MQTTnet.Client;
+using MQTTnet.Protocol;
+using MQTTnet.Tests.Extensions;
+
+namespace MQTTnet.AspNetCore.Tests
+{
+    [TestClass]
+    public class MqttConnectionContextTest
+    {
+        [TestMethod]
+        public async Task TestReceivePacketAsyncThrowsWhenReaderCompleted()
+        {
+            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
+            var pipe = new DuplexPipeMockup();
+            var connection = new DefaultConnectionContext();
+            connection.Transport = pipe;
+            var ctx = new MqttConnectionContext(serializer, connection);
+
+            pipe.Receive.Writer.Complete();
+
+            await Assert.ThrowsExceptionAsync<MqttCommunicationException>(() => ctx.ReceivePacketAsync(CancellationToken.None));
+        }
+
+        [TestMethod]
+        public async Task TestCorruptedConnectPacket()
+        {
+            var writer = new MqttBufferWriter(4096, 65535);
+            var serializer = new MqttPacketFormatterAdapter(writer);
+            var pipe = new DuplexPipeMockup();
+            var connection = new DefaultConnectionContext();
+            connection.Transport = pipe;
+            var ctx = new MqttConnectionContext(serializer, connection);
+            
+            await pipe.Receive.Writer.WriteAsync(writer.AddMqttHeader(MqttControlPacketType.Connect, new byte[0]));
+
+            await Assert.ThrowsExceptionAsync<MqttProtocolViolationException>(() => ctx.ReceivePacketAsync(CancellationToken.None));
+
+            // the first exception should complete the pipes so if someone tries to use the connection after that it should throw immidiatly
+            await Assert.ThrowsExceptionAsync<InvalidOperationException>(() =>  ctx.ReceivePacketAsync(CancellationToken.None));
+        }
+
+        // COMMENTED OUT DUE TO DEAD LOCK? OR VERY VERY SLOW PERFORMANCE ON LOCAL DEV MACHINE. TEST WAS STILL RUNNING AFTER SEVERAL MINUTES!
+        //[TestMethod]
+        //public async Task TestParallelWrites()
+        //{
+        //    var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311);
+        //    var pipe = new DuplexPipeMockup();
+        //    var connection = new DefaultConnectionContext();
+        //    connection.Transport = pipe;
+        //    var ctx = new MqttConnectionContext(serializer, connection);
+
+        //    var tasks = Enumerable.Range(1, 100).Select(_ => Task.Run(async () => 
+        //    {
+        //        for (int i = 0; i < 100; i++)
+        //        {
+        //            await ctx.SendPacketAsync(new MqttPublishPacket(), TimeSpan.Zero, CancellationToken.None).ConfigureAwait(false);
+        //        }
+        //    }));
+
+        //    await Task.WhenAll(tasks).ConfigureAwait(false);
+        //}
+        
+        [TestMethod]
+        public async Task TestLargePacket()
+        {
+            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
+            var pipe = new DuplexPipeMockup();
+            var connection = new DefaultConnectionContext();
+            connection.Transport = pipe;
+            var ctx = new MqttConnectionContext(serializer, connection);
+
+            await ctx.SendPacketAsync(new MqttPublishPacket { Payload = new byte[20_000] }, CancellationToken.None).ConfigureAwait(false);
+
+            var readResult = await pipe.Send.Reader.ReadAsync();
+            Assert.IsTrue(readResult.Buffer.Length > 20000);
+        }
+
+        private class Startup 
+        {
+            public void Configure(IApplicationBuilder app)
+            { 
+            }
+        }
+
+        [TestMethod]
+        public async Task TestEndpoint()
+        {
+            var mockup = new ConnectionHandlerMockup();
+
+
+            using (var host = new WebHostBuilder()
+                .UseKestrel(kestrel => kestrel.ListenLocalhost(1883, listener => listener.Use((ctx, next) => mockup.OnConnectedAsync(ctx))))
+                .UseStartup<Startup>()
+                .ConfigureServices((hostContext, services) =>
+                {
+                    services.AddHostedMqttServer(o => o.WithoutDefaultEndpoint());
+                    services.AddSingleton<IMqttServerAdapter>(mockup);
+                })
+                .Build())
+                
+            using (var client = new MqttFactory().CreateMqttClient())
+            {
+                host.Start();
+                await client.ConnectAsync(new MqttClientOptionsBuilder()
+                    .WithTcpServer("localhost")
+                    .Build(), CancellationToken.None);
+
+                var ctx = await mockup.Context.Task;
+#if NETCOREAPP3_1
+                var ep = IPEndPoint.Parse(ctx.Endpoint);
+                Assert.IsNotNull(ep);
+#endif
+                Assert.IsNotNull(ctx);
+            }               
+        }
+    }
+}
@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if NETCOREAPP3_1
+using System.Buffers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.AspNetCore;
+using MQTTnet.Formatter;
+using MQTTnet.Packets;
+
+namespace MQTTnet.AspNetCore.Tests
+{
+    [TestClass]
+    public class ReaderExtensionsTest
+    {
+        [TestMethod]
+        public void TestTryDeserialize()
+        {
+            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
+
+            var buffer = serializer.Encode(new MqttPublishPacket {Topic = "a", Payload = new byte[5]}).Join();
+
+            var sequence = new ReadOnlySequence<byte>(buffer.Array, buffer.Offset, buffer.Count);
+
+            var part = sequence;
+            MqttPacket packet;
+            var consumed = part.Start;
+            var observed = part.Start;
+            var result = false;
+            var read = 0;
+            
+            part = sequence.Slice(sequence.Start, 0); // empty message should fail
+            result = serializer.TryDecode(part, out packet, out consumed, out observed, out read);
+            Assert.IsFalse(result);
+
+            part = sequence.Slice(sequence.Start, 1); // partial fixed header should fail
+            result = serializer.TryDecode(part, out packet, out consumed, out observed, out read);
+            Assert.IsFalse(result);
+
+            part = sequence.Slice(sequence.Start, 4); // partial body should fail
+            result = serializer.TryDecode(part, out packet, out consumed, out observed, out read);
+            Assert.IsFalse(result);
+
+            part = sequence; // complete msg should work
+            result = serializer.TryDecode(part, out packet, out consumed, out observed, out read);
+            Assert.IsTrue(result);
+        }
+    }
+}
+#endif