System.CommandLine update

src/NServiceBus.Transport.RabbitMQ.CommandLine.Tests/MigrateQueue/QueueMigrateToQuorumTests.cs

@@ -2,7 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
-    using System.CommandLine.IO;
+    using System.IO;
     using System.Threading;
     using System.Threading.Tasks;
     using global::RabbitMQ.Client;
@@ -308,7 +308,9 @@ public async Task TearDown()
 
         Task ExecuteMigration(string endpointName)
         {
-            var migrationCommand = new QueueMigrateCommand(endpointName, brokerConnection, new TestConsole());
+            var output = new StringWriter();
+
+            var migrationCommand = new QueueMigrateCommand(endpointName, brokerConnection, output);
 
             return migrationCommand.Run();
         }

src/NServiceBus.Transport.RabbitMQ.CommandLine/BrokerConnectionBinder.cs

@@ -1,24 +1,23 @@
 namespace NServiceBus.Transport.RabbitMQ.CommandLine
 {
     using System.CommandLine;
-    using System.CommandLine.Binding;
     using System.Security.Cryptography.X509Certificates;
     using NServiceBus.Transport.RabbitMQ.ManagementApi;
 
     class BrokerConnectionBinder(Option<string> connectionStringOption, Option<string> connectionStringEnvOption, Option<string> managementApiUrlOption, Option<string> managementApiUserNameOption, Option<string> managementApiPasswordOption, Option<string> certPathOption,
-        Option<string> certPassphraseOption, Option<bool> disableCertificateValidationOption, Option<bool> useExternalAuthOption) : BinderBase<BrokerConnection>
+        Option<string> certPassphraseOption, Option<bool> disableCertificateValidationOption, Option<bool> useExternalAuthOption)
     {
-        protected override BrokerConnection GetBoundValue(BindingContext bindingContext)
+        public BrokerConnection CreateBrokerConnection(ParseResult parseResult)
         {
-            var connectionStringOptionValue = bindingContext.ParseResult.GetValueForOption(connectionStringOption);
-            var connectionStringEnvOptionValue = bindingContext.ParseResult.GetValueForOption(connectionStringEnvOption);
-            var managementApiUrl = bindingContext.ParseResult.GetValueForOption(managementApiUrlOption);
-            var managementApiUserName = bindingContext.ParseResult.GetValueForOption(managementApiUserNameOption);
-            var managementApiPassword = bindingContext.ParseResult.GetValueForOption(managementApiPasswordOption);
-            var certPath = bindingContext.ParseResult.GetValueForOption(certPathOption);
-            var certPassphrase = bindingContext.ParseResult.GetValueForOption(certPassphraseOption);
-            var disableCertificateValidation = bindingContext.ParseResult.GetValueForOption(disableCertificateValidationOption);
-            var useExternalAuth = bindingContext.ParseResult.GetValueForOption(useExternalAuthOption);
+            var connectionStringOptionValue = parseResult.GetValue(connectionStringOption);
+            var connectionStringEnvOptionValue = parseResult.GetValue(connectionStringEnvOption);
+            var managementApiUrl = parseResult.GetValue(managementApiUrlOption);
+            var managementApiUserName = parseResult.GetValue(managementApiUserNameOption);
+            var managementApiPassword = parseResult.GetValue(managementApiPasswordOption);
+            var certPath = parseResult.GetValue(certPathOption);
+            var certPassphrase = parseResult.GetValue(certPassphraseOption);
+            var disableCertificateValidation = parseResult.GetValue(disableCertificateValidationOption);
+            var useExternalAuth = parseResult.GetValue(useExternalAuthOption);
 
             var connectionString = GetConnectionString(connectionStringOptionValue, connectionStringEnvOptionValue);
 

src/NServiceBus.Transport.RabbitMQ.CommandLine/BrokerVerifierBinder.cs

@@ -1,19 +1,18 @@
 namespace NServiceBus.Transport.RabbitMQ.CommandLine
 {
     using System.CommandLine;
-    using System.CommandLine.Binding;
     using NServiceBus.Transport.RabbitMQ.ManagementApi;
 
-    class BrokerVerifierBinder(Option<string> connectionStringOption, Option<string> connectionStringEnvOption, Option<string> managementApiUrlOption, Option<string> managementApiUserNameOption, Option<string> managementApiPasswordOption, Option<bool> disableCertificateValidationOption) : BinderBase<BrokerVerifier>
+    class BrokerVerifierBinder(Option<string> connectionStringOption, Option<string> connectionStringEnvOption, Option<string> managementApiUrlOption, Option<string> managementApiUserNameOption, Option<string> managementApiPasswordOption, Option<bool> disableCertificateValidationOption)
     {
-        protected override BrokerVerifier GetBoundValue(BindingContext bindingContext)
+        public BrokerVerifier CreateBrokerVerifier(ParseResult parseResult)
         {
-            var connectionStringOptionValue = bindingContext.ParseResult.GetValueForOption(connectionStringOption);
-            var connectionStringEnvOptionValue = bindingContext.ParseResult.GetValueForOption(connectionStringEnvOption);
-            var managementApiUrl = bindingContext.ParseResult.GetValueForOption(managementApiUrlOption);
-            var managementApiUserName = bindingContext.ParseResult.GetValueForOption(managementApiUserNameOption);
-            var managementApiPassword = bindingContext.ParseResult.GetValueForOption(managementApiPasswordOption);
-            var disableCertificateValidation = bindingContext.ParseResult.GetValueForOption(disableCertificateValidationOption);
+            var connectionStringOptionValue = parseResult.GetValue(connectionStringOption);
+            var connectionStringEnvOptionValue = parseResult.GetValue(connectionStringEnvOption);
+            var managementApiUrl = parseResult.GetValue(managementApiUrlOption);
+            var managementApiUserName = parseResult.GetValue(managementApiUserNameOption);
+            var managementApiPassword = parseResult.GetValue(managementApiPasswordOption);
+            var disableCertificateValidation = parseResult.GetValue(disableCertificateValidationOption);
 
             var connectionString = GetConnectionString(connectionStringOptionValue, connectionStringEnvOptionValue);
 

src/NServiceBus.Transport.RabbitMQ.CommandLine/Commands/Delays/DelaysCreateCommand.cs

@@ -1,44 +1,37 @@
 namespace NServiceBus.Transport.RabbitMQ.CommandLine
 {
     using System.CommandLine;
+    using System.Threading;
 
-    class DelaysCreateCommand
+    class DelaysCreateCommand(BrokerConnection brokerConnection, TextWriter output)
     {
         public static Command CreateCommand()
         {
             var command = new Command("create", "Create v2 delay infrastructure queues and exchanges");
 
             var brokerConnectionBinder = SharedOptions.CreateBrokerConnectionBinderWithOptions(command);
 
-            command.SetHandler(async (brokerConnection, console, cancellationToken) =>
+            command.SetAction(async (parseResult, cancellationToken) =>
             {
-                var delaysCreate = new DelaysCreateCommand(brokerConnection, console);
+                var brokerConnection = brokerConnectionBinder.CreateBrokerConnection(parseResult);
+
+                var delaysCreate = new DelaysCreateCommand(brokerConnection, parseResult.Configuration.Output);
                 await delaysCreate.Run(cancellationToken);
-            },
-            brokerConnectionBinder, Bind.FromServiceProvider<IConsole>(), Bind.FromServiceProvider<CancellationToken>());
+            });
 
             return command;
         }
 
-        public DelaysCreateCommand(BrokerConnection brokerConnection, IConsole console)
-        {
-            this.brokerConnection = brokerConnection;
-            this.console = console;
-        }
-
         public async Task Run(CancellationToken cancellationToken = default)
         {
-            console.WriteLine($"Creating v2 delay infrastructure queues and exchanges...");
+            output.WriteLine($"Creating v2 delay infrastructure queues and exchanges...");
 
             using var connection = await brokerConnection.Create(cancellationToken);
             using var channel = await connection.CreateChannelAsync(cancellationToken: cancellationToken);
 
             await DelayInfrastructure.Build(channel, cancellationToken);
 
-            console.WriteLine("Queues and exchanges created successfully");
+            output.WriteLine("Queues and exchanges created successfully");
         }
-
-        readonly BrokerConnection brokerConnection;
-        readonly IConsole console;
     }
 }

src/NServiceBus.Transport.RabbitMQ.CommandLine/Commands/Delays/DelaysMigrateCommand.cs

@@ -7,7 +7,7 @@
     using System.Threading.Tasks;
     using global::RabbitMQ.Client;
 
-    class DelaysMigrateCommand(BrokerConnection brokerConnection, IRoutingTopology routingTopology, IConsole console)
+    class DelaysMigrateCommand(BrokerConnection brokerConnection, IRoutingTopology routingTopology, TextWriter output)
     {
         const string poisonMessageQueue = "delays-migrate-poison-messages";
         const string timeSentHeader = "NServiceBus.TimeSent";
@@ -21,21 +21,23 @@ public static Command CreateCommand()
             var brokerConnectionBinder = SharedOptions.CreateBrokerConnectionBinderWithOptions(command);
 
             var routingTopologyTypeOption = SharedOptions.CreateRoutingTopologyTypeOption();
-            command.AddOption(routingTopologyTypeOption);
+            command.Options.Add(routingTopologyTypeOption);
 
-            command.SetHandler(async (brokerConnection, routingTopologyType, console, cancellationToken) =>
+            command.SetAction(async (parseResult, cancellationToken) =>
             {
+                var brokerConnection = brokerConnectionBinder.CreateBrokerConnection(parseResult);
+                var routingTopologyType = parseResult.GetValue(routingTopologyTypeOption);
+
                 IRoutingTopology routingTopology = routingTopologyType switch
                 {
                     RoutingTopologyType.Conventional => new ConventionalRoutingTopology(true, QueueType.Quorum),
                     RoutingTopologyType.Direct => new DirectRoutingTopology(true, QueueType.Quorum),
                     _ => throw new InvalidOperationException()
                 };
 
-                var delaysMigrate = new DelaysMigrateCommand(brokerConnection, routingTopology, console);
+                var delaysMigrate = new DelaysMigrateCommand(brokerConnection, routingTopology, parseResult.Configuration.Output);
                 await delaysMigrate.Run(cancellationToken);
-            },
-            brokerConnectionBinder, routingTopologyTypeOption, Bind.FromServiceProvider<IConsole>(), Bind.FromServiceProvider<CancellationToken>());
+            });
 
             return command;
         }
@@ -60,7 +62,7 @@ async Task MigrateQueue(IChannel channel, int delayLevel, CancellationToken canc
 
             if (messageCount > 0)
             {
-                console.Write($"Processing {messageCount} messages at delay level {delayLevel:00}. ");
+                output.Write($"Processing {messageCount} messages at delay level {delayLevel:00}. ");
 
                 int skippedMessages = 0;
                 int processedMessages = 0;
@@ -132,11 +134,11 @@ async Task MigrateQueue(IChannel channel, int delayLevel, CancellationToken canc
                     processedMessages++;
                 }
 
-                console.WriteLine($"{processedMessages} successful, {skippedMessages} skipped.");
+                output.WriteLine($"{processedMessages} successful, {skippedMessages} skipped.");
             }
             else
             {
-                console.WriteLine($"No messages to process at delay level {delayLevel:00}.");
+                output.WriteLine($"No messages to process at delay level {delayLevel:00}.");
             }
         }
 

src/NServiceBus.Transport.RabbitMQ.CommandLine/Commands/Delays/DelaysVerifyCommand.cs

@@ -3,20 +3,21 @@
     using System;
     using System.CommandLine;
 
-    class DelaysVerifyCommand(BrokerVerifier brokerVerifier, IConsole console)
+    class DelaysVerifyCommand(BrokerVerifier brokerVerifier, TextWriter output)
     {
         public static Command CreateCommand()
         {
             var command = new Command("verify", "Verify broker requirements for using the v2 delay infrastructure");
 
             var brokerVerifierBinder = SharedOptions.CreateBrokerVerifierBinderWithOptions(command);
 
-            command.SetHandler(async (brokerVerifier, console, cancellationToken) =>
+            command.SetAction(async (parseResult, cancellationToken) =>
             {
-                var delaysVerify = new DelaysVerifyCommand(brokerVerifier, console);
+                var brokerVerifier = brokerVerifierBinder.CreateBrokerVerifier(parseResult);
+
+                var delaysVerify = new DelaysVerifyCommand(brokerVerifier, parseResult.Configuration.Output);
                 await delaysVerify.Run(cancellationToken);
-            },
-            brokerVerifierBinder, Bind.FromServiceProvider<IConsole>(), Bind.FromServiceProvider<CancellationToken>());
+            });
 
             return command;
         }
@@ -28,11 +29,11 @@ public async Task Run(CancellationToken cancellationToken = default)
                 await brokerVerifier.Initialize(cancellationToken);
                 await brokerVerifier.VerifyRequirements(cancellationToken);
 
-                console.WriteLine("All checks OK");
+                output.WriteLine("All checks OK");
             }
             catch (Exception ex) when (!ex.IsCausedBy(cancellationToken))
             {
-                console.WriteLine($"Fail: {ex.Message}");
+                output.WriteLine($"Fail: {ex.Message}");
             }
         }
     }