added Ocelot bulder to try and make adding Ocelot configuration more … (#159)

* added Ocelot bulder to try and make adding Ocelot configuration more idiomatic

* renamed tests

src/Ocelot/DependencyInjection/IOcelotBuilder.cs

@@ -0,0 +1,11 @@
+using CacheManager.Core;
+using System;
+
+namespace Ocelot.DependencyInjection
+{
+    public interface IOcelotBuilder
+    {
+        IOcelotBuilder AddStoreOcelotConfigurationInConsul();
+        IOcelotBuilder AddCacheManager(Action<ConfigurationBuilderCachePart> settings);
+    }
+}

src/Ocelot/DependencyInjection/OcelotBuilder.cs

@@ -0,0 +1,262 @@
+using CacheManager.Core;
+using IdentityServer4.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Ocelot.Authorisation;
+using Ocelot.Cache;
+using Ocelot.Claims;
+using Ocelot.Configuration.Authentication;
+using Ocelot.Configuration.Creator;
+using Ocelot.Configuration.File;
+using Ocelot.Configuration.Parser;
+using Ocelot.Configuration.Provider;
+using Ocelot.Configuration.Repository;
+using Ocelot.Configuration.Setter;
+using Ocelot.Configuration.Validator;
+using Ocelot.Controllers;
+using Ocelot.DownstreamRouteFinder.Finder;
+using Ocelot.DownstreamRouteFinder.UrlMatcher;
+using Ocelot.DownstreamUrlCreator;
+using Ocelot.DownstreamUrlCreator.UrlTemplateReplacer;
+using Ocelot.Headers;
+using Ocelot.Infrastructure.Claims.Parser;
+using Ocelot.Infrastructure.RequestData;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Logging;
+using Ocelot.Middleware;
+using Ocelot.QueryStrings;
+using Ocelot.RateLimit;
+using Ocelot.Request.Builder;
+using Ocelot.Request.Mapper;
+using Ocelot.Requester;
+using Ocelot.Requester.QoS;
+using Ocelot.Responder;
+using Ocelot.ServiceDiscovery;
+using System;
+using System.Collections.Generic;
+using System.IdentityModel.Tokens.Jwt;
+using System.Net.Http;
+using System.Reflection;
+using System.Security.Cryptography.X509Certificates;
+using IdentityServer4.AccessTokenValidation;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
+using FileConfigurationProvider = Ocelot.Configuration.Provider.FileConfigurationProvider;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using System.Linq;
+
+namespace Ocelot.DependencyInjection
+{
+    public class OcelotBuilder : IOcelotBuilder
+    {
+        private IServiceCollection _services;
+        private IConfigurationRoot _configurationRoot;
+        
+        public OcelotBuilder(IServiceCollection services, IConfigurationRoot configurationRoot)
+        {
+            _configurationRoot = configurationRoot;
+            _services = services;    
+            
+            //add default cache settings...
+            Action<ConfigurationBuilderCachePart> defaultCachingSettings = x =>
+            {
+                x.WithDictionaryHandle();
+            };
+
+            AddCacheManager(defaultCachingSettings);
+
+            //add ocelot services...
+            _services.Configure<FileConfiguration>(configurationRoot);
+            _services.TryAddSingleton<IOcelotConfigurationCreator, FileOcelotConfigurationCreator>();
+            _services.TryAddSingleton<IOcelotConfigurationRepository, InMemoryOcelotConfigurationRepository>();
+            _services.TryAddSingleton<IConfigurationValidator, FileConfigurationValidator>();
+            _services.TryAddSingleton<IClaimsToThingCreator, ClaimsToThingCreator>();
+            _services.TryAddSingleton<IAuthenticationOptionsCreator, AuthenticationOptionsCreator>();
+            _services.TryAddSingleton<IUpstreamTemplatePatternCreator, UpstreamTemplatePatternCreator>();
+            _services.TryAddSingleton<IRequestIdKeyCreator, RequestIdKeyCreator>();
+            _services.TryAddSingleton<IServiceProviderConfigurationCreator,ServiceProviderConfigurationCreator>();
+            _services.TryAddSingleton<IQoSOptionsCreator, QoSOptionsCreator>();
+            _services.TryAddSingleton<IReRouteOptionsCreator, ReRouteOptionsCreator>();
+            _services.TryAddSingleton<IRateLimitOptionsCreator, RateLimitOptionsCreator>();
+            _services.TryAddSingleton<IBaseUrlFinder, BaseUrlFinder>();
+            _services.TryAddSingleton<IRegionCreator, RegionCreator>();
+            _services.TryAddSingleton<IFileConfigurationRepository, FileConfigurationRepository>();
+            _services.TryAddSingleton<IFileConfigurationSetter, FileConfigurationSetter>();
+            _services.TryAddSingleton<IFileConfigurationProvider, FileConfigurationProvider>();
+            _services.TryAddSingleton<IQosProviderHouse, QosProviderHouse>();
+            _services.TryAddSingleton<IQoSProviderFactory, QoSProviderFactory>();
+            _services.TryAddSingleton<IServiceDiscoveryProviderFactory, ServiceDiscoveryProviderFactory>();
+            _services.TryAddSingleton<ILoadBalancerFactory, LoadBalancerFactory>();
+            _services.TryAddSingleton<ILoadBalancerHouse, LoadBalancerHouse>();
+            _services.TryAddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
+            _services.TryAddSingleton<IUrlBuilder, UrlBuilder>();
+            _services.TryAddSingleton<IRemoveOutputHeaders, RemoveOutputHeaders>();
+            _services.TryAddSingleton<IOcelotConfigurationProvider, OcelotConfigurationProvider>();
+            _services.TryAddSingleton<IClaimToThingConfigurationParser, ClaimToThingConfigurationParser>();
+            _services.TryAddSingleton<IClaimsAuthoriser, ClaimsAuthoriser>();
+            _services.TryAddSingleton<IScopesAuthoriser, ScopesAuthoriser>();
+            _services.TryAddSingleton<IAddClaimsToRequest, AddClaimsToRequest>();
+            _services.TryAddSingleton<IAddHeadersToRequest, AddHeadersToRequest>();
+            _services.TryAddSingleton<IAddQueriesToRequest, AddQueriesToRequest>();
+            _services.TryAddSingleton<IClaimsParser, ClaimsParser>();
+            _services.TryAddSingleton<IUrlPathToUrlTemplateMatcher, RegExUrlMatcher>();
+            _services.TryAddSingleton<IUrlPathPlaceholderNameAndValueFinder, UrlPathPlaceholderNameAndValueFinder>();
+            _services.TryAddSingleton<IDownstreamPathPlaceholderReplacer, DownstreamTemplatePathPlaceholderReplacer>();
+            _services.TryAddSingleton<IDownstreamRouteFinder, DownstreamRouteFinder.Finder.DownstreamRouteFinder>();
+            _services.TryAddSingleton<IHttpRequester, HttpClientHttpRequester>();
+            _services.TryAddSingleton<IHttpResponder, HttpContextResponder>();
+            _services.TryAddSingleton<IRequestCreator, HttpRequestCreator>();
+            _services.TryAddSingleton<IErrorsToHttpStatusCodeMapper, ErrorsToHttpStatusCodeMapper>();
+            _services.TryAddSingleton<IRateLimitCounterHandler, MemoryCacheRateLimitCounterHandler>();
+            _services.TryAddSingleton<IHttpClientCache, MemoryHttpClientCache>();
+            _services.TryAddSingleton<IRequestMapper, RequestMapper>();
+            _services.TryAddSingleton<IHttpHandlerOptionsCreator, HttpHandlerOptionsCreator>();
+            // see this for why we register this as singleton http://stackoverflow.com/questions/37371264/invalidoperationexception-unable-to-resolve-service-for-type-microsoft-aspnetc
+            // could maybe use a scoped data repository
+            _services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+            _services.TryAddScoped<IRequestScopedDataRepository, HttpDataRepository>();
+            _services.AddMemoryCache();
+            _services.TryAddSingleton<OcelotDiagnosticListener>();
+
+            //add identity server for admin area
+            var identityServerConfiguration = IdentityServerConfigurationCreator.GetIdentityServerConfiguration();
+
+            if (identityServerConfiguration != null)
+            {
+                AddIdentityServer(identityServerConfiguration);
+            }
+
+            //add asp.net services..
+            var assembly = typeof(FileConfigurationController).GetTypeInfo().Assembly;
+
+            _services.AddMvcCore()
+                .AddApplicationPart(assembly)
+                .AddControllersAsServices()
+                .AddAuthorization()
+                .AddJsonFormatters();
+
+            _services.AddLogging();
+            _services.AddMiddlewareAnalysis();
+            _services.AddWebEncoders();
+        }
+
+        public IOcelotBuilder AddStoreOcelotConfigurationInConsul()
+        {
+            var serviceDiscoveryPort = _configurationRoot.GetValue("GlobalConfiguration:ServiceDiscoveryProvider:Port", 0);
+            var serviceDiscoveryHost = _configurationRoot.GetValue("GlobalConfiguration:ServiceDiscoveryProvider:Host", string.Empty);
+
+            var config = new ServiceProviderConfigurationBuilder()
+                .WithServiceDiscoveryProviderPort(serviceDiscoveryPort)
+                .WithServiceDiscoveryProviderHost(serviceDiscoveryHost)
+                .Build();
+
+            _services.AddSingleton<ServiceProviderConfiguration>(config);
+            _services.AddSingleton<ConsulFileConfigurationPoller>();
+            _services.AddSingleton<IFileConfigurationRepository, ConsulFileConfigurationRepository>();
+            return this;
+        }
+
+        public IOcelotBuilder AddCacheManager(Action<ConfigurationBuilderCachePart> settings)
+        {
+            var cacheManagerOutputCache = CacheFactory.Build<HttpResponseMessage>("OcelotOutputCache", settings);
+            var ocelotOutputCacheManager = new OcelotCacheManagerCache<HttpResponseMessage>(cacheManagerOutputCache);
+
+            _services.RemoveAll(typeof(ICacheManager<HttpResponseMessage>));
+            _services.RemoveAll(typeof(IOcelotCache<HttpResponseMessage>));
+            _services.AddSingleton<ICacheManager<HttpResponseMessage>>(cacheManagerOutputCache);
+            _services.AddSingleton<IOcelotCache<HttpResponseMessage>>(ocelotOutputCacheManager);
+
+            var ocelotConfigCacheManagerOutputCache = CacheFactory.Build<IOcelotConfiguration>("OcelotConfigurationCache", settings);
+            var ocelotConfigCacheManager = new OcelotCacheManagerCache<IOcelotConfiguration>(ocelotConfigCacheManagerOutputCache);
+            _services.RemoveAll(typeof(ICacheManager<IOcelotConfiguration>));
+            _services.RemoveAll(typeof(IOcelotCache<IOcelotConfiguration>));
+            _services.AddSingleton<ICacheManager<IOcelotConfiguration>>(ocelotConfigCacheManagerOutputCache);
+            _services.AddSingleton<IOcelotCache<IOcelotConfiguration>>(ocelotConfigCacheManager);
+
+            var fileConfigCacheManagerOutputCache = CacheFactory.Build<FileConfiguration>("FileConfigurationCache", settings);
+            var fileConfigCacheManager = new OcelotCacheManagerCache<FileConfiguration>(fileConfigCacheManagerOutputCache);
+            _services.RemoveAll(typeof(ICacheManager<FileConfiguration>));
+            _services.RemoveAll(typeof(IOcelotCache<FileConfiguration>));
+            _services.AddSingleton<ICacheManager<FileConfiguration>>(fileConfigCacheManagerOutputCache);
+            _services.AddSingleton<IOcelotCache<FileConfiguration>>(fileConfigCacheManager);
+            return this;
+        }
+
+        private void AddIdentityServer(IIdentityServerConfiguration identityServerConfiguration) 
+        {
+            _services.TryAddSingleton<IIdentityServerConfiguration>(identityServerConfiguration);
+            _services.TryAddSingleton<IHashMatcher, HashMatcher>();
+            var identityServerBuilder = _services
+                .AddIdentityServer(o => {
+                    o.IssuerUri = "Ocelot";
+                })
+                .AddInMemoryApiResources(Resources(identityServerConfiguration))
+                .AddInMemoryClients(Client(identityServerConfiguration))
+                .AddResourceOwnerValidator<OcelotResourceOwnerPasswordValidator>();
+
+            //todo - refactor a method so we know why this is happening
+            var whb = _services.First(x => x.ServiceType == typeof(IWebHostBuilder));
+            var urlFinder = new BaseUrlFinder((IWebHostBuilder)whb.ImplementationInstance);
+            var baseSchemeUrlAndPort = urlFinder.Find();
+            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
+
+            _services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
+                .AddIdentityServerAuthentication(o =>
+                {
+                    var adminPath = _configurationRoot.GetValue("GlobalConfiguration:AdministrationPath", string.Empty);
+                    o.Authority = baseSchemeUrlAndPort + adminPath;
+                    o.ApiName = identityServerConfiguration.ApiName;
+                    o.RequireHttpsMetadata = identityServerConfiguration.RequireHttps;
+                    o.SupportedTokens = SupportedTokens.Both;
+                    o.ApiSecret = identityServerConfiguration.ApiSecret;
+                });
+
+                //todo - refactor naming..
+                if (string.IsNullOrEmpty(identityServerConfiguration.CredentialsSigningCertificateLocation) || string.IsNullOrEmpty(identityServerConfiguration.CredentialsSigningCertificatePassword))
+                {
+                    identityServerBuilder.AddDeveloperSigningCredential();
+                }
+                else
+                {
+                    //todo - refactor so calls method?
+                    var cert = new X509Certificate2(identityServerConfiguration.CredentialsSigningCertificateLocation, identityServerConfiguration.CredentialsSigningCertificatePassword);
+                    identityServerBuilder.AddSigningCredential(cert);
+                }
+        }
+
+        private List<ApiResource> Resources(IIdentityServerConfiguration identityServerConfiguration)
+        {
+            return new List<ApiResource>
+            {
+                new ApiResource(identityServerConfiguration.ApiName, identityServerConfiguration.ApiName)
+                {
+                    ApiSecrets = new List<Secret>
+                    {
+                        new Secret
+                        {
+                            Value = identityServerConfiguration.ApiSecret.Sha256()
+                        }
+                    }
+                }
+            };
+        }
+
+        private List<Client> Client(IIdentityServerConfiguration identityServerConfiguration) 
+        {
+            return new List<Client>
+            {
+                new Client
+                {
+                    ClientId = identityServerConfiguration.ApiName,
+                    AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
+                    ClientSecrets = new List<Secret> {new Secret(identityServerConfiguration.ApiSecret.Sha256())},
+                    AllowedScopes = { identityServerConfiguration.ApiName }
+                }
+            };
+        }
+
+    }
+}

src/Ocelot/DependencyInjection/ServiceCollectionExtensions.cs

@@ -1,249 +1,16 @@
-using CacheManager.Core;
+using Microsoft.Extensions.Configuration;
-using IdentityServer4.Models;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
-using Ocelot.Authorisation;
-using Ocelot.Cache;
-using Ocelot.Claims;
-using Ocelot.Configuration.Authentication;
-using Ocelot.Configuration.Creator;
-using Ocelot.Configuration.File;
-using Ocelot.Configuration.Parser;
-using Ocelot.Configuration.Provider;
-using Ocelot.Configuration.Repository;
-using Ocelot.Configuration.Setter;
-using Ocelot.Configuration.Validator;
-using Ocelot.Controllers;
-using Ocelot.DownstreamRouteFinder.Finder;
-using Ocelot.DownstreamRouteFinder.UrlMatcher;
-using Ocelot.DownstreamUrlCreator;
-using Ocelot.DownstreamUrlCreator.UrlTemplateReplacer;
-using Ocelot.Headers;
-using Ocelot.Infrastructure.Claims.Parser;
-using Ocelot.Infrastructure.RequestData;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Ocelot.Logging;
-using Ocelot.Middleware;
-using Ocelot.QueryStrings;
-using Ocelot.RateLimit;
-using Ocelot.Request.Builder;
-using Ocelot.Request.Mapper;
-using Ocelot.Requester;
-using Ocelot.Requester.QoS;
-using Ocelot.Responder;
-using Ocelot.ServiceDiscovery;
-using System;
-using System.Collections.Generic;
-using System.IdentityModel.Tokens.Jwt;
 using System.Linq;
-using System.Net.Http;
-using System.Reflection;
-using System.Security.Cryptography.X509Certificates;
-using IdentityServer4.AccessTokenValidation;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Ocelot.Configuration;
-using Ocelot.Configuration.Builder;
-using FileConfigurationProvider = Ocelot.Configuration.Provider.FileConfigurationProvider;
 
 namespace Ocelot.DependencyInjection
 {
     public static class ServiceCollectionExtensions
     {
-        public static IServiceCollection AddStoreOcelotConfigurationInConsul(this IServiceCollection services, IConfigurationRoot configurationRoot)
+        public static IOcelotBuilder AddOcelot(this IServiceCollection services,
-        {
-            var serviceDiscoveryPort = configurationRoot.GetValue("GlobalConfiguration:ServiceDiscoveryProvider:Port", 0);
-            var serviceDiscoveryHost = configurationRoot.GetValue("GlobalConfiguration:ServiceDiscoveryProvider:Host", string.Empty);
-
-            var config = new ServiceProviderConfigurationBuilder()
-                .WithServiceDiscoveryProviderPort(serviceDiscoveryPort)
-                .WithServiceDiscoveryProviderHost(serviceDiscoveryHost)
-                .Build();
-
-            services.AddSingleton<ServiceProviderConfiguration>(config);
-            services.AddSingleton<ConsulFileConfigurationPoller>();
-            services.AddSingleton<IFileConfigurationRepository, ConsulFileConfigurationRepository>();
-            return services;
-        }
-
-        public static IServiceCollection AddOcelot(this IServiceCollection services,
             IConfigurationRoot configurationRoot)
         {
-            Action<ConfigurationBuilderCachePart> defaultCachingSettings = x =>
+            return new OcelotBuilder(services, configurationRoot);
-            {
-                x.WithDictionaryHandle();
-            };
-
-            return services.AddOcelot(configurationRoot, defaultCachingSettings);
-        }
-
-        public static IServiceCollection AddOcelot(this IServiceCollection services, IConfigurationRoot configurationRoot, Action<ConfigurationBuilderCachePart> settings)
-        {
-            var cacheManagerOutputCache = CacheFactory.Build<HttpResponseMessage>("OcelotOutputCache", settings);
-            var ocelotOutputCacheManager = new OcelotCacheManagerCache<HttpResponseMessage>(cacheManagerOutputCache);
-            services.TryAddSingleton<ICacheManager<HttpResponseMessage>>(cacheManagerOutputCache);
-            services.TryAddSingleton<IOcelotCache<HttpResponseMessage>>(ocelotOutputCacheManager);
-
-            var ocelotConfigCacheManagerOutputCache = CacheFactory.Build<IOcelotConfiguration>("OcelotConfigurationCache", settings);
-            var ocelotConfigCacheManager = new OcelotCacheManagerCache<IOcelotConfiguration>(ocelotConfigCacheManagerOutputCache);
-            services.TryAddSingleton<ICacheManager<IOcelotConfiguration>>(ocelotConfigCacheManagerOutputCache);
-            services.TryAddSingleton<IOcelotCache<IOcelotConfiguration>>(ocelotConfigCacheManager);
-
-              var fileConfigCacheManagerOutputCache = CacheFactory.Build<FileConfiguration>("FileConfigurationCache", settings);
-            var fileConfigCacheManager = new OcelotCacheManagerCache<FileConfiguration>(fileConfigCacheManagerOutputCache);
-            services.TryAddSingleton<ICacheManager<FileConfiguration>>(fileConfigCacheManagerOutputCache);
-            services.TryAddSingleton<IOcelotCache<FileConfiguration>>(fileConfigCacheManager);
-
-            services.Configure<FileConfiguration>(configurationRoot);
-            services.TryAddSingleton<IOcelotConfigurationCreator, FileOcelotConfigurationCreator>();
-            services.TryAddSingleton<IOcelotConfigurationRepository, InMemoryOcelotConfigurationRepository>();
-            services.TryAddSingleton<IConfigurationValidator, FileConfigurationValidator>();
-            services.TryAddSingleton<IClaimsToThingCreator, ClaimsToThingCreator>();
-            services.TryAddSingleton<IAuthenticationOptionsCreator, AuthenticationOptionsCreator>();
-            services.TryAddSingleton<IUpstreamTemplatePatternCreator, UpstreamTemplatePatternCreator>();
-            services.TryAddSingleton<IRequestIdKeyCreator, RequestIdKeyCreator>();
-            services.TryAddSingleton<IServiceProviderConfigurationCreator,ServiceProviderConfigurationCreator>();
-            services.TryAddSingleton<IQoSOptionsCreator, QoSOptionsCreator>();
-            services.TryAddSingleton<IReRouteOptionsCreator, ReRouteOptionsCreator>();
-            services.TryAddSingleton<IRateLimitOptionsCreator, RateLimitOptionsCreator>();
-            services.TryAddSingleton<IBaseUrlFinder, BaseUrlFinder>();
-
-            var assembly = typeof(FileConfigurationController).GetTypeInfo().Assembly;
-
-            services.AddMvcCore()
-                .AddApplicationPart(assembly)
-                .AddControllersAsServices()
-                .AddAuthorization()
-                .AddJsonFormatters();
-
-            services.AddLogging();
-            services.TryAddSingleton<IRegionCreator, RegionCreator>();
-            services.TryAddSingleton<IFileConfigurationRepository, FileConfigurationRepository>();
-            services.TryAddSingleton<IFileConfigurationSetter, FileConfigurationSetter>();
-            services.TryAddSingleton<IFileConfigurationProvider, FileConfigurationProvider>();
-            services.TryAddSingleton<IQosProviderHouse, QosProviderHouse>();
-            services.TryAddSingleton<IQoSProviderFactory, QoSProviderFactory>();
-            services.TryAddSingleton<IServiceDiscoveryProviderFactory, ServiceDiscoveryProviderFactory>();
-            services.TryAddSingleton<ILoadBalancerFactory, LoadBalancerFactory>();
-            services.TryAddSingleton<ILoadBalancerHouse, LoadBalancerHouse>();
-            services.TryAddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
-            services.TryAddSingleton<IUrlBuilder, UrlBuilder>();
-            services.TryAddSingleton<IRemoveOutputHeaders, RemoveOutputHeaders>();
-            services.TryAddSingleton<IOcelotConfigurationProvider, OcelotConfigurationProvider>();
-            services.TryAddSingleton<IClaimToThingConfigurationParser, ClaimToThingConfigurationParser>();
-            services.TryAddSingleton<IClaimsAuthoriser, ClaimsAuthoriser>();
-            services.TryAddSingleton<IScopesAuthoriser, ScopesAuthoriser>();
-            services.TryAddSingleton<IAddClaimsToRequest, AddClaimsToRequest>();
-            services.TryAddSingleton<IAddHeadersToRequest, AddHeadersToRequest>();
-            services.TryAddSingleton<IAddQueriesToRequest, AddQueriesToRequest>();
-            services.TryAddSingleton<IClaimsParser, ClaimsParser>();
-            services.TryAddSingleton<IUrlPathToUrlTemplateMatcher, RegExUrlMatcher>();
-            services.TryAddSingleton<IUrlPathPlaceholderNameAndValueFinder, UrlPathPlaceholderNameAndValueFinder>();
-            services.TryAddSingleton<IDownstreamPathPlaceholderReplacer, DownstreamTemplatePathPlaceholderReplacer>();
-            services.TryAddSingleton<IDownstreamRouteFinder, DownstreamRouteFinder.Finder.DownstreamRouteFinder>();
-            services.TryAddSingleton<IHttpRequester, HttpClientHttpRequester>();
-            services.TryAddSingleton<IHttpResponder, HttpContextResponder>();
-            services.TryAddSingleton<IRequestCreator, HttpRequestCreator>();
-            services.TryAddSingleton<IErrorsToHttpStatusCodeMapper, ErrorsToHttpStatusCodeMapper>();
-            services.TryAddSingleton<IRateLimitCounterHandler, MemoryCacheRateLimitCounterHandler>();
-            services.TryAddSingleton<IHttpClientCache, MemoryHttpClientCache>();
-            services.TryAddSingleton<IRequestMapper, RequestMapper>();
-            services.TryAddSingleton<IHttpHandlerOptionsCreator, HttpHandlerOptionsCreator>();
-
-            // see this for why we register this as singleton http://stackoverflow.com/questions/37371264/invalidoperationexception-unable-to-resolve-service-for-type-microsoft-aspnetc
-            // could maybe use a scoped data repository
-            services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
-            services.TryAddScoped<IRequestScopedDataRepository, HttpDataRepository>();
-            services.AddMemoryCache();
-
-            //Used to log the the start and ending of middleware
-            services.TryAddSingleton<OcelotDiagnosticListener>();
-            services.AddMiddlewareAnalysis();
-            services.AddWebEncoders();
-
-            var identityServerConfiguration = IdentityServerConfigurationCreator.GetIdentityServerConfiguration();
-
-            if (identityServerConfiguration != null)
-            {
-                services.AddIdentityServer(identityServerConfiguration, configurationRoot);
-            }
-
-            return services;
-        }
-
-        private static void AddIdentityServer(this IServiceCollection services, IIdentityServerConfiguration identityServerConfiguration, IConfigurationRoot configurationRoot) 
-        {
-            services.TryAddSingleton<IIdentityServerConfiguration>(identityServerConfiguration);
-            services.TryAddSingleton<IHashMatcher, HashMatcher>();
-            var identityServerBuilder = services
-                .AddIdentityServer(o => {
-                    o.IssuerUri = "Ocelot";
-                })
-                .AddInMemoryApiResources(Resources(identityServerConfiguration))
-                .AddInMemoryClients(Client(identityServerConfiguration))
-                .AddResourceOwnerValidator<OcelotResourceOwnerPasswordValidator>();
-
-            //todo - refactor a method so we know why this is happening
-            var whb = services.First(x => x.ServiceType == typeof(IWebHostBuilder));
-            var urlFinder = new BaseUrlFinder((IWebHostBuilder)whb.ImplementationInstance);
-            var baseSchemeUrlAndPort = urlFinder.Find();
-            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
-
-            services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
-                .AddIdentityServerAuthentication(o =>
-                {
-                    var adminPath = configurationRoot.GetValue("GlobalConfiguration:AdministrationPath", string.Empty);
-                    o.Authority = baseSchemeUrlAndPort + adminPath;
-                    o.ApiName = identityServerConfiguration.ApiName;
-                    o.RequireHttpsMetadata = identityServerConfiguration.RequireHttps;
-                    o.SupportedTokens = SupportedTokens.Both;
-                    o.ApiSecret = identityServerConfiguration.ApiSecret;
-                });
-
-                //todo - refactor naming..
-                if (string.IsNullOrEmpty(identityServerConfiguration.CredentialsSigningCertificateLocation) || string.IsNullOrEmpty(identityServerConfiguration.CredentialsSigningCertificatePassword))
-                {
-                    identityServerBuilder.AddDeveloperSigningCredential();
-                }
-                else
-                {
-                    //todo - refactor so calls method?
-                    var cert = new X509Certificate2(identityServerConfiguration.CredentialsSigningCertificateLocation, identityServerConfiguration.CredentialsSigningCertificatePassword);
-                    identityServerBuilder.AddSigningCredential(cert);
-                }
-        }
-
-        private static List<ApiResource> Resources(IIdentityServerConfiguration identityServerConfiguration)
-        {
-            return new List<ApiResource>
-            {
-                new ApiResource(identityServerConfiguration.ApiName, identityServerConfiguration.ApiName)
-                {
-                    ApiSecrets = new List<Secret>
-                    {
-                        new Secret
-                        {
-                            Value = identityServerConfiguration.ApiSecret.Sha256()
-                        }
-                    }
-                }
-            };
-        }
-
-        private static List<Client> Client(IIdentityServerConfiguration identityServerConfiguration) 
-        {
-            return new List<Client>
-            {
-                new Client
-                {
-                    ClientId = identityServerConfiguration.ApiName,
-                    AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
-                    ClientSecrets = new List<Secret> {new Secret(identityServerConfiguration.ApiSecret.Sha256())},
-                    AllowedScopes = { identityServerConfiguration.ApiName }
-                }
-            };
         }
     }
 }

test/Ocelot.AcceptanceTests/ConfigurationInConsulTests.cs

@@ -17,14 +17,14 @@ using Xunit;
 
 namespace Ocelot.AcceptanceTests
 {
-    public class ConfigurationInConsul : IDisposable
+    public class ConfigurationInConsulTests : IDisposable
     {
         private IWebHost _builder;
         private readonly Steps _steps;
         private IWebHost _fakeConsulBuilder;
         private FileConfiguration _config;
 
-        public ConfigurationInConsul()
+        public ConfigurationInConsulTests()
         {
             _steps = new Steps();
         }

test/Ocelot.AcceptanceTests/ConsulStartup.cs

@@ -0,0 +1,47 @@
+using System;
+using CacheManager.Core;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Ocelot.DependencyInjection;
+using Ocelot.Middleware;
+using ConfigurationBuilder = Microsoft.Extensions.Configuration.ConfigurationBuilder;
+
+namespace Ocelot.AcceptanceTests
+{
+    public class ConsulStartup
+    {
+        public ConsulStartup(IHostingEnvironment env)
+        {
+            var builder = new ConfigurationBuilder()
+                .SetBasePath(env.ContentRootPath)
+                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
+                .AddJsonFile("configuration.json")
+                .AddEnvironmentVariables();
+
+            Configuration = builder.Build();
+        }
+
+        public IConfigurationRoot Configuration { get; }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            Action<ConfigurationBuilderCachePart> settings = (x) =>
+            {
+                x.WithDictionaryHandle();
+            };
+
+            services.AddOcelot(Configuration).AddStoreOcelotConfigurationInConsul();
+        }
+
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
+        {
+            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
+
+            app.UseOcelot().Wait();
+        }
+    }
+}

test/Ocelot.AcceptanceTests/Startup.cs

@@ -34,42 +34,7 @@ namespace Ocelot.AcceptanceTests
                 x.WithDictionaryHandle();
             };
 
-            services.AddOcelot(Configuration, settings);
+            services.AddOcelot(Configuration);
-        }
-
-        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
-        {
-            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
-
-            app.UseOcelot().Wait();
-        }
-    }
-
-    public class ConsulStartup
-    {
-        public ConsulStartup(IHostingEnvironment env)
-        {
-            var builder = new ConfigurationBuilder()
-                .SetBasePath(env.ContentRootPath)
-                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
-                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
-                .AddJsonFile("configuration.json")
-                .AddEnvironmentVariables();
-
-            Configuration = builder.Build();
-        }
-
-        public IConfigurationRoot Configuration { get; }
-
-        public void ConfigureServices(IServiceCollection services)
-        {
-            Action<ConfigurationBuilderCachePart> settings = (x) =>
-            {
-                x.WithDictionaryHandle();
-            };
-
-            services.AddOcelot(Configuration, settings);
-            services.AddStoreOcelotConfigurationInConsul(Configuration);
         }
 
         public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)

test/Ocelot.AcceptanceTests/Steps.cs

@@ -173,7 +173,7 @@ namespace Ocelot.AcceptanceTests
                         .WithDictionaryHandle();
                     };
                     
-                    s.AddOcelot(configuration, settings);
+                    s.AddOcelot(configuration);
                 })
                 .ConfigureLogging(l =>
                 {

test/Ocelot.IntegrationTests/Startup.cs

@@ -38,7 +38,7 @@ namespace Ocelot.IntegrationTests
                     .WithDictionaryHandle();
             };
 
-            services.AddOcelot(Configuration, settings);
+            services.AddOcelot(Configuration);
         }
 
         public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)

test/Ocelot.ManualTest/Startup.cs

@@ -45,7 +45,7 @@ namespace Ocelot.ManualTest
                     x.Audience = "test";
                 });
 
-            services.AddOcelot(Configuration, settings);
+            services.AddOcelot(Configuration);
         }
 
         public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)

test/Ocelot.UnitTests/DependencyInjection/OcelotBuilderTests.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using CacheManager.Core;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Ocelot.Cache;
+using Ocelot.Configuration;
+using Ocelot.Configuration.File;
+using Ocelot.DependencyInjection;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.DependencyInjection
+{
+    public class OcelotBuilderTests
+    {
+        private IServiceCollection _services;
+        private IConfigurationRoot _configRoot;
+        private IOcelotBuilder _ocelotBuilder;
+        private int _maxRetries;
+
+        public OcelotBuilderTests()
+        {
+                IWebHostBuilder builder = new WebHostBuilder();
+                _configRoot = new ConfigurationRoot(new List<IConfigurationProvider>());
+                _services = new ServiceCollection();
+                _services.AddSingleton(builder);
+                _maxRetries = 100;
+        }
+        private Exception _ex;
+
+        [Fact]
+        public void should_set_up_services()
+        {
+            this.When(x => WhenISetUpOcelotServices())
+                .Then(x => ThenAnExceptionIsntThrown())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_ocelot_builder()
+        {
+            this.When(x => WhenISetUpOcelotServices())
+                .Then(x => ThenAnOcelotBuilderIsReturned())
+                .BDDfy();
+        }
+
+       
+        [Fact]
+        public void should_set_up_cache_manager()
+        {
+            this.Given(x => WhenISetUpOcelotServices())
+                .When(x => WhenISetUpCacheManager())
+                .Then(x => ThenAnExceptionIsntThrown())
+                .And(x => OnlyOneVersionOfEachCacheIsRegistered())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_set_up_consul()
+        {            
+            this.Given(x => WhenISetUpOcelotServices())
+                .When(x => WhenISetUpConsul())
+                .Then(x => ThenAnExceptionIsntThrown())
+                .BDDfy();
+        }
+
+        private void OnlyOneVersionOfEachCacheIsRegistered()
+        {
+            var outputCache = _services.Single(x => x.ServiceType == typeof(IOcelotCache<HttpResponseMessage>));
+            var outputCacheManager = _services.Single(x => x.ServiceType == typeof(ICacheManager<HttpResponseMessage>));
+            var thing = (CacheManager.Core.ICacheManager<System.Net.Http.HttpResponseMessage>)outputCacheManager.ImplementationInstance;
+            thing.Configuration.MaxRetries.ShouldBe(_maxRetries);
+            
+            var ocelotConfigCache = _services.Single(x => x.ServiceType == typeof(IOcelotCache<IOcelotConfiguration>));
+            var ocelotConfigCacheManager = _services.Single(x => x.ServiceType == typeof(ICacheManager<IOcelotConfiguration>));
+
+            var fileConfigCache = _services.Single(x => x.ServiceType == typeof(IOcelotCache<FileConfiguration>));
+            var fileConfigCacheManager = _services.Single(x => x.ServiceType == typeof(ICacheManager<FileConfiguration>));
+        }
+
+        private void WhenISetUpConsul()
+        {
+            try
+            {
+                _ocelotBuilder.AddStoreOcelotConfigurationInConsul();
+            }
+            catch (Exception e)
+            {
+                _ex = e;
+            }       
+        }
+
+        private void ThenAnOcelotBuilderIsReturned()
+        {
+            _ocelotBuilder.ShouldBeOfType<OcelotBuilder>();
+        }
+
+        private void WhenISetUpOcelotServices()
+        {
+            try
+            {
+                _ocelotBuilder = _services.AddOcelot(_configRoot);
+            }
+            catch (Exception e)
+            {
+                _ex = e;
+            }
+        }
+        private void WhenISetUpCacheManager()
+        {
+            try
+            {
+                _ocelotBuilder.AddCacheManager(x => {
+                    x.WithMaxRetries(_maxRetries);
+                    x.WithDictionaryHandle();
+                });
+            }
+            catch (Exception e)
+            {
+                _ex = e;
+            }
+        }
+
+        private void ThenAnExceptionIsntThrown()
+        {
+            _ex.ShouldBeNull();
+        }
+    }
+}

test/Ocelot.UnitTests/DependencyInjection/ServiceCollectionExtensionTests.cs

@@ -1,47 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Ocelot.DependencyInjection;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.DependencyInjection
-{
-    public class ServiceCollectionExtensionTests
-    {
-        private Exception _ex;
-
-        [Fact]
-        public void should_set_up_services()
-        {
-            this.When(x => WhenISetUpOcelotServices())
-                .Then(x => ThenAnExceptionIsntThrown())
-                .BDDfy();
-        }
-
-        private void WhenISetUpOcelotServices()
-        {
-            try
-            {
-                IWebHostBuilder builder = new WebHostBuilder();
-                IConfigurationRoot configRoot = new ConfigurationRoot(new List<IConfigurationProvider>());
-                IServiceCollection services = new ServiceCollection();
-                services.AddSingleton(builder);
-                services.AddOcelot(configRoot);
-            }
-            catch (Exception e)
-            {
-                _ex = e;
-            }
-        }
-
-        private void ThenAnExceptionIsntThrown()
-        {
-            _ex.ShouldBeNull();
-        }
-    }
-}