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 int _serviceProviderPort;
+        private ServiceProviderConfiguraion _serviceProviderConfiguraion;
 
         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;
-            return this;
-        }
-
-        public ReRouteBuilder WithServiceProviderPort(int serviceProviderPort)
-        {
-            _serviceProviderPort = serviceProviderPort;
+            _serviceProviderConfiguraion = serviceProviderConfiguraion;
             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,
-                fileReRoute.DownstreamHost, fileReRoute.DownstreamPort, useServiceDiscovery,
-                globalConfiguration?.ServiceDiscoveryProvider?.Provider, globalConfiguration?.ServiceDiscoveryProvider?.Host,
-                serviceProviderPort);
+            var serviceProviderConfiguration = new ServiceProviderConfiguraionBuilder()
+                    .WithServiceName(fileReRoute.ServiceName)
+                    .WithDownstreamHost(fileReRoute.DownstreamHost)
+                    .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

@@ -13,17 +13,8 @@ namespace Ocelot.LoadBalancer.LoadBalancers
         }
 
         public async Task<ILoadBalancer> Get(ReRoute reRoute)
-        {
-            var serviceConfig = new 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);
+        {            
+            var serviceProvider = _serviceProviderFactory.Get(reRoute.ServiceProviderConfiguraion);
 
             switch (reRoute.LoadBalancer)
             {