added builder for service provider config

src/Ocelot/Configuration/Builder/ReRouteBuilder.cs

@@ -26,16 +26,12 @@ namespace Ocelot.Configuration.Builder
         private string _requestIdHeaderKey;
         private bool _isCached;
         private CacheOptions _fileCacheOptions;
-        private bool _useServiceDiscovery;
         private string _serviceName;
-        private string _serviceDiscoveryProvider;
-        private string _serviceDiscoveryAddress;
         private string _downstreamScheme;
         private string _downstreamHost;
-        private int _dsPort;
+        private int _downstreamPort;
         private string _loadBalancer;
-        private string _serviceProviderHost;
+        private ServiceProviderConfiguraion _serviceProviderConfiguraion;
-        private int _serviceProviderPort;
 
         public ReRouteBuilder()
         {
@@ -60,30 +56,12 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
-        public ReRouteBuilder WithServiceDiscoveryAddress(string serviceDiscoveryAddress)
-        {
-            _serviceDiscoveryAddress = serviceDiscoveryAddress;
-            return this;
-        }
-
-        public ReRouteBuilder WithServiceDiscoveryProvider(string serviceDiscoveryProvider)
-        {
-            _serviceDiscoveryProvider = serviceDiscoveryProvider;
-            return this;
-        }
-
         public ReRouteBuilder WithServiceName(string serviceName)
         {
             _serviceName = serviceName;
             return this;
         }
 
-        public ReRouteBuilder WithUseServiceDiscovery(bool useServiceDiscovery)
-        {
-            _useServiceDiscovery = useServiceDiscovery;
-            return this;
-        }
-
         public ReRouteBuilder WithDownstreamPathTemplate(string input)
         {
             _downstreamPathTemplate = input;
@@ -198,7 +176,7 @@ namespace Ocelot.Configuration.Builder
 
         public ReRouteBuilder WithDownstreamPort(int port)
         {
-            _dsPort = port;
+            _downstreamPort = port;
             return this;
         }
 
@@ -208,15 +186,9 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
-        public ReRouteBuilder WithServiceProviderHost(string serviceProviderHost)
+        public ReRouteBuilder WithServiceProviderConfiguraion(ServiceProviderConfiguraion serviceProviderConfiguraion)
         {
-            _serviceProviderHost = serviceProviderHost;
+            _serviceProviderConfiguraion = serviceProviderConfiguraion;
-            return this;
-        }
-
-        public ReRouteBuilder WithServiceProviderPort(int serviceProviderPort)
-        {
-            _serviceProviderPort = serviceProviderPort;
             return this;
         }
 
@@ -226,7 +198,7 @@ namespace Ocelot.Configuration.Builder
                 _isAuthenticated, new AuthenticationOptions(_authenticationProvider, _authenticationProviderUrl, _scopeName, 
                 _requireHttps, _additionalScopes, _scopeSecret), _configHeaderExtractorProperties, _claimToClaims, _routeClaimRequirement, 
                 _isAuthorised, _claimToQueries, _requestIdHeaderKey, _isCached, _fileCacheOptions, _downstreamScheme, _loadBalancer,
-                _downstreamHost, _dsPort, _loadBalancerKey, new ServiceProviderConfiguraion(_serviceName, _downstreamHost, _dsPort, _useServiceDiscovery, _serviceDiscoveryProvider, _serviceProviderHost, _serviceProviderPort));
+                _downstreamHost, _downstreamPort, _loadBalancerKey, _serviceProviderConfiguraion);
         }
     }
 }

src/Ocelot/Configuration/Creator/FileOcelotConfigurationCreator.cs

@@ -110,10 +110,15 @@ namespace Ocelot.Configuration.Creator
 
             var serviceProviderPort = globalConfiguration?.ServiceDiscoveryProvider?.Port ?? 0;
 
-            var serviceProviderConfiguration = new ServiceProviderConfiguraion(fileReRoute.ServiceName,
+            var serviceProviderConfiguration = new ServiceProviderConfiguraionBuilder()
-                fileReRoute.DownstreamHost, fileReRoute.DownstreamPort, useServiceDiscovery,
+                    .WithServiceName(fileReRoute.ServiceName)
-                globalConfiguration?.ServiceDiscoveryProvider?.Provider, globalConfiguration?.ServiceDiscoveryProvider?.Host,
+                    .WithDownstreamHost(fileReRoute.DownstreamHost)
-                serviceProviderPort);
+                    .WithDownstreamPort(fileReRoute.DownstreamPort)
+                    .WithUseServiceDiscovery(useServiceDiscovery)
+                    .WithServiceDiscoveryProvider(globalConfiguration?.ServiceDiscoveryProvider?.Provider)
+                    .WithServiceDiscoveryProviderHost(globalConfiguration?.ServiceDiscoveryProvider?.Host)
+                    .WithServiceDiscoveryProviderPort(serviceProviderPort)
+                    .Build();
 
             if (isAuthenticated)
             {

src/Ocelot/Configuration/ServiceProviderConfiguraionBuilder.cs

@@ -0,0 +1,62 @@
+namespace Ocelot.Configuration
+{
+    public class ServiceProviderConfiguraionBuilder
+    {
+        private string _serviceName;
+        private string _downstreamHost;
+        private int _downstreamPort;
+        private bool _userServiceDiscovery;
+        private string _serviceDiscoveryProvider;
+        private string _serviceDiscoveryProviderHost;
+        private int _serviceDiscoveryProviderPort;
+
+        public ServiceProviderConfiguraionBuilder WithServiceName(string serviceName)
+        {
+            _serviceName = serviceName;
+            return this;
+        }
+
+        public ServiceProviderConfiguraionBuilder WithDownstreamHost(string downstreamHost)
+        {
+            _downstreamHost = downstreamHost;
+            return this;
+        }
+
+        public ServiceProviderConfiguraionBuilder WithDownstreamPort(int downstreamPort)
+        {
+            _downstreamPort = downstreamPort;
+            return this;
+        }
+
+        public ServiceProviderConfiguraionBuilder WithUseServiceDiscovery(bool userServiceDiscovery)
+        {
+            _userServiceDiscovery = userServiceDiscovery;
+            return this;
+        }
+
+        public ServiceProviderConfiguraionBuilder WithServiceDiscoveryProvider(string serviceDiscoveryProvider)
+        {
+            _serviceDiscoveryProvider = serviceDiscoveryProvider;
+            return this;
+        }
+
+        public ServiceProviderConfiguraionBuilder WithServiceDiscoveryProviderHost(string serviceDiscoveryProviderHost)
+        {
+            _serviceDiscoveryProviderHost = serviceDiscoveryProviderHost;
+            return this;
+        }
+
+        public ServiceProviderConfiguraionBuilder WithServiceDiscoveryProviderPort(int serviceDiscoveryProviderPort)
+        {
+            _serviceDiscoveryProviderPort = serviceDiscoveryProviderPort;
+            return this;
+        }
+
+        
+        public ServiceProviderConfiguraion Build()
+        {
+            return new ServiceProviderConfiguraion(_serviceName, _downstreamHost, _downstreamPort, _userServiceDiscovery,
+            _serviceDiscoveryProvider, _serviceDiscoveryProviderHost,_serviceDiscoveryProviderPort);
+        }
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/LoadBalancerFactory.cs

@@ -14,16 +14,7 @@ namespace Ocelot.LoadBalancer.LoadBalancers
 
         public async Task<ILoadBalancer> Get(ReRoute reRoute)
         {            
-            var serviceConfig = new ServiceProviderConfiguraion(
+            var serviceProvider = _serviceProviderFactory.Get(reRoute.ServiceProviderConfiguraion);
-                reRoute.ServiceProviderConfiguraion.ServiceName,
-                reRoute.ServiceProviderConfiguraion.DownstreamHost,
-                reRoute.ServiceProviderConfiguraion.DownstreamPort,
-                reRoute.ServiceProviderConfiguraion.UseServiceDiscovery,
-                reRoute.ServiceProviderConfiguraion.ServiceDiscoveryProvider,
-                reRoute.ServiceProviderConfiguraion.ServiceProviderHost,
-                reRoute.ServiceProviderConfiguraion.ServiceProviderPort);
-            
-            var serviceProvider = _serviceProviderFactory.Get(serviceConfig);
 
             switch (reRoute.LoadBalancer)
             {

test/Ocelot.UnitTests/Configuration/FileConfigurationCreatorTests.cs

@@ -165,9 +165,11 @@ namespace Ocelot.UnitTests.Configuration
                                     .WithUpstreamHttpMethod("Get")
                                     .WithUpstreamTemplatePattern("(?i)/api/products/.*/$")
                                     .WithServiceName("ProductService")
+                                    .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder()
                                         .WithUseServiceDiscovery(true)
                                         .WithServiceDiscoveryProvider("consul")
-                                    .WithServiceDiscoveryAddress("127.0.01")
+                                        .WithServiceDiscoveryProviderHost("127.0.0.1")
+                                        .Build())
                                     .Build()
                             }))
                             .BDDfy();
@@ -198,9 +200,9 @@ namespace Ocelot.UnitTests.Configuration
                                     .WithUpstreamTemplate("/api/products/{productId}")
                                     .WithUpstreamHttpMethod("Get")
                                     .WithUpstreamTemplatePattern("(?i)/api/products/.*/$")
+                                    .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder()
                                         .WithUseServiceDiscovery(false)
-                                    .WithServiceDiscoveryProvider(null)
+                                        .Build())
-                                    .WithServiceDiscoveryAddress(null)
                                     .Build()
                             }))
                             .BDDfy();

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -24,17 +24,11 @@ namespace Ocelot.UnitTests.LoadBalancer
             _factory = new LoadBalancerFactory(_serviceProviderFactory.Object);
         }
 
-        private void GivenTheServiceProviderFactoryReturns()
-        {
-            _serviceProviderFactory
-                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguraion>()))
-                .Returns(_serviceProvider.Object);
-        }
-
         [Fact]
         public void should_return_no_load_balancer()
         {
             var reRoute = new ReRouteBuilder()
+                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
@@ -49,6 +43,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         {
              var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("RoundRobin")
+                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
@@ -63,6 +58,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         {
              var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("LeastConnection")
+                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
@@ -77,6 +73,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         {
             var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("RoundRobin")
+                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
@@ -86,6 +83,13 @@ namespace Ocelot.UnitTests.LoadBalancer
                 .BDDfy();
         }
 
+        private void GivenTheServiceProviderFactoryReturns()
+        {
+            _serviceProviderFactory
+                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguraion>()))
+                .Returns(_serviceProvider.Object);
+        }
+
         private void ThenTheServiceProviderIsCalledCorrectly()
         {
             _serviceProviderFactory

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderFactoryTests.cs

@@ -20,7 +20,11 @@ namespace Ocelot.UnitTests.ServiceDiscovery
         [Fact]
         public void should_return_no_service_provider()
         {
-            var serviceConfig = new ServiceProviderConfiguraion("product", "127.0.0.1", 80, false, "Does not matter", string.Empty, 0);
+            var serviceConfig = new ServiceProviderConfiguraionBuilder()
+                .WithDownstreamHost("127.0.0.1")
+                .WithDownstreamPort(80)
+                .WithUseServiceDiscovery(false)
+                .Build();
 
             this.Given(x => x.GivenTheReRoute(serviceConfig))
                 .When(x => x.WhenIGetTheServiceProvider())
@@ -31,7 +35,11 @@ namespace Ocelot.UnitTests.ServiceDiscovery
         [Fact]
         public void should_return_consul_service_provider()
         {
-            var serviceConfig = new ServiceProviderConfiguraion("product", string.Empty, 0, true, "Consul", string.Empty, 0);
+            var serviceConfig = new ServiceProviderConfiguraionBuilder()
+                .WithServiceName("product")
+                .WithUseServiceDiscovery(true)
+                .WithServiceDiscoveryProvider("Consul")
+                .Build();
 
             this.Given(x => x.GivenTheReRoute(serviceConfig))
                 .When(x => x.WhenIGetTheServiceProvider())