Gracefully handle cancelled instant search requests (loic-sharma#383)

Adds a middleware to swallow cancellation exceptions due to instant searching.
Swallows frontend errors caused by instant searching.

Part of loic-sharma#354

Author: loic-sharma

src/BaGet.Core.Server/Extensions/IApplicationBuilderExtensions.cs

@@ -0,0 +1,15 @@
+using System;
+using Microsoft.AspNetCore.Builder;
+
+namespace BaGet.Core.Server.Extensions
+{
+    public static class IApplicationBuilderExtensions
+    {
+        public static IApplicationBuilder UseOperationCancelledMiddleware(this IApplicationBuilder app)
+        {
+            if (app == null) throw new ArgumentNullException(nameof(app));
+
+            return app.UseMiddleware<OperationCancelledMiddleware>();
+        }
+    }
+}

src/BaGet.Core.Server/OperationCancelledMiddleware.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+
+namespace BaGet
+{
+    /// <summary>
+    /// Captures <see cref="OperationCanceledException" /> and converts to HTTP 409 response.
+    /// Based off: https://github.com/aspnet/AspNetCore/blob/28157e62597bf0e043bc7e937e44c5ec81946b83/src/Middleware/Diagnostics/src/DeveloperExceptionPage/DeveloperExceptionPageMiddleware.cs
+    /// </summary>
+    public class OperationCancelledMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly ILogger<OperationCancelledMiddleware> _logger;
+
+        public OperationCancelledMiddleware(RequestDelegate next, ILogger<OperationCancelledMiddleware> logger)
+        {
+            _next = next ?? throw new ArgumentNullException(nameof(next));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            try
+            {
+                await _next(context);
+            }
+            catch (Exception e) when (ShouldHandleException(context, e))
+            {
+                try
+                {
+                    _logger.LogWarning("Request cancelled");
+
+                    context.Response.Clear();
+                    context.Response.StatusCode = (int)HttpStatusCode.Conflict;
+                    return;
+                }
+                catch (Exception)
+                {
+                    // If there's an exception, rethrow the original exception.
+                }
+
+                throw;
+            }
+
+            bool ShouldHandleException(HttpContext ctx, Exception e)
+            {
+                if (ctx.Response.HasStarted) return false;
+
+                if (e is OperationCanceledException) return true;
+                if (e.InnerException is OperationCanceledException) return true;
+
+                return false;
+            }
+        }
+    }
+}

src/BaGet.UI/src/SearchResults.tsx

@@ -217,15 +217,27 @@ class SearchResults extends React.Component<ISearchResultsProps, ISearchResultsS
     const url = this.buildUrl(query, includePrerelease, packageType, targetFramework);
 
     fetch(url, {signal: this.resultsController.signal}).then(response => {
-      return response.json();
+      return response.ok
+        ? response.json()
+        : null;
     }).then(resultsJson => {
+      if (!resultsJson) {
+        return;
+      }
+
       const results = resultsJson as ISearchResponse;
 
       this.setState({
         includePrerelease,
         items: results.data,
         targetFramework,
       });
+    })
+    .catch((e) => {
+      var ex = e as DOMException;
+      if (!ex || ex.code !== DOMException.ABORT_ERR) {
+        console.log("Unexpected error on search", e);
+      }
     });
   }
 

src/BaGet/Startup.cs

@@ -1,6 +1,7 @@
 using System;
 using BaGet.Configuration;
 using BaGet.Core;
+using BaGet.Core.Server.Extensions;
 using BaGet.Extensions;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -58,6 +59,7 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
             app.UseSpaStaticFiles();
 
             app.UseCors(ConfigureCorsOptions.CorsPolicy);
+            app.UseOperationCancelledMiddleware();
 
             app.UseMvc(routes =>
             {