fixed core 3.1 startup and verified it still works with 2.1 and net461

2026-10-20 11:45:43 +08:00 · 2020-03-15 14:43:59 +01:00
parent f6a814c6d7
commit 20eda96921
14 changed files with 102 additions and 34 deletions
@@ -0,0 +1,48 @@
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using MQTTnet.Server;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ApplicationBuilderExtensions
+    {
+        [Obsolete("This class is obsolete and will be removed in a future version. The recommended alternative is to use MapMqtt inside Microsoft.AspNetCore.Builder.UseEndpoints(...).")]
+        public static IApplicationBuilder UseMqttEndpoint(this IApplicationBuilder app, string path = "/mqtt")
+        {
+            app.UseWebSockets();
+            app.Use(async (context, next) =>
+            {
+                if (!context.WebSockets.IsWebSocketRequest || context.Request.Path != path)
+                {
+                    await next();
+                    return;
+                }
+
+                string subProtocol = null;
+
+                if (context.Request.Headers.TryGetValue("Sec-WebSocket-Protocol", out var requestedSubProtocolValues))
+                {
+                    subProtocol = MqttSubProtocolSelector.SelectSubProtocol(requestedSubProtocolValues);
+                }
+
+                var adapter = app.ApplicationServices.GetRequiredService<MqttWebSocketServerAdapter>();
+                using (var webSocket = await context.WebSockets.AcceptWebSocketAsync(subProtocol).ConfigureAwait(false))
+                {
+                    await adapter.RunWebSocketConnectionAsync(webSocket, context);
+                }
+            });
+
+            return app;
+        }
+
+        public static IApplicationBuilder UseMqttServer(this IApplicationBuilder app, Action<IMqttServer> configure)
+        {
+            var server = app.ApplicationServices.GetRequiredService<IMqttServer>();
+
+            configure(server);
+
+            return app;
+        }
+    }
+}
@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Connections;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ConnectionBuilderExtensions
+    {
+        public static IConnectionBuilder UseMqtt(this IConnectionBuilder builder)
+        {
+            return builder.UseConnectionHandler<MqttConnectionHandler>();
+        }
+    }
+}
@@ -0,0 +1,20 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Connections;
+using System;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ConnectionRouteBuilderExtensions
+    {
+#if NETCOREAPP3_1
+        [Obsolete("This class is obsolete and will be removed in a future version. The recommended alternative is to use MapMqtt inside Microsoft.AspNetCore.Builder.UseEndpoints(...).")]
+#endif
+        public static void MapMqtt(this ConnectionsRouteBuilder connection, PathString path)
+        {
+            connection.MapConnectionHandler<MqttConnectionHandler>(path, options =>
+            {
+                options.WebSockets.SubProtocolSelector = MqttSubProtocolSelector.SelectSubProtocol;
+            });
+        }
+    }
+}
@@ -0,0 +1,21 @@
+
+#if NETCOREAPP3_1
+
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Routing;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class EndpointRouterExtensions
+    {
+        public static void MapMqtt(this IEndpointRouteBuilder endpoints, string pattern) 
+        {
+            endpoints.MapConnectionHandler<MqttConnectionHandler>(pattern, options =>
+            {
+                options.WebSockets.SubProtocolSelector = MqttSubProtocolSelector.SelectSubProtocol;
+            });
+        }
+    }
+}
+
+#endif
@@ -0,0 +1,110 @@
+using System;
+using System.Buffers;
+using MQTTnet.Adapter;
+using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
+using MQTTnet.Packets;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ReaderExtensions
+    {
+        public static bool TryDecode(this MqttPacketFormatterAdapter formatter, 
+            SpanBasedMqttPacketBodyReader reader, 
+            in ReadOnlySequence<byte> input, 
+            out MqttBasePacket packet, 
+            out SequencePosition consumed, 
+            out SequencePosition observed,
+            out int bytesRead)
+        {
+            if (formatter == null) throw new ArgumentNullException(nameof(formatter));
+
+            packet = null;
+            consumed = input.Start;
+            observed = input.End;
+            bytesRead = 0;
+            var copy = input;
+
+            if (copy.Length < 2)
+            {
+                return false;
+            }
+
+            var fixedheader = copy.First.Span[0];
+            if (!TryReadBodyLength(ref copy, out int headerLength, out var bodyLength))
+            {
+                return false;
+            }
+
+            if (copy.Length < bodyLength)
+            {
+                return false;
+            }
+
+            var bodySlice = copy.Slice(0, bodyLength);
+            var buffer = bodySlice.GetMemory();
+            reader.SetBuffer(buffer);
+
+            var receivedMqttPacket = new ReceivedMqttPacket(fixedheader, reader, buffer.Length + 2);
+
+            if (formatter.ProtocolVersion == MqttProtocolVersion.Unknown)
+            {
+                formatter.DetectProtocolVersion(receivedMqttPacket);
+            }
+
+            packet = formatter.Decode(receivedMqttPacket);
+            consumed = bodySlice.End;
+            observed = bodySlice.End;
+            bytesRead = headerLength + bodyLength;
+            return true;
+        }
+
+        private static ReadOnlyMemory<byte> GetMemory(this in ReadOnlySequence<byte> input)
+        {
+            if (input.IsSingleSegment)
+            {
+                return input.First;
+            }
+
+            // Should be rare
+            return input.ToArray();
+        }
+
+        private static bool TryReadBodyLength(ref ReadOnlySequence<byte> input, out int headerLength, out int bodyLength)
+        {
+            // Alorithm taken from https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html.
+            var multiplier = 1;
+            var value = 0;
+            byte encodedByte;
+            var index = 1;
+            headerLength = 0;
+            bodyLength = 0;
+            
+            var temp = input.Slice(0, Math.Min(5, input.Length)).GetMemory();
+
+            do
+            {
+                if (index == temp.Length)
+                {
+                    return false;
+                }
+                encodedByte = temp.Span[index];
+                index++;
+
+                value += (byte)(encodedByte & 127) * multiplier;
+                if (multiplier > 128 * 128 * 128)
+                {
+                    throw new MqttProtocolViolationException($"Remaining length is invalid (Data={string.Join(",", temp.Slice(1, index).ToArray())}).");
+                }
+
+                multiplier *= 128;
+            } while ((encodedByte & 128) != 0);
+
+            input = input.Slice(index);
+
+            headerLength = index;
+            bodyLength = value;
+            return true;
+        }
+    }
+}
@@ -0,0 +1,98 @@
+using System;
+using Microsoft.Extensions.Hosting;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Server;
+using MQTTnet.Implementations;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, IMqttServerOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+            
+            services.AddSingleton(options);
+
+            services.AddHostedMqttServer();
+
+            return services;
+        }
+
+        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, Action<MqttServerOptionsBuilder> configure)
+        {
+            services.AddSingleton<IMqttServerOptions>(s => {
+                var builder = new MqttServerOptionsBuilder();
+                configure(builder);
+                return builder.Build();
+            });
+
+            services.AddHostedMqttServer();
+
+            return services;
+        }
+
+        public static IServiceCollection AddHostedMqttServerWithServices(this IServiceCollection services, Action<AspNetMqttServerOptionsBuilder> configure)
+        {
+            services.AddSingleton<IMqttServerOptions>(s => {
+                var builder = new AspNetMqttServerOptionsBuilder(s);
+                configure(builder);
+                return builder.Build();
+            });
+
+            services.AddHostedMqttServer();
+
+            return services;
+        }
+
+        public static IServiceCollection AddHostedMqttServer<TOptions>(this IServiceCollection services)
+            where TOptions : class, IMqttServerOptions
+        {
+            services.AddSingleton<IMqttServerOptions, TOptions>();
+
+            services.AddHostedMqttServer();
+
+            return services;
+        }
+
+        private static IServiceCollection AddHostedMqttServer(this IServiceCollection services)
+        {
+            var logger = new MqttNetLogger();
+            var childLogger = logger.CreateChildLogger();
+
+            services.AddSingleton<IMqttNetLogger>(logger);
+            services.AddSingleton(childLogger);
+            services.AddSingleton<MqttHostedServer>();
+            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
+            services.AddSingleton<IMqttServer>(s => s.GetService<MqttHostedServer>());
+            
+            return services;
+        }
+
+        public static IServiceCollection AddMqttWebSocketServerAdapter(this IServiceCollection services)
+        {
+            services.AddSingleton<MqttWebSocketServerAdapter>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttWebSocketServerAdapter>());
+
+            return services;
+        }
+
+        public static IServiceCollection AddMqttTcpServerAdapter(this IServiceCollection services)
+        {
+            services.AddSingleton<MqttTcpServerAdapter>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttTcpServerAdapter>());
+
+            return services;
+        }
+
+        public static IServiceCollection AddMqttConnectionHandler(this IServiceCollection services)
+        {
+            services.AddSingleton<MqttConnectionHandler>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttConnectionHandler>());
+
+            return services;
+        }
+    }
+}