Add IUnhandledExceptionHandler and a default implementation in Hosting.CLI (#192)

Author: TheConstructor

src/CommandLineUtils/Conventions/ExecuteMethodConvention.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Reflection;
+using System.Runtime.ExceptionServices;
 using System.Threading.Tasks;
 
 namespace McMaster.Extensions.CommandLineUtils.Conventions
@@ -71,22 +72,37 @@ private async Task<int> OnExecute(ConventionContext context)
 
         private async Task<int> InvokeAsync(MethodInfo method, object instance, object[] arguments)
         {
-            var result = (Task)method.Invoke(instance, arguments);
-            if (result is Task<int> intResult)
+            try
+            {
+                var result = (Task) method.Invoke(instance, arguments);
+                if (result is Task<int> intResult)
+                {
+                    return await intResult;
+                }
+
+                await result;
+            }
+            catch (TargetInvocationException e)
             {
-                return await intResult;
+                ExceptionDispatchInfo.Capture(e.InnerException).Throw();
             }
 
-            await result;
             return 0;
         }
 
         private int Invoke(MethodInfo method, object instance, object[] arguments)
         {
-            var result = method.Invoke(instance, arguments);
-            if (method.ReturnType == typeof(int))
+            try
+            {
+                var result = method.Invoke(instance, arguments);
+                if (method.ReturnType == typeof(int))
+                {
+                    return (int) result;
+                }
+            }
+            catch (TargetInvocationException e)
             {
-                return (int)result;
+                ExceptionDispatchInfo.Capture(e.InnerException).Throw();
             }
 
             return 0;

src/Hosting.CommandLine/HostBuilderExtensions.cs

@@ -1,10 +1,12 @@
 // Copyright (c) Nate McMaster.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 using McMaster.Extensions.CommandLineUtils;
 using McMaster.Extensions.CommandLineUtils.Abstractions;
+using McMaster.Extensions.Hosting.CommandLine;
 using McMaster.Extensions.Hosting.CommandLine.Internal;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -31,11 +33,14 @@ public static async Task<int> RunCommandLineApplicationAsync<TApp>(
             this IHostBuilder hostBuilder, string[] args, CancellationToken cancellationToken = default)
             where TApp : class
         {
+            var exceptionHandler = new StoreExceptionHandler();
             var state = new CommandLineState(args);
             hostBuilder.ConfigureServices(
                 (context, services)
                     =>
                 {
+                    services
+                        .TryAddSingleton<IUnhandledExceptionHandler>(exceptionHandler);
                     services
                         .AddSingleton<IHostLifetime, CommandLineLifetime>()
                         .TryAddSingleton(PhysicalConsole.Singleton);
@@ -53,6 +58,11 @@ public static async Task<int> RunCommandLineApplicationAsync<TApp>(
             {
                 await host.RunAsync(cancellationToken);
 
+                if (exceptionHandler.StoredException != null)
+                {
+                    ExceptionDispatchInfo.Capture(exceptionHandler.StoredException).Throw();
+                }
+
                 return state.ExitCode;
             }
         }

src/Hosting.CommandLine/IUnhandledExceptionHandler.cs

@@ -0,0 +1,19 @@
+using System;
+using McMaster.Extensions.CommandLineUtils;
+using McMaster.Extensions.Hosting.CommandLine.Internal;
+
+namespace McMaster.Extensions.Hosting.CommandLine
+{
+    /// <summary>
+    /// Used by <see cref="CommandLineLifetime"/> to handle exceptions that are emitted from the
+    /// <see cref="CommandLineApplication{TModel}"/> e.g. during parsing or execution
+    /// </summary>
+    public interface IUnhandledExceptionHandler
+    {
+        /// <summary>
+        /// Handle otherwise uncaught exception. You are free to log, rethrow, … the exception 
+        /// </summary>
+        /// <param name="e">An otherwise uncaught exception</param>
+        void HandleException(Exception e);
+    }
+}

src/Hosting.CommandLine/Internal/CommandLineLifetime.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 using McMaster.Extensions.CommandLineUtils;
@@ -18,18 +19,21 @@ internal class CommandLineLifetime : IHostLifetime, IDisposable
         private readonly IApplicationLifetime _applicationLifetime;
         private readonly ICommandLineService _cliService;
         private readonly IConsole _console;
+        private readonly IUnhandledExceptionHandler _unhandledExceptionHandler;
         private readonly ManualResetEvent _disposeComplete = new ManualResetEvent(false);
 
         /// <summary>
         ///     Creates a new instance.
         /// </summary>
         public CommandLineLifetime(IApplicationLifetime applicationLifetime,
             ICommandLineService cliService,
-            IConsole console)
+            IConsole console,
+            IUnhandledExceptionHandler unhandledExceptionHandler)
         {
             _applicationLifetime = applicationLifetime;
             _cliService = cliService;
             _console = console;
+            _unhandledExceptionHandler = unhandledExceptionHandler;
         }
 
         /// <summary>The exit code returned by the command line application</summary>
@@ -56,7 +60,22 @@ public Task WaitForStartAsync(CancellationToken cancellationToken)
         {
             _applicationLifetime.ApplicationStarted.Register(async () =>
             {
-                ExitCode = await _cliService.RunAsync(cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    ExitCode = await _cliService.RunAsync(cancellationToken).ConfigureAwait(false);
+                }
+                catch (Exception e)
+                {
+                    if (_unhandledExceptionHandler != null)
+                    {
+                        _unhandledExceptionHandler.HandleException(e);
+                    }
+                    else
+                    {
+                        ExceptionDispatchInfo.Capture(e).Throw();
+                    }
+                }
+
                 _applicationLifetime.StopApplication();
             });
 

src/Hosting.CommandLine/Internal/StoreExceptionHandler.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace McMaster.Extensions.Hosting.CommandLine.Internal
+{
+    /// <summary>
+    /// Implementation of <see cref="IUnhandledExceptionHandler"/> that stores an unhandled exception so it can later be
+    /// rethrown by <see cref="CommandLineService{T}"/>.
+    /// </summary>
+    internal class StoreExceptionHandler : IUnhandledExceptionHandler
+    {
+        /// <summary>
+        /// The captured exception, if any
+        /// </summary>
+        public Exception StoredException { get; private set; }
+
+        /// <summary>
+        /// This will store the first unhandled exception and throw an <see cref="AggregateException"/> if called a
+        /// second time.
+        /// </summary>
+        /// <param name="e">The unhandled exception to store</param>
+        /// <exception cref="AggregateException">If called a second time an <see cref="AggregateException"/> containing
+        /// both exceptions is raised</exception>
+        public void HandleException(Exception e)
+        {
+            if (StoredException != null)
+            {
+                throw new AggregateException("Second exception received!", StoredException, e);
+            }
+
+            StoredException = e;
+        }
+    }
+}

test/Hosting.CommandLine.Tests/HostBuilderExtensionsTests.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using McMaster.Extensions.CommandLineUtils;
 using McMaster.Extensions.CommandLineUtils.Conventions;
 using McMaster.Extensions.Hosting.CommandLine.Tests.Utilities;
@@ -61,6 +62,31 @@ public async void TestConventionInjection()
             Mock.Verify(convention);
         }
 
+        [Fact]
+        public void ItThrowsOnUnknownSubCommand()
+        {
+            var ex = Assert.Throws<UnrecognizedCommandParsingException>(
+                () => new HostBuilder()
+                    .ConfigureServices(collection => collection.AddSingleton<IConsole>(new TestConsole(_output)))
+                    .RunCommandLineApplicationAsync<ParentCommand>(new string[] {"return41"})
+                    .GetAwaiter()
+                    .GetResult());
+            Assert.Equal(new string[] {"return42"}, ex.NearestMatches);
+        }
+
+        [Fact]
+        public void ItRethrowsThrownExceptions()
+        {
+            var ex = Assert.Throws<InvalidOperationException>(
+                () => new HostBuilder()
+                    .ConfigureServices(collection => collection.AddSingleton<IConsole>(new TestConsole(_output)))
+                    .RunCommandLineApplicationAsync<ThrowsExceptionCommand>(new string[0])
+                    .GetAwaiter()
+                    .GetResult());
+            Assert.Equal("A test", ex.Message);
+        }
+
+        [Command]
         public class Return42Command
         {
             private int OnExecute()
@@ -69,6 +95,7 @@ private int OnExecute()
             }
         }
 
+        [Command]
         public class Write42Command
         {
             private void OnExecute(CommandLineApplication<Write42Command> app)
@@ -102,5 +129,20 @@ private void OnExecute(CommandLineApplication<CaptureRemainingArgsCommand> app)
             {
             }
         }
+
+        [Command]
+        [Subcommand(typeof(Return42Command))]
+        class ParentCommand
+        {
+        }
+
+        [Command]
+        class ThrowsExceptionCommand
+        {
+            private int OnExecute()
+            {
+                throw new InvalidOperationException("A test");
+            }
+        }
     }
 }