auth options builders

src/Ocelot/Authorisation/Middleware/AuthorisationMiddleware.cs

@@ -61,7 +61,7 @@ namespace Ocelot.Authorisation.Middleware
                     SetPipelineError(new List<Error>
                     {
                         new UnauthorisedError(
-                            $"{context.User.Identity.Name} unable to access {DownstreamRoute.ReRoute.UpstreamTemplate}")
+                            $"{context.User.Identity.Name} unable to access {DownstreamRoute.ReRoute.UpstreamPathTemplate.Value}")
                     });
                 }
             }

src/Ocelot/Configuration/Builder/AuthenticationOptionsBuilder.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+
+namespace Ocelot.Configuration.Builder
+{
+    public class AuthenticationOptionsBuilder
+    {
+
+        private string _provider;
+        private string _providerRootUrl;
+        private string _scopeName;
+        private string _scopeSecret;
+        private bool _requireHttps;
+        private List<string> _additionalScopes;
+
+        public AuthenticationOptionsBuilder WithProvider(string provider)
+        {
+            _provider = provider;
+            return this;
+        }
+
+        public AuthenticationOptionsBuilder WithProviderRootUrl(string providerRootUrl)
+        {
+            _providerRootUrl = providerRootUrl;
+            return this;
+        }
+
+        public AuthenticationOptionsBuilder WithScopeName(string scopeName)
+        {
+            _scopeName = scopeName;
+            return this;
+        }
+
+        public AuthenticationOptionsBuilder WithScopeSecret(string scopeSecret)
+        {
+            _scopeSecret = scopeSecret;
+            return this;
+        }
+
+        public AuthenticationOptionsBuilder WithRequireHttps(bool requireHttps)
+        {
+            _requireHttps = requireHttps;
+            return this;
+        }
+
+        public AuthenticationOptionsBuilder WithAdditionalScopes(List<string> additionalScopes)
+        {
+            _additionalScopes = additionalScopes;
+            return this;
+        }
+
+        public AuthenticationOptions Build()
+        {
+            return new AuthenticationOptions(_provider, _providerRootUrl, _scopeName, _requireHttps, _additionalScopes, _scopeSecret);
+        }
+    }
+}

src/Ocelot/Configuration/Builder/ReRouteBuilder.cs

@@ -1,23 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.Net.Http;
 using Ocelot.Values;
 
 namespace Ocelot.Configuration.Builder
 {
     public class ReRouteBuilder
     {
+        private AuthenticationOptions _authenticationOptions;
         private string _loadBalancerKey;
         private string _downstreamPathTemplate;
         private string _upstreamTemplate;
         private string _upstreamTemplatePattern;
         private string _upstreamHttpMethod;
         private bool _isAuthenticated;
-        private string _authenticationProvider;
-        private string _authenticationProviderUrl;
-        private string _scopeName;
-        private List<string> _additionalScopes;
-        private bool _requireHttps;
-        private string _scopeSecret;
         private List<ClaimToThing> _configHeaderExtractorProperties;
         private List<ClaimToThing> _claimToClaims;
         private Dictionary<string, string> _routeClaimRequirement;
@@ -33,11 +29,6 @@ namespace Ocelot.Configuration.Builder
         private string _loadBalancer;
         private ServiceProviderConfiguraion _serviceProviderConfiguraion;
 
-        public ReRouteBuilder()
-        {
-            _additionalScopes = new List<string>();
-        }
-
         public ReRouteBuilder WithLoadBalancer(string loadBalancer)
         {
             _loadBalancer = loadBalancer;
@@ -68,7 +59,7 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
-        public ReRouteBuilder WithUpstreamTemplate(string input)
+        public ReRouteBuilder WithUpstreamPathTemplate(string input)
         {
             _upstreamTemplate = input;
             return this;
@@ -96,42 +87,6 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
-        public ReRouteBuilder WithAuthenticationProvider(string input)
-        {
-            _authenticationProvider = input;
-            return this;
-        }
-
-        public ReRouteBuilder WithAuthenticationProviderUrl(string input)
-        {
-            _authenticationProviderUrl = input;
-            return this;
-        }
-
-        public ReRouteBuilder WithAuthenticationProviderScopeName(string input)
-        {
-            _scopeName = input;
-            return this;
-        }
-
-        public ReRouteBuilder WithAuthenticationProviderAdditionalScopes(List<string> input)
-        {
-            _additionalScopes = input;
-            return this;
-        }
-
-        public ReRouteBuilder WithRequireHttps(bool input)
-        {
-            _requireHttps = input;
-            return this;
-        }
-
-        public ReRouteBuilder WithScopeSecret(string input)
-        {
-            _scopeSecret = input;
-            return this;
-        }
-
         public ReRouteBuilder WithRequestIdKey(string input)
         {
             _requestIdHeaderKey = input;
@@ -192,13 +147,35 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
+        public ReRouteBuilder WithAuthenticationOptions(AuthenticationOptions authenticationOptions)
+        {
+            _authenticationOptions = authenticationOptions;
+            return this;
+        }
+
         public ReRoute Build()
         {
-            return new ReRoute(new PathTemplate(_downstreamPathTemplate), new PathTemplate(_upstreamTemplate), _upstreamHttpMethod, _upstreamTemplatePattern, 
-                _isAuthenticated, new AuthenticationOptions(_authenticationProvider, _authenticationProviderUrl, _scopeName, 
-                _requireHttps, _additionalScopes, _scopeSecret), _configHeaderExtractorProperties, _claimToClaims, _routeClaimRequirement, 
-                _isAuthorised, _claimToQueries, _requestIdHeaderKey, _isCached, _fileCacheOptions, _downstreamScheme, _loadBalancer,
-                _downstreamHost, _downstreamPort, _loadBalancerKey, _serviceProviderConfiguraion);
+            return new ReRoute(
+                new PathTemplate(_downstreamPathTemplate), 
+                new PathTemplate(_upstreamTemplate), 
+                new HttpMethod(_upstreamHttpMethod), 
+                _upstreamTemplatePattern, 
+                _isAuthenticated, 
+                _authenticationOptions,
+                _configHeaderExtractorProperties, 
+                _claimToClaims, 
+                _routeClaimRequirement, 
+                _isAuthorised, 
+                _claimToQueries, 
+                _requestIdHeaderKey, 
+                _isCached, 
+                _fileCacheOptions, 
+                _downstreamScheme, 
+                _loadBalancer,
+                _downstreamHost, 
+                _downstreamPort, 
+                _loadBalancerKey, 
+                _serviceProviderConfiguraion);
         }
     }
 }

src/Ocelot/Configuration/Builder/ServiceProviderConfiguraionBuilder.cs

@@ -1,4 +1,4 @@
-namespace Ocelot.Configuration
+namespace Ocelot.Configuration.Builder
 {
     public class ServiceProviderConfiguraionBuilder
     {

src/Ocelot/Configuration/Creator/FileOcelotConfigurationCreator.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Ocelot.Configuration.Builder;
 using Ocelot.Configuration.File;
 using Ocelot.Configuration.Parser;
 using Ocelot.Configuration.Validator;
@@ -88,7 +90,7 @@ namespace Ocelot.Configuration.Creator
         {
             var globalRequestIdConfiguration = !string.IsNullOrEmpty(globalConfiguration?.RequestIdKey);
 
-            var upstreamTemplate = BuildUpstreamTemplate(fileReRoute);
+            var upstreamTemplatePattern = BuildUpstreamTemplate(fileReRoute);
 
             var isAuthenticated = !string.IsNullOrEmpty(fileReRoute.AuthenticationOptions?.Provider);
 
@@ -104,7 +106,7 @@ namespace Ocelot.Configuration.Creator
                 && !string.IsNullOrEmpty(globalConfiguration?.ServiceDiscoveryProvider?.Provider);
 
             //note - not sure if this is the correct key, but this is probably the only unique key i can think of given my poor brain
-            var loadBalancerKey = $"{fileReRoute.UpstreamTemplate}{fileReRoute.UpstreamHttpMethod}";
+            var loadBalancerKey = $"{fileReRoute.UpstreamPathTemplate}{fileReRoute.UpstreamHttpMethod}";
 
             ReRoute reRoute;
 
@@ -132,20 +134,29 @@ namespace Ocelot.Configuration.Creator
                 var claimsToQueries = GetAddThingsToRequest(fileReRoute.AddQueriesToRequest);
 
                 reRoute = new ReRoute(new PathTemplate(fileReRoute.DownstreamPathTemplate),
-                    new PathTemplate(fileReRoute.UpstreamTemplate),
-                    fileReRoute.UpstreamHttpMethod, upstreamTemplate, isAuthenticated,
+                    new PathTemplate(fileReRoute.UpstreamPathTemplate),
+                    new HttpMethod(fileReRoute.UpstreamHttpMethod), upstreamTemplatePattern, isAuthenticated,
                     authOptionsForRoute, claimsToHeaders, claimsToClaims,
                     fileReRoute.RouteClaimsRequirement, isAuthorised, claimsToQueries,
                     requestIdKey, isCached, new CacheOptions(fileReRoute.FileCacheOptions.TtlSeconds)
                     , fileReRoute.DownstreamScheme,
                     fileReRoute.LoadBalancer, fileReRoute.DownstreamHost, fileReRoute.DownstreamPort, loadBalancerKey,
                     serviceProviderConfiguration);
+
+                //reRoute = new ReRouteBuilder()
+                  //          .WithDownstreamPathTemplate(fileReRoute.DownstreamPathTemplate)
+                    //        .WithUpstreamPathTemplate(fileReRoute.UpstreamPathTemplate)
+                      //      .WithUpstreamHttpMethod(fileReRoute.UpstreamHttpMethod)
+                        //    .WithUpstreamTemplatePattern(upstreamTemplatePattern)
+                          //  .WithIsAuthenticated(isAuthenticated)
+                            //.Build();
+                
             }
             else
             {
                 reRoute = new ReRoute(new PathTemplate(fileReRoute.DownstreamPathTemplate),
-                    new PathTemplate(fileReRoute.UpstreamTemplate),
-                    fileReRoute.UpstreamHttpMethod, upstreamTemplate, isAuthenticated,
+                    new PathTemplate(fileReRoute.UpstreamPathTemplate),
+                    new HttpMethod(fileReRoute.UpstreamHttpMethod), upstreamTemplatePattern, isAuthenticated,
                     null, new List<ClaimToThing>(), new List<ClaimToThing>(),
                     fileReRoute.RouteClaimsRequirement, isAuthorised, new List<ClaimToThing>(),
                     requestIdKey, isCached, new CacheOptions(fileReRoute.FileCacheOptions.TtlSeconds),
@@ -161,7 +172,7 @@ namespace Ocelot.Configuration.Creator
 
         private string BuildUpstreamTemplate(FileReRoute reRoute)
         {
-            var upstreamTemplate = reRoute.UpstreamTemplate;
+            var upstreamTemplate = reRoute.UpstreamPathTemplate;
 
             upstreamTemplate = upstreamTemplate.SetLastCharacterAs('/');
 

src/Ocelot/Configuration/File/FileReRoute.cs

@@ -15,7 +15,7 @@ namespace Ocelot.Configuration.File
         }
 
         public string DownstreamPathTemplate { get; set; }
-        public string UpstreamTemplate { get; set; }
+        public string UpstreamPathTemplate { get; set; }
         public string UpstreamHttpMethod { get; set; }
         public FileAuthenticationOptions AuthenticationOptions { get; set; }
         public Dictionary<string, string> AddHeadersToRequest { get; set; }

src/Ocelot/Configuration/ReRoute.cs

@@ -8,7 +8,7 @@ namespace Ocelot.Configuration
     public class ReRoute
     {
         public ReRoute(PathTemplate downstreamPathTemplate, 
-            PathTemplate upstreamTemplate, string upstreamHttpMethod, 
+            PathTemplate upstreamTemplate, HttpMethod upstreamHttpMethod, 
             string upstreamTemplatePattern, 
             bool isAuthenticated, AuthenticationOptions authenticationOptions, 
             List<ClaimToThing> configurationHeaderExtractorProperties, 
@@ -25,8 +25,8 @@ namespace Ocelot.Configuration
             DownstreamHost = downstreamHost;
             DownstreamPort = downstreamPort;
             DownstreamPathTemplate = downstreamPathTemplate;
-            UpstreamTemplate = upstreamTemplate;
-            UpstreamHttpMethod = new HttpMethod(upstreamHttpMethod);
+            UpstreamPathTemplate = upstreamTemplate;
+            UpstreamHttpMethod = upstreamHttpMethod;
             UpstreamTemplatePattern = upstreamTemplatePattern;
             IsAuthenticated = isAuthenticated;
             AuthenticationOptions = authenticationOptions;
@@ -46,7 +46,7 @@ namespace Ocelot.Configuration
 
         public string LoadBalancerKey {get;private set;}
         public PathTemplate DownstreamPathTemplate { get; private set; }
-        public PathTemplate UpstreamTemplate { get; private set; }
+        public PathTemplate UpstreamPathTemplate { get; private set; }
         public string UpstreamTemplatePattern { get; private set; }
         public HttpMethod UpstreamHttpMethod { get; private set; }
         public bool IsAuthenticated { get; private set; }

src/Ocelot/Configuration/Validator/FileConfigurationValidator.cs

@@ -54,7 +54,7 @@ namespace Ocelot.Configuration.Validator
                     continue;
                 }
 
-                var error = new UnsupportedAuthenticationProviderError($"{reRoute.AuthenticationOptions?.Provider} is unsupported authentication provider, upstream template is {reRoute.UpstreamTemplate}, upstream method is {reRoute.UpstreamHttpMethod}");
+                var error = new UnsupportedAuthenticationProviderError($"{reRoute.AuthenticationOptions?.Provider} is unsupported authentication provider, upstream template is {reRoute.UpstreamPathTemplate}, upstream method is {reRoute.UpstreamHttpMethod}");
                 errors.Add(error);
             }
 
@@ -94,18 +94,18 @@ namespace Ocelot.Configuration.Validator
         private ConfigurationValidationResult CheckForDupliateReRoutes(FileConfiguration configuration)
         {
             var hasDupes = configuration.ReRoutes
-                   .GroupBy(x => new { x.UpstreamTemplate, x.UpstreamHttpMethod }).Any(x => x.Skip(1).Any());
+                   .GroupBy(x => new { x.UpstreamPathTemplate, x.UpstreamHttpMethod }).Any(x => x.Skip(1).Any());
 
             if (!hasDupes)
             {
                 return new ConfigurationValidationResult(false);
             }
 
-            var dupes = configuration.ReRoutes.GroupBy(x => new { x.UpstreamTemplate, x.UpstreamHttpMethod })
+            var dupes = configuration.ReRoutes.GroupBy(x => new { x.UpstreamPathTemplate, x.UpstreamHttpMethod })
                                .Where(x => x.Skip(1).Any());
 
             var errors = dupes
-                .Select(d => new DownstreamPathTemplateAlreadyUsedError(string.Format("Duplicate DownstreamPath: {0}", d.Key.UpstreamTemplate)))
+                .Select(d => new DownstreamPathTemplateAlreadyUsedError(string.Format("Duplicate DownstreamPath: {0}", d.Key.UpstreamPathTemplate)))
                 .Cast<Error>()
                 .ToList();
 

src/Ocelot/DownstreamRouteFinder/Finder/DownstreamRouteFinder.cs

@@ -34,7 +34,7 @@ namespace Ocelot.DownstreamRouteFinder.Finder
 
                 if (urlMatch.Data.Match)
                 {
-                    var templateVariableNameAndValues = _urlPathPlaceholderNameAndValueFinder.Find(upstreamUrlPath, reRoute.UpstreamTemplate.Value);
+                    var templateVariableNameAndValues = _urlPathPlaceholderNameAndValueFinder.Find(upstreamUrlPath, reRoute.UpstreamPathTemplate.Value);
 
                     return new OkResponse<DownstreamRoute>(new DownstreamRoute(templateVariableNameAndValues.Data, reRoute));
                 }