allowing people to inject functions as custom middleware

src/Ocelot/Configuration/Provider/OcelotConfigurationProvider.cs

@@ -7,12 +7,12 @@ namespace Ocelot.Configuration.Provider
     /// <summary>
     /// Register as singleton
     /// </summary>
-    public class YamlOcelotConfigurationProvider : IOcelotConfigurationProvider
+    public class OcelotConfigurationProvider : IOcelotConfigurationProvider
     {
         private readonly IOcelotConfigurationRepository _repo;
         private readonly IOcelotConfigurationCreator _creator;
 
-        public YamlOcelotConfigurationProvider(IOcelotConfigurationRepository repo, 
+        public OcelotConfigurationProvider(IOcelotConfigurationRepository repo, 
             IOcelotConfigurationCreator creator)
         {
             _repo = repo;
@@ -21,28 +21,28 @@ namespace Ocelot.Configuration.Provider
 
         public Response<IOcelotConfiguration> Get()
         {
-            var config = _repo.Get();
+            var repoConfig = _repo.Get();
 
-            if (config.IsError)
+            if (repoConfig.IsError)
             {
-                return new ErrorResponse<IOcelotConfiguration>(config.Errors);
+                return new ErrorResponse<IOcelotConfiguration>(repoConfig.Errors);
             }
 
-            if (config.Data == null)
+            if (repoConfig.Data == null)
             {
-                var configuration = _creator.Create();
+                var creatorConfig = _creator.Create();
 
-                if (configuration.IsError)
+                if (creatorConfig.IsError)
                 {
-                    return new ErrorResponse<IOcelotConfiguration>(configuration.Errors);
+                    return new ErrorResponse<IOcelotConfiguration>(creatorConfig.Errors);
                 }
 
-                _repo.AddOrReplace(configuration.Data);
+                _repo.AddOrReplace(creatorConfig.Data);
 
-                return new OkResponse<IOcelotConfiguration>(configuration.Data);
+                return new OkResponse<IOcelotConfiguration>(creatorConfig.Data);
             }
 
-            return new OkResponse<IOcelotConfiguration>(config.Data);
+            return new OkResponse<IOcelotConfiguration>(repoConfig.Data);
         }
     }
 }

src/Ocelot/DependencyInjection/ServiceCollectionExtensions.cs

@@ -34,7 +34,7 @@ namespace Ocelot.DependencyInjection
 
             // ocelot services.
             services.AddSingleton<IOcelotConfigurationCreator, YamlOcelotConfigurationCreator>();
-            services.AddSingleton<IOcelotConfigurationProvider, YamlOcelotConfigurationProvider>();
+            services.AddSingleton<IOcelotConfigurationProvider, OcelotConfigurationProvider>();
             services.AddSingleton<IOcelotConfigurationRepository, InMemoryOcelotConfigurationRepository>();
             services.AddSingleton<IClaimToThingConfigurationParser, ClaimToThingConfigurationParser>();
             services.AddSingleton<IConfigurationValidator, ConfigurationValidator>();

src/Ocelot/Middleware/OcelotMiddlewareConfiguration.cs

@@ -0,0 +1,27 @@
+namespace Ocelot.Middleware
+{
+    using System;
+    using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Http;
+
+    public class OcelotMiddlewareConfiguration
+    {
+        public Func<HttpContext, Func<Task>, Task> PreHttpResponderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostHttpResponderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreDownstreamRouteFinderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostDownstreamRouteFinderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreAuthenticationMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostAuthenticationMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreClaimsBuilderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostClaimsBuilderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreAuthorisationMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostAuthorisationMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreHttpRequestHeadersBuilderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostHttpRequestHeadersBuilderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreDownstreamUrlCreatorMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostDownstreamUrlCreatorMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreHttpRequestBuilderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PostHttpRequestBuilderMiddleware { get; set; }
+        public Func<HttpContext, Func<Task>, Task> PreHttpRequesterMiddleware { get; set; }
+    }
+}

src/Ocelot/Middleware/OcelotMiddlewareExtensions.cs

@@ -9,8 +9,11 @@ using Ocelot.Responder.Middleware;
 
 namespace Ocelot.Middleware
 {
+    using System;
+    using System.Threading.Tasks;
     using Authorisation.Middleware;
     using ClaimsBuilder.Middleware;
+    using Microsoft.AspNetCore.Http;
 
     public static class OcelotMiddlewareExtensions
     {
@@ -36,5 +39,70 @@ namespace Ocelot.Middleware
 
             return builder;
         }
+
+        public static IApplicationBuilder UseOcelot(this IApplicationBuilder builder, OcelotMiddlewareConfiguration middlewareConfiguration)
+        {
+            builder.UseIfNotNull(middlewareConfiguration.PreHttpResponderMiddleware);
+
+            builder.UseHttpResponderMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostHttpResponderMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreDownstreamRouteFinderMiddleware);
+
+            builder.UseDownstreamRouteFinderMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostDownstreamRouteFinderMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreAuthenticationMiddleware);
+
+            builder.UseAuthenticationMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostAuthenticationMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreClaimsBuilderMiddleware);
+
+            builder.UseClaimsBuilderMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostClaimsBuilderMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreAuthorisationMiddleware);
+
+            builder.UseAuthorisationMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostAuthorisationMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreHttpRequestHeadersBuilderMiddleware);
+
+            builder.UseHttpRequestHeadersBuilderMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostHttpRequestHeadersBuilderMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreDownstreamUrlCreatorMiddleware);
+
+            builder.UseDownstreamUrlCreatorMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostDownstreamUrlCreatorMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreHttpRequestBuilderMiddleware);
+
+            builder.UseHttpRequestBuilderMiddleware();
+
+            builder.UseIfNotNull(middlewareConfiguration.PostHttpRequestBuilderMiddleware);
+
+            builder.UseIfNotNull(middlewareConfiguration.PreHttpRequesterMiddleware);
+
+            builder.UseHttpRequesterMiddleware();
+
+            return builder;
+        }
+
+        private static void UseIfNotNull(this IApplicationBuilder builder, Func<HttpContext, Func<Task>, Task> middleware)
+        {
+            if (middleware != null)
+            {
+                builder.Use(middleware);
+            }
+        }
     }
 }