#82 - Improve error handling mechanics.

src/Microsoft.AspNet.Security/Infrastructure/AuthenticationHandler.cs

@@ -60,6 +60,8 @@ namespace Microsoft.AspNet.Security.Infrastructure
 
         public IAuthenticationHandler PriorHandler { get; set; }
 
+        public bool Faulted { get; set; }
+
         protected async Task BaseInitializeAsync(AuthenticationOptions options, HttpContext context)
         {
             _baseOptions = options;
@@ -98,8 +100,25 @@ namespace Microsoft.AspNet.Security.Infrastructure
         /// </summary>
         /// <returns>async completion</returns>
         internal async Task TeardownAsync()
+        {
+            try
             {
                 await ApplyResponseAsync();
+            }
+            catch (Exception)
+            {
+                try
+                {
+                    await TeardownCoreAsync();
+                }
+                catch (Exception)
+                {
+                    // Don't mask the original exception
+                }
+                UnregisterAuthenticationHandler();
+                throw;
+            }
+
             await TeardownCoreAsync();
             UnregisterAuthenticationHandler();
         }
@@ -216,6 +235,13 @@ namespace Microsoft.AspNet.Security.Infrastructure
         }
 
         private void ApplyResponse()
+        {
+            // If ApplyResponse already failed in the OnSendingHeaderCallback or TeardownAsync code path then a
+            // failed task is cached. If called again the same error will be re-thrown. This breaks error handling
+            // scenarios like the ability to display the error page or re-execute the request.
+            try
+            {
+                if (!Faulted)
                 {
                     LazyInitializer.EnsureInitialized(
                         ref _applyResponse,
@@ -227,6 +253,13 @@ namespace Microsoft.AspNet.Security.Infrastructure
                             return Task.FromResult(0);
                         }).GetAwaiter().GetResult(); // Block if the async version is in progress.
                 }
+            }
+            catch (Exception)
+            {
+                Faulted = true;
+                throw;
+            }
+        }
 
         protected virtual void ApplyResponseCore()
         {
@@ -240,14 +273,28 @@ namespace Microsoft.AspNet.Security.Infrastructure
         /// or later, as the last step when the original async call to the middleware is returning.
         /// </summary>
         /// <returns></returns>
-        private Task ApplyResponseAsync()
+        private async Task ApplyResponseAsync()
         {
-            return LazyInitializer.EnsureInitialized(
+            // If ApplyResponse already failed in the OnSendingHeaderCallback or TeardownAsync code path then a
+            // failed task is cached. If called again the same error will be re-thrown. This breaks error handling
+            // scenarios like the ability to display the error page or re-execute the request.
+            try
+            {
+                if (!Faulted)
+                {
+                    await LazyInitializer.EnsureInitialized(
                         ref _applyResponse,
                         ref _applyResponseInitialized,
                         ref _applyResponseSyncLock,
                         ApplyResponseCoreAsync);
                 }
+            }
+            catch (Exception)
+            {
+                Faulted = true;
+                throw;
+            }
+        }
 
         /// <summary>
         /// Core method that may be overridden by handler. The default behavior is to call two common response 

src/Microsoft.AspNet.Security/Infrastructure/AuthenticationMiddleware.cs

@@ -41,10 +41,26 @@ namespace Microsoft.AspNet.Security.Infrastructure
             {
                 AuthenticationHandler<TOptions> handler = CreateHandler();
                 await handler.Initialize(Options, context);
+                try
+                {
                     if (!await handler.InvokeAsync())
                     {
                         await _next(context);
                     }
+                }
+                catch (Exception)
+                {
+                    try
+                    {
+                        handler.Faulted = true;
+                        await handler.TeardownAsync();
+                    }
+                    catch (Exception)
+                    {
+                        // Don't mask the original exception
+                    }
+                    throw;
+                }
                 await handler.TeardownAsync();
             }
         }