Refactoring MQTTnet.AspNetCore

Samples/MQTTnet.Samples.csproj

@@ -14,7 +14,7 @@
         <NuGetAuditMode>all</NuGetAuditMode>
         <NuGetAudit>true</NuGetAudit>
         <NuGetAuditLevel>low</NuGetAuditLevel>
-        <AnalysisLevel>latest-Recommended</AnalysisLevel>
+        <!--<AnalysisLevel>latest-Recommended</AnalysisLevel>-->
     </PropertyGroup>
 
     <ItemGroup>

Samples/Server/Server_ASP_NET_Samples.cs

@@ -12,99 +12,95 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using MQTTnet.AspNetCore;
 using MQTTnet.Server;
 
 namespace MQTTnet.Samples.Server;
 
 public static class Server_ASP_NET_Samples
 {
+    static readonly string unixSocketPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "mqtt.socks");
+
     public static Task Start_Server_With_WebSockets_Support()
     {
-        /*
-         * This sample starts a minimal ASP.NET Webserver including a hosted MQTT server.
-         */
-        var host = Host.CreateDefaultBuilder(Array.Empty<string>())
-            .ConfigureWebHostDefaults(
-                webBuilder =>
-                {
-                    webBuilder.UseKestrel(
-                        o =>
-                        {
-                            // This will allow MQTT connections based on TCP port 1883.
-                            o.ListenAnyIP(1883, l => l.UseMqtt());
-
-                            // This will allow MQTT connections based on HTTP WebSockets with URI "localhost:5000/mqtt"
-                            // See code below for URI configuration.
-                            o.ListenAnyIP(5000); // Default HTTP pipeline
-                        });
-
-                    webBuilder.UseStartup<Startup>();
-                });
-
-        return host.RunConsoleAsync();
+        File.Delete(unixSocketPath);
+
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddMqttServer(s => s.WithDefaultEndpoint().WithEncryptedEndpoint());
+        builder.Services.AddMqttClient();
+        builder.Services.AddHostedService<MqttClientController>();
+
+        builder.WebHost.UseKestrel(kestrel =>
+        {
+            // Need ConfigureMqttServer(s => ...) to enable the endpoints
+            kestrel.ListenMqtt();
+
+            // We can also manually listen to a specific port without ConfigureMqttServer()
+            kestrel.ListenUnixSocket(unixSocketPath, l => l.UseMqtt());
+            // kestrel.ListenAnyIP(1883, l => l.UseMqtt());  // mqtt over tcp          
+            // kestrel.ListenAnyIP(8883, l => l.UseHttps().UseMqtt());   // mqtt over tls over tcp
+        });
+
+        var app = builder.Build();
+        app.MapMqtt("/mqtt");
+        app.UseMqttServer<MqttServerController>();
+        return app.RunAsync();
     }
 
-    sealed class MqttController
+    sealed class MqttServerController
     {
-        public MqttController()
+        private readonly ILogger<MqttServerController> _logger;
+
+        public MqttServerController(
+            MqttServer mqttServer,
+            ILogger<MqttServerController> logger)
         {
-            // Inject other services via constructor.
+            _logger = logger;
+
+            mqttServer.ValidatingConnectionAsync += ValidateConnection;
+            mqttServer.ClientConnectedAsync += OnClientConnected;
         }
 
         public Task OnClientConnected(ClientConnectedEventArgs eventArgs)
         {
-            Console.WriteLine($"Client '{eventArgs.ClientId}' connected.");
+            _logger.LogInformation($"Client '{eventArgs.ClientId}' connected.");
             return Task.CompletedTask;
         }
 
-
         public Task ValidateConnection(ValidatingConnectionEventArgs eventArgs)
         {
-            Console.WriteLine($"Client '{eventArgs.ClientId}' wants to connect. Accepting!");
+            _logger.LogInformation($"Client '{eventArgs.ClientId}' wants to connect. Accepting!");
             return Task.CompletedTask;
         }
     }
 
-    sealed class Startup
+    sealed class MqttClientController : BackgroundService
     {
-        public void Configure(IApplicationBuilder app, IWebHostEnvironment environment, MqttController mqttController)
+        private readonly IMqttClientFactory _mqttClientFactory;
+
+        public MqttClientController(IMqttClientFactory mqttClientFactory)
         {
-            app.UseRouting();
-
-            app.UseEndpoints(
-                endpoints =>
-                {
-                    endpoints.MapConnectionHandler<MqttConnectionHandler>(
-                        "/mqtt",
-                        httpConnectionDispatcherOptions => httpConnectionDispatcherOptions.WebSockets.SubProtocolSelector =
-                            protocolList => protocolList.FirstOrDefault() ?? string.Empty);
-                });
-
-            app.UseMqttServer(
-                server =>
-                {
-                    /*
-                     * Attach event handlers etc. if required.
-                     */
-
-                    server.ValidatingConnectionAsync += mqttController.ValidateConnection;
-                    server.ClientConnectedAsync += mqttController.OnClientConnected;
-                });
+            _mqttClientFactory = mqttClientFactory;
         }
 
-        public void ConfigureServices(IServiceCollection services)
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
-            services.AddHostedMqttServer(
-                optionsBuilder =>
-                {
-                    optionsBuilder.WithDefaultEndpoint();
-                });
+            await Task.Delay(1000);
+            using var client = _mqttClientFactory.CreateMqttClient();
+
+            // var mqttUri = "mqtt://localhost:1883";
+            // var mqttsUri = "mqtts://localhost:8883";
+            // var wsMqttUri = "ws://localhost:1883/mqtt";
+            var wssMqttUri = "wss://localhost:8883/mqtt";
 
-            services.AddMqttConnectionHandler();
-            services.AddConnections();
+            var options = new MqttClientOptionsBuilder()
+                //.WithEndPoint(new UnixDomainSocketEndPoint(unixSocketPath))
+                .WithConnectionUri(wssMqttUri)
+                .Build();
 
-            services.AddSingleton<MqttController>();
+            await client.ConnectAsync(options, stoppingToken);
+            await client.DisconnectAsync();
         }
     }
 }

Source/MQTTnet.AspTestApp/MQTTnet.AspTestApp.csproj

@@ -13,7 +13,7 @@
         <NuGetAuditMode>all</NuGetAuditMode>
         <NuGetAudit>true</NuGetAudit>
         <NuGetAuditLevel>low</NuGetAuditLevel>
-        <AnalysisLevel>latest-Recommended</AnalysisLevel>
+        <!--<AnalysisLevel>latest-Recommended</AnalysisLevel>-->
     </PropertyGroup>
 
     <ItemGroup>

Source/MQTTnet.AspTestApp/Program.cs

@@ -11,11 +11,15 @@
 builder.Services.AddRazorPages();
 
 // Setup MQTT stuff.
-builder.Services.AddMqttServer();
-builder.Services.AddConnections();
+builder.Services.AddMqttServer(s => s.WithDefaultEndpoint().WithDefaultEndpointPort(5000));
 
-var app = builder.Build();
+// ListenMqtt 
+builder.WebHost.UseKestrel(kestrel =>
+{
+    kestrel.ListenMqtt(MqttProtocols.WebSocket);
+});
 
+var app = builder.Build();
 if (!app.Environment.IsDevelopment())
 {
     app.UseExceptionHandler("/Error");
@@ -29,7 +33,7 @@
 
 app.MapRazorPages();
 
-// Setup MQTT stuff.
+// mqtt over websocket
 app.MapMqtt("/mqtt");
 
 app.UseMqttServer(server =>

Source/MQTTnet.AspTestApp/appsettings.json

@@ -1,4 +1,4 @@
-{
+{ 
   "Logging": {
     "LogLevel": {
       "Default": "Information",

Source/MQTTnet.AspnetCore/ApplicationBuilderExtensions.cs

@@ -2,52 +2,39 @@
 // 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 Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using MQTTnet.Server;
+using System;
+using System.Diagnostics.CodeAnalysis;
 
 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;
-    }
-
+    /// <summary>
+    /// Get and use <see cref="MqttServer"/>
+    /// </summary>
+    /// <remarks>Also, you can inject <see cref="MqttServer"/> into your service</remarks>
+    /// <param name="app"></param>
+    /// <param name="configure"></param>
+    /// <returns></returns>
     public static IApplicationBuilder UseMqttServer(this IApplicationBuilder app, Action<MqttServer> configure)
     {
         var server = app.ApplicationServices.GetRequiredService<MqttServer>();
-
         configure(server);
+        return app;
+    }
 
+    /// <summary>
+    /// Active MqttServer's wrapper service
+    /// </summary>
+    /// <typeparam name="TMQttServerWrapper"></typeparam>
+    /// <param name="app"></param>
+    /// <returns></returns>
+    public static IApplicationBuilder UseMqttServer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TMQttServerWrapper>(this IApplicationBuilder app)
+    {
+        ActivatorUtilities.GetServiceOrCreateInstance<TMQttServerWrapper>(app.ApplicationServices);
         return app;
     }
 }

Source/MQTTnet.AspnetCore/AspNetCoreMqttNetLoggerOptions.cs

@@ -0,0 +1,29 @@
+// 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.Extensions.Logging;
+using MQTTnet.Diagnostics.Logger;
+using System;
+
+namespace MQTTnet.AspNetCore
+{
+    public sealed class AspNetCoreMqttNetLoggerOptions
+    {
+        public string? CategoryNamePrefix { get; set; } = "MQTTnet.AspNetCore.";
+
+        public Func<MqttNetLogLevel, LogLevel> LogLevelConverter { get; set; } = ConvertLogLevel;
+
+        private static LogLevel ConvertLogLevel(MqttNetLogLevel level)
+        { 
+            return level switch
+            {
+                MqttNetLogLevel.Verbose => LogLevel.Trace,
+                MqttNetLogLevel.Info => LogLevel.Information,
+                MqttNetLogLevel.Warning => LogLevel.Warning,
+                MqttNetLogLevel.Error => LogLevel.Error,
+                _ => LogLevel.None
+            };
+        }
+    }
+}

Source/MQTTnet.AspnetCore/ConnectionBuilderExtensions.cs

@@ -3,14 +3,27 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.AspNetCore.Connections;
+using Microsoft.Extensions.DependencyInjection;
+using MQTTnet.Server;
 
 namespace MQTTnet.AspNetCore
 {
     public static class ConnectionBuilderExtensions
     {
-        public static IConnectionBuilder UseMqtt(this IConnectionBuilder builder)
+        /// <summary>
+        /// Handle the connection using the specified MQTT protocols
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <param name="protocols"></param>
+        /// <returns></returns>
+        public static IConnectionBuilder UseMqtt(this IConnectionBuilder builder, MqttProtocols protocols = MqttProtocols.MqttAndWebSocket)
         {
-            return builder.UseConnectionHandler<MqttConnectionHandler>();
+            // check services.AddMqttServer()
+            builder.ApplicationServices.GetRequiredService<MqttServer>();
+            builder.ApplicationServices.GetRequiredService<MqttConnectionHandler>().UseFlag = true;
+
+            var middleware = builder.ApplicationServices.GetRequiredService<MqttConnectionMiddleware>();
+            return builder.Use(next => context => middleware.InvokeAsync(next, context, protocols));
         }
     }
 }