Upgrade System.Commandline and add command line tests (#1700)

Author: JamesNK

build/dependencies.props

@@ -23,8 +23,8 @@
     <Nunit3TestAdapterPackageVersion>3.16.1</Nunit3TestAdapterPackageVersion>
     <OpenTelemetryPackageVersion>0.6.0-beta.1</OpenTelemetryPackageVersion>
     <ProtobufNetGrpcPackageVersion>1.0.140</ProtobufNetGrpcPackageVersion>
-    <SystemCommandLinePackageVersion>2.0.0-beta1.20214.1</SystemCommandLinePackageVersion>
-    <SystemCommandLineRenderingPackageVersion>0.3.0-alpha.20214.1</SystemCommandLineRenderingPackageVersion>
+    <SystemCommandLinePackageVersion>2.0.0-beta3.22114.1</SystemCommandLinePackageVersion>
+    <SystemCommandLineRenderingPackageVersion>0.4.0-alpha.22114.1</SystemCommandLineRenderingPackageVersion>
     <SystemDiagnosticsDiagnosticSourcePackageVersion>4.5.1</SystemDiagnosticsDiagnosticSourcePackageVersion>
     <SystemIOPipelinesPackageVersion>5.0.1</SystemIOPipelinesPackageVersion>
     <SystemMemoryPackageVersion>4.5.3</SystemMemoryPackageVersion>

perf/benchmarkapps/GrpcClient/ClientOptions.cs

@@ -22,7 +22,7 @@ namespace GrpcClient
 {
     public class ClientOptions
     {
-        public string? Url { get; set; }
+        public Uri? Url { get; set; }
 #if NET5_0_OR_GREATER
         public string? UdsFileName { get; set; }
 #endif

perf/benchmarkapps/GrpcClient/Program.cs

@@ -17,6 +17,7 @@
 #endregion
 
 using System.CommandLine;
+using System.CommandLine.Binding;
 using System.CommandLine.Invocation;
 using System.Diagnostics;
 using System.Globalization;
@@ -58,29 +59,33 @@ class Program
 
         public static async Task<int> Main(string[] args)
         {
+            var options = new List<Option>();
+            options.Add(new Option<Uri>(new string[] { "-u", "--url" }, "The server url to request") { IsRequired = true });
+            options.Add(new Option<string>(new string[] { "--udsFileName" }, "The Unix Domain Socket file name"));
+            options.Add(new Option<int>(new string[] { "-c", "--connections" }, () => 1, "Total number of connections to keep open"));
+            options.Add(new Option<int>(new string[] { "-w", "--warmup" }, () => 5, "Duration of the warmup in seconds"));
+            options.Add(new Option<int>(new string[] { "-d", "--duration" }, () => 10, "Duration of the test in seconds"));
+            options.Add(new Option<int>(new string[] { "--callCount" }, "Call count of test"));
+            options.Add(new Option<string>(new string[] { "-s", "--scenario" }, "Scenario to run") { IsRequired = true });
+            options.Add(new Option<bool>(new string[] { "-l", "--latency" }, () => false, "Whether to collect detailed latency"));
+            options.Add(new Option<string>(new string[] { "-p", "--protocol" }, "HTTP protocol") { IsRequired = true });
+            options.Add(new Option<LogLevel>(new string[] { "-log", "--logLevel" }, () => LogLevel.None, "The log level to use for Console logging"));
+            options.Add(new Option<int>(new string[] { "--requestSize" }, "Request payload size"));
+            options.Add(new Option<int>(new string[] { "--responseSize" }, "Response payload size"));
+            options.Add(new Option<GrpcClientType>(new string[] { "--grpcClientType" }, () => GrpcClientType.GrpcNetClient, "Whether to use Grpc.NetClient or Grpc.Core client"));
+            options.Add(new Option<int>(new string[] { "--streams" }, () => 1, "Maximum concurrent streams per connection"));
+            options.Add(new Option<bool>(new string[] { "--enableCertAuth" }, () => false, "Flag indicating whether client sends a client certificate"));
+            options.Add(new Option<int>(new string[] { "--deadline" }, "Duration of deadline in seconds"));
+
             var rootCommand = new RootCommand();
-            rootCommand.AddOption(new Option<string>(new string[] { "-u", "--url" }, "The server url to request") { Required = true });
-            rootCommand.AddOption(new Option<string>(new string[] { "--udsFileName" }, "The Unix Domain Socket file name"));
-            rootCommand.AddOption(new Option<int>(new string[] { "-c", "--connections" }, () => 1, "Total number of connections to keep open"));
-            rootCommand.AddOption(new Option<int>(new string[] { "-w", "--warmup" }, () => 5, "Duration of the warmup in seconds"));
-            rootCommand.AddOption(new Option<int>(new string[] { "-d", "--duration" }, () => 10, "Duration of the test in seconds"));
-            rootCommand.AddOption(new Option<int>(new string[] { "--callCount" }, "Call count of test"));
-            rootCommand.AddOption(new Option<string>(new string[] { "-s", "--scenario" }, "Scenario to run") { Required = true });
-            rootCommand.AddOption(new Option<bool>(new string[] { "-l", "--latency" }, () => false, "Whether to collect detailed latency"));
-            rootCommand.AddOption(new Option<string>(new string[] { "-p", "--protocol" }, "HTTP protocol") { Required = true });
-            rootCommand.AddOption(new Option<LogLevel>(new string[] { "-log", "--logLevel" }, () => LogLevel.None, "The log level to use for Console logging"));
-            rootCommand.AddOption(new Option<int>(new string[] { "--requestSize" }, "Request payload size"));
-            rootCommand.AddOption(new Option<int>(new string[] { "--responseSize" }, "Response payload size"));
-            rootCommand.AddOption(new Option<GrpcClientType>(new string[] { "--grpcClientType" }, () => GrpcClientType.GrpcNetClient, "Whether to use Grpc.NetClient or Grpc.Core client"));
-            rootCommand.AddOption(new Option<int>(new string[] { "--streams" }, () => 1, "Maximum concurrent streams per connection"));
-            rootCommand.AddOption(new Option<bool>(new string[] { "--enableCertAuth" }, () => false, "Flag indicating whether client sends a client certificate"));
-            rootCommand.AddOption(new Option<int>(new string[] { "--deadline" }, "Duration of deadline in seconds"));
-
-            rootCommand.Handler = CommandHandler.Create<ClientOptions>(async (options) =>
+            foreach (var option in options)
             {
-                _options = options;
+                rootCommand.AddOption(option);
+            }
 
-                Log("gRPC Client");
+            rootCommand.SetHandler<ClientOptions>(async (options) =>
+            {
+                _options = options;
 
                 var runtimeVersion = typeof(object).GetTypeInfo().Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion ?? "Unknown";
                 var isServerGC = GCSettings.IsServerGC;
@@ -103,11 +108,45 @@ public static async Task<int> Main(string[] args)
                 await StartScenario();
 
                 await StopJobAsync();
-            });
+            }, new ReflectionBinder<ClientOptions>(options));
+
+            Log("gRPC Client");
 
             return await rootCommand.InvokeAsync(args);
         }
 
+        private class ReflectionBinder<T> : BinderBase<T> where T : new()
+        {
+            private readonly List<Option> _options;
+
+            public ReflectionBinder(List<Option> options)
+            {
+                _options = options;
+            }
+
+            protected override T GetBoundValue(BindingContext bindingContext)
+            {
+                var boundValue = new T();
+
+                Log($"Binding {typeof(T)}");
+
+                foreach (var option in _options)
+                {
+                    var value = bindingContext.ParseResult.GetValueForOption(option);
+
+                    var propertyInfo = typeof(T).GetProperty(option.Name, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
+                    if (propertyInfo != null)
+                    {
+                        propertyInfo.SetValue(boundValue, value);
+                        
+                        Log($"-{propertyInfo.Name} = {value}");
+                    }
+                }
+
+                return boundValue;
+            }
+        }
+
         private static async Task StartScenario()
         {
             if (_options.CallCount == null)
@@ -354,7 +393,7 @@ private static void CreateChannels()
             }
 
             // Channel does not care about scheme
-            var initialUri = new Uri(_options.Url!);
+            var initialUri = _options.Url!;
             var resolvedUri = initialUri.Authority;
 
             Log($"gRPC client type: {_options.GrpcClientType}");

src/dotnet-grpc/Commands/AddFileCommand.cs

@@ -27,43 +27,49 @@ namespace Grpc.Dotnet.Cli.Commands
 {
     internal class AddFileCommand : CommandBase
     {
-        public AddFileCommand(IConsole console, FileInfo? projectPath)
-            : base(console, projectPath) { }
+        public AddFileCommand(IConsole console, string? projectPath, HttpClient httpClient)
+            : base(console, projectPath, httpClient) { }
 
-        public static Command Create()
+        public static Command Create(HttpClient httpClient)
         {
             var command = new Command(
                 name: "add-file",
                 description: CoreStrings.AddFileCommandDescription);
-            command.AddArgument(new Argument<string[]>
+
+            var projectOption = CommonOptions.ProjectOption();
+            var serviceOption = CommonOptions.ServiceOption();
+            var additionalImportDirsOption = CommonOptions.AdditionalImportDirsOption();
+            var accessOption = CommonOptions.AccessOption();
+            var filesArgument = new Argument<string[]>
             {
                 Name = "files",
                 Description = CoreStrings.AddFileCommandArgumentDescription,
                 Arity = ArgumentArity.OneOrMore
-            });
+            };
 
-            command.AddOption(CommonOptions.ProjectOption());
-            command.AddOption(CommonOptions.ServiceOption());
-            command.AddOption(CommonOptions.AdditionalImportDirsOption());
-            command.AddOption(CommonOptions.AccessOption());
+            command.AddOption(projectOption);
+            command.AddOption(serviceOption);
+            command.AddOption(accessOption);
+            command.AddOption(additionalImportDirsOption);
+            command.AddArgument(filesArgument);
 
-            command.Handler = CommandHandler.Create<IConsole, FileInfo, Services, Access, string?, string[]>(
-                async (console, project, services, access, additionalImportDirs, files) =>
+            command.SetHandler<string, Services, Access, string?, string[], InvocationContext, IConsole>(
+                async (project, services, access, additionalImportDirs, files, context, console) =>
                 {
                     try
                     {
-                        var command = new AddFileCommand(console, project);
+                        var command = new AddFileCommand(console, project, httpClient);
                         await command.AddFileAsync(services, access, additionalImportDirs, files);
 
-                        return 0;
+                        context.ExitCode = 0;
                     }
                     catch (CLIToolException e)
                     {
                         console.LogError(e);
 
-                        return -1;
+                        context.ExitCode = -1;
                     }
-                });
+                }, projectOption, serviceOption, accessOption, additionalImportDirsOption, filesArgument);
 
             return command;
         }

src/dotnet-grpc/Commands/AddUrlCommand.cs

@@ -26,37 +26,42 @@ namespace Grpc.Dotnet.Cli.Commands
 {
     internal class AddUrlCommand : CommandBase
     {
-        public AddUrlCommand(IConsole console, FileInfo? projectPath)
-            : base(console, projectPath) { }
+        public AddUrlCommand(IConsole console, string? projectPath, HttpClient httpClient)
+            : base(console, projectPath, httpClient) { }
 
         // Internal for testing
         internal AddUrlCommand(IConsole console, HttpClient client)
             : base(console, client) { }
 
-        public static Command Create()
+        public static Command Create(HttpClient httpClient)
         {
             var command = new Command(
                 name: "add-url",
                 description: CoreStrings.AddUrlCommandDescription);
-            command.AddArgument(new Argument<string>
+
+            var projectOption = CommonOptions.ProjectOption();
+            var serviceOption = CommonOptions.ServiceOption();
+            var additionalImportDirsOption = CommonOptions.AdditionalImportDirsOption();
+            var accessOption = CommonOptions.AccessOption();
+            var outputOption = new Option<string>(
+                aliases: new[] { "-o", "--output" },
+                description: CoreStrings.OutputOptionDescription);
+            var urlArgument = new Argument<string>
             {
                 Name = "url",
                 Description = CoreStrings.AddUrlCommandArgumentDescription,
                 Arity = ArgumentArity.ExactlyOne
-            });
+            };
 
-            var outputOption = new Option(
-                aliases: new[] { "-o", "--output" },
-                description: CoreStrings.OutputOptionDescription);
-            outputOption.Argument = new Argument<string> { Name = "path", Arity = ArgumentArity.ExactlyOne };
             command.AddOption(outputOption);
-            command.AddOption(CommonOptions.ProjectOption());
-            command.AddOption(CommonOptions.ServiceOption());
-            command.AddOption(CommonOptions.AdditionalImportDirsOption());
-            command.AddOption(CommonOptions.AccessOption());
-
-            command.Handler = CommandHandler.Create<IConsole, FileInfo, Services, Access, string?, string, string>(
-                async (console, project, services, access, additionalImportDirs, url, output) =>
+            command.AddOption(projectOption);
+            command.AddOption(serviceOption);
+            command.AddOption(additionalImportDirsOption);
+            command.AddOption(accessOption);
+            command.AddArgument(urlArgument);
+
+            command.SetHandler<string, Services, Access, string?, string, string, InvocationContext, IConsole>(
+                async (project, services, access, additionalImportDirs, url, output, context, console) =>
                 {
                     try
                     {
@@ -65,18 +70,18 @@ public static Command Create()
                             throw new CLIToolException(CoreStrings.ErrorNoOutputProvided);
                         }
 
-                        var command = new AddUrlCommand(console, project);
+                        var command = new AddUrlCommand(console, project, httpClient);
                         await command.AddUrlAsync(services, access, additionalImportDirs, url, output);
 
-                        return 0;
+                        context.ExitCode = 0;
                     }
                     catch (CLIToolException e)
                     {
                         console.LogError(e);
 
-                        return -1;
+                        context.ExitCode = -1;
                     }
-                });
+                }, projectOption, serviceOption, accessOption, additionalImportDirsOption, urlArgument, outputOption);
 
             return command;
         }

src/dotnet-grpc/Commands/CommandBase.cs

@@ -47,8 +47,8 @@ internal class CommandBase
 
         private readonly HttpClient _httpClient;
 
-        public CommandBase(IConsole console, FileInfo? projectPath)
-            : this(console, ResolveProject(projectPath), new HttpClient()) { }
+        public CommandBase(IConsole console, string? projectPath, HttpClient client)
+            : this(console, ResolveProject(projectPath), client) { }
 
         // Internal for testing
         internal CommandBase(IConsole console, Project project)
@@ -219,20 +219,29 @@ public void AddProtobufReference(Services services, string? additionalImportDirs
             }
         }
 
-        public static Project ResolveProject(FileInfo? project)
+        public static Project ResolveProject(string? project)
         {
             if (project != null)
             {
-                if (!File.Exists(project.FullName))
+                if (File.Exists(project))
                 {
-                    throw new CLIToolException(string.Format(CultureInfo.CurrentCulture, CoreStrings.ErrorProjectDoesNotExist, project.FullName));
+                    return new Project(project);
+                }
+                if (Directory.Exists(project))
+                {
+                    return LoadFromDirectoryPath(project);
                 }
 
-                return new Project(project.FullName);
+                throw new CLIToolException(string.Format(CultureInfo.CurrentCulture, CoreStrings.ErrorProjectDoesNotExist, project));
             }
 
             var currentDirectory = Directory.GetCurrentDirectory();
-            var projectFiles = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.csproj");
+            return LoadFromDirectoryPath(currentDirectory);
+        }
+
+        private static Project LoadFromDirectoryPath(string currentDirectory)
+        {
+            var projectFiles = Directory.GetFiles(currentDirectory, "*.csproj");
 
             if (projectFiles.Length == 0)
             {

src/dotnet-grpc/Commands/ListCommand.cs

@@ -29,33 +29,35 @@ namespace Grpc.Dotnet.Cli.Commands
 {
     internal class ListCommand : CommandBase
     {
-        public ListCommand(IConsole console, FileInfo? projectPath)
-            : base(console, projectPath) { }
+        public ListCommand(IConsole console, string? projectPath, HttpClient httpClient)
+            : base(console, projectPath, httpClient) { }
 
-        public static Command Create()
+        public static Command Create(HttpClient httpClient)
         {
             var command = new Command(
                 name: "list",
                 description: CoreStrings.ListCommandDescription);
-            command.AddOption(CommonOptions.ProjectOption());
+            var projectOption = CommonOptions.ProjectOption();
 
-            command.Handler = CommandHandler.Create<IConsole, FileInfo>(
-                (console, project) =>
+            command.AddOption(projectOption);
+
+            command.SetHandler<string, InvocationContext, IConsole>(
+                (project, context, console) =>
                 {
                     try
                     {
-                        var command = new ListCommand(console, project);
+                        var command = new ListCommand(console, project, httpClient);
                         command.List();
 
-                        return 0;
+                        context.ExitCode = 0;
                     }
                     catch (CLIToolException e)
                     {
                         console.LogError(e);
 
-                        return -1;
+                        context.ExitCode = -1;
                     }
-                });
+                }, projectOption);
 
             return command;
         }