#360 Routing based on request header

docs/features/configuration.rst

@@ -24,6 +24,7 @@ Here is an example Route configuration. You don't need to set all of these thing
     "UpstreamHttpMethod": [ "Get" ],
     "DownstreamHttpMethod": "",
     "DownstreamHttpVersion": "",
+    "UpstreamHeaderTemplates": {},
     "AddHeadersToRequest": {},
     "AddClaimsToRequest": {},
     "RouteClaimsRequirement": {},

docs/features/routing.rst

@@ -154,6 +154,62 @@ The Route above will only be matched when the ``Host`` header value is ``somedom
 If you do not set **UpstreamHost** on a Route then any ``Host`` header will match it.
 This means that if you have two Routes that are the same, apart from the **UpstreamHost**, where one is null and the other set Ocelot will favour the one that has been set. 
 
+Upstream Headers
+^^^^^^^^^^^^^^^^
+
+Additionally to routing by UpstreamPathTemplate, you can define UpstreamHeaderTemplates. Then to match a route, all the headers from this section must exist in the request headers.
+
+The example:
+
+.. code-block:: json
+
+    {
+        "DownstreamPathTemplate": "/",
+        "DownstreamScheme": "https",
+        "DownstreamHostAndPorts": [
+                {
+                    "Host": "10.0.10.1",
+                    "Port": 80,
+                }
+            ],
+        "UpstreamPathTemplate": "/",
+        "UpstreamHttpMethod": [ "Get" ],
+        "UpstreamHeaderTemplates": {
+            "country": "uk",
+            "version": "v1"
+        }
+    }
+
+In this case the route will be matched only if a request has both headers set to the configured values.
+
+You can use placeholders in your UpstreamHeaderTemplates in the following way:
+
+.. code-block:: json
+
+    {
+        "DownstreamPathTemplate": "/{versionnumber}/api",
+        "DownstreamScheme": "https",
+        "DownstreamHostAndPorts": [
+                {
+                    "Host": "10.0.10.1",
+                    "Port": 80,
+                }
+            ],
+        "UpstreamPathTemplate": "/api",
+        "UpstreamHttpMethod": [ "Get" ],
+        "UpstreamHeaderTemplates": {
+            "version": "{header:versionnumber}"
+        }
+    }
+
+In this case the whole value for the request header "version" will be placed into the DownstreamPathTemplate. If you need, you can specify more complex upstream header template with placeholders like e.g. "version-{header:version}_country-{header:country}".
+
+Placeholders do not have to exist in DownstreamPathTemplate. This case may be used to require specific header no matter what the value it contains.
+
+UpstreamHeaderTemplates section can be used also for Aggregates.
+
+This feature was requested in `Issue 360 <https://github.com/ThreeMammals/Ocelot/pull/360>`_ .
+
 Priority
 --------
 

src/Ocelot/Configuration/Builder/DownstreamRouteBuilder.cs

@@ -40,13 +40,14 @@ public class DownstreamRouteBuilder
     private SecurityOptions _securityOptions;
     private string _downstreamHttpMethod;
     private Version _downstreamHttpVersion;
+    private Dictionary<string, UpstreamHeaderTemplate> _upstreamHeaders;
 
     public DownstreamRouteBuilder()
     {
-        _downstreamAddresses = new List<DownstreamHostAndPort>();
-        _delegatingHandlers = new List<string>();
-        _addHeadersToDownstream = new List<AddHeader>();
-        _addHeadersToUpstream = new List<AddHeader>();
+        _downstreamAddresses = new();
+        _delegatingHandlers = new();
+        _addHeadersToDownstream = new();
+        _addHeadersToUpstream = new();
     }
 
     public DownstreamRouteBuilder WithDownstreamAddresses(List<DownstreamHostAndPort> downstreamAddresses)
@@ -87,7 +88,9 @@ public DownstreamRouteBuilder WithUpstreamPathTemplate(UpstreamPathTemplate inpu
 
     public DownstreamRouteBuilder WithUpstreamHttpMethod(List<string> input)
     {
-        _upstreamHttpMethod = (input.Count == 0) ? new List<HttpMethod>() : input.Select(x => new HttpMethod(x.Trim())).ToList();
+        _upstreamHttpMethod = input.Count > 0
+            ? input.Select(x => new HttpMethod(x.Trim())).ToList()
+            : new();
         return this;
     }
 
@@ -259,6 +262,12 @@ public DownstreamRouteBuilder WithDownstreamHttpVersion(Version downstreamHttpVe
         return this;
     }
 
+    public DownstreamRouteBuilder WithUpstreamHeaders(Dictionary<string, UpstreamHeaderTemplate> input)
+    {
+        _upstreamHeaders = input;
+        return this;
+    }
+
     public DownstreamRoute Build()
     {
         return new DownstreamRoute(
@@ -295,6 +304,7 @@ public DownstreamRoute Build()
             _dangerousAcceptAnyServerCertificateValidator,
             _securityOptions,
             _downstreamHttpMethod,
-            _downstreamHttpVersion);
+            _downstreamHttpVersion,
+            _upstreamHeaders);
     }
 }

src/Ocelot/Configuration/Builder/RouteBuilder.cs

@@ -10,7 +10,8 @@ public class RouteBuilder
         private string _upstreamHost;
         private List<DownstreamRoute> _downstreamRoutes;
         private List<AggregateRouteConfig> _downstreamRoutesConfig;
-        private string _aggregator;
+        private string _aggregator;
+        private Dictionary<string, UpstreamHeaderTemplate> _upstreamHeaders;
 
         public RouteBuilder()
         {
@@ -58,6 +59,12 @@ public RouteBuilder WithAggregator(string aggregator)
         {
             _aggregator = aggregator;
             return this;
+        }
+
+        public RouteBuilder WithUpstreamHeaders(Dictionary<string, UpstreamHeaderTemplate> upstreamHeaders)
+        {
+            _upstreamHeaders = upstreamHeaders;
+            return this;
         }
 
         public Route Build()
@@ -68,7 +75,8 @@ public Route Build()
                 _upstreamHttpMethod,
                 _upstreamTemplatePattern,
                 _upstreamHost,
-                _aggregator
+                _aggregator,
+                _upstreamHeaders
                 );
         }
     }

src/Ocelot/Configuration/Creator/AggregatesCreator.cs

@@ -5,11 +5,13 @@ namespace Ocelot.Configuration.Creator
 {
     public class AggregatesCreator : IAggregatesCreator
     {
-        private readonly IUpstreamTemplatePatternCreator _creator;
+        private readonly IUpstreamTemplatePatternCreator _creator;
+        private readonly IUpstreamHeaderTemplatePatternCreator _headerCreator;
 
-        public AggregatesCreator(IUpstreamTemplatePatternCreator creator)
+        public AggregatesCreator(IUpstreamTemplatePatternCreator creator, IUpstreamHeaderTemplatePatternCreator headerCreator)
         {
-            _creator = creator;
+            _creator = creator;
+            _headerCreator = headerCreator;
         }
 
         public List<Route> Create(FileConfiguration fileConfiguration, List<Route> routes)
@@ -35,15 +37,17 @@ private Route SetUpAggregateRoute(IEnumerable<Route> routes, FileAggregateRoute
                 applicableRoutes.Add(downstreamRoute);
             }
 
-            var upstreamTemplatePattern = _creator.Create(aggregateRoute);
+            var upstreamTemplatePattern = _creator.Create(aggregateRoute);
+            var upstreamHeaderTemplates = _headerCreator.Create(aggregateRoute);
 
             var route = new RouteBuilder()
                 .WithUpstreamHttpMethod(aggregateRoute.UpstreamHttpMethod)
                 .WithUpstreamPathTemplate(upstreamTemplatePattern)
                 .WithDownstreamRoutes(applicableRoutes)
                 .WithAggregateRouteConfig(aggregateRoute.RouteKeysConfig)
                 .WithUpstreamHost(aggregateRoute.UpstreamHost)
-                .WithAggregator(aggregateRoute.Aggregator)
+                .WithAggregator(aggregateRoute.Aggregator)
+                .WithUpstreamHeaders(upstreamHeaderTemplates)
                 .Build();
 
             return route;

src/Ocelot/Configuration/Creator/IUpstreamHeaderTemplatePatternCreator.cs

@@ -0,0 +1,17 @@
+using Ocelot.Configuration.File;
+using Ocelot.Values;
+
+namespace Ocelot.Configuration.Creator;
+
+/// <summary>
+/// Ocelot feature: <see href="https://github.com/ThreeMammals/Ocelot/blob/develop/docs/features/routing.rst#upstream-headers">Routing based on request header</see>.
+/// </summary>
+public interface IUpstreamHeaderTemplatePatternCreator
+{
+    /// <summary>
+    /// Creates upstream templates based on route headers.
+    /// </summary>
+    /// <param name="route">The route info.</param>
+    /// <returns>A <see cref="Dictionary{TKey, TValue}"/> object where TKey is <see langword="string"/>, TValue is <see cref="UpstreamHeaderTemplate"/>.</returns>
+    Dictionary<string, UpstreamHeaderTemplate> Create(IRoute route);
+}

src/Ocelot/Configuration/Creator/RoutesCreator.cs

@@ -1,7 +1,7 @@
 using Ocelot.Cache;
 using Ocelot.Configuration.Builder;
 using Ocelot.Configuration.File;
-
+
 namespace Ocelot.Configuration.Creator
 {
     public class RoutesCreator : IRoutesCreator
@@ -10,6 +10,7 @@ public class RoutesCreator : IRoutesCreator
         private readonly IClaimsToThingCreator _claimsToThingCreator;
         private readonly IAuthenticationOptionsCreator _authOptionsCreator;
         private readonly IUpstreamTemplatePatternCreator _upstreamTemplatePatternCreator;
+        private readonly IUpstreamHeaderTemplatePatternCreator _upstreamHeaderTemplatePatternCreator;
         private readonly IRequestIdKeyCreator _requestIdKeyCreator;
         private readonly IQoSOptionsCreator _qosOptionsCreator;
         private readonly IRouteOptionsCreator _fileRouteOptionsCreator;
@@ -37,8 +38,8 @@ public RoutesCreator(
             ILoadBalancerOptionsCreator loadBalancerOptionsCreator,
             IRouteKeyCreator routeKeyCreator,
             ISecurityOptionsCreator securityOptionsCreator,
-            IVersionCreator versionCreator
-            )
+            IVersionCreator versionCreator,
+            IUpstreamHeaderTemplatePatternCreator upstreamHeaderTemplatePatternCreator)
         {
             _routeKeyCreator = routeKeyCreator;
             _loadBalancerOptionsCreator = loadBalancerOptionsCreator;
@@ -56,6 +57,7 @@ IVersionCreator versionCreator
             _loadBalancerOptionsCreator = loadBalancerOptionsCreator;
             _securityOptionsCreator = securityOptionsCreator;
             _versionCreator = versionCreator;
+            _upstreamHeaderTemplatePatternCreator = upstreamHeaderTemplatePatternCreator;
         }
 
         public List<Route> Create(FileConfiguration fileConfiguration)
@@ -150,13 +152,15 @@ private DownstreamRoute SetUpDownstreamRoute(FileRoute fileRoute, FileGlobalConf
 
         private Route SetUpRoute(FileRoute fileRoute, DownstreamRoute downstreamRoutes)
         {
-            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileRoute);
+            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileRoute);
+            var upstreamHeaderTemplates = _upstreamHeaderTemplatePatternCreator.Create(fileRoute);
 
             var route = new RouteBuilder()
                 .WithUpstreamHttpMethod(fileRoute.UpstreamHttpMethod)
                 .WithUpstreamPathTemplate(upstreamTemplatePattern)
                 .WithDownstreamRoute(downstreamRoutes)
-                .WithUpstreamHost(fileRoute.UpstreamHost)
+                .WithUpstreamHost(fileRoute.UpstreamHost)
+                .WithUpstreamHeaders(upstreamHeaderTemplates)
                 .Build();
 
             return route;

src/Ocelot/Configuration/Creator/UpstreamHeaderTemplatePatternCreator.cs

@@ -0,0 +1,49 @@
+using Ocelot.Configuration.File;
+using Ocelot.Values;
+
+namespace Ocelot.Configuration.Creator;
+
+/// <summary>
+/// Default creator of upstream templates based on route headers.
+/// </summary>
+/// <remarks>Ocelot feature: Routing based on request header.</remarks>
+public partial class UpstreamHeaderTemplatePatternCreator : IUpstreamHeaderTemplatePatternCreator
+{
+#if NET7_0_OR_GREATER
+    [GeneratedRegex(@"(\{header:.*?\})", RegexOptions.IgnoreCase | RegexOptions.Singleline, "en-US")]
+    private static partial Regex RegExPlaceholders();
+#else
+    private static readonly Regex RegExPlaceholdersVar = new(@"(\{header:.*?\})", RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromMilliseconds(1000));
+    private static Regex RegExPlaceholders() => RegExPlaceholdersVar;
+#endif
+
+    public Dictionary<string, UpstreamHeaderTemplate> Create(IRoute route)
+    {
+        var result = new Dictionary<string, UpstreamHeaderTemplate>();
+
+        foreach (var headerTemplate in route.UpstreamHeaderTemplates)
+        {
+            var headerTemplateValue = headerTemplate.Value;
+            var matches = RegExPlaceholders().Matches(headerTemplateValue);
+
+            if (matches.Count > 0)
+            {
+                var placeholders = matches.Select(m => m.Groups[1].Value).ToArray();
+                for (int i = 0; i < placeholders.Length; i++)
+                {
+                    var indexOfPlaceholder = headerTemplateValue.IndexOf(placeholders[i]);
+                    var placeholderName = placeholders[i][8..^1]; // remove "{header:" and "}"
+                    headerTemplateValue = headerTemplateValue.Replace(placeholders[i], $"(?<{placeholderName}>.+)");
+                }
+            }
+
+            var template = route.RouteIsCaseSensitive
+                ? $"^{headerTemplateValue}$"
+                : $"^(?i){headerTemplateValue}$"; // ignore case
+
+            result.Add(headerTemplate.Key, new(template, headerTemplate.Value));
+        }
+
+        return result;
+    }
+}

src/Ocelot/Configuration/DownstreamRoute.cs

@@ -39,7 +39,8 @@ public DownstreamRoute(
             bool dangerousAcceptAnyServerCertificateValidator,
             SecurityOptions securityOptions,
             string downstreamHttpMethod,
-            Version downstreamHttpVersion)
+            Version downstreamHttpVersion,
+            Dictionary<string, UpstreamHeaderTemplate> upstreamHeaders)
         {
             DangerousAcceptAnyServerCertificateValidator = dangerousAcceptAnyServerCertificateValidator;
             AddHeadersToDownstream = addHeadersToDownstream;
@@ -74,7 +75,8 @@ public DownstreamRoute(
             AddHeadersToUpstream = addHeadersToUpstream;
             SecurityOptions = securityOptions;
             DownstreamHttpMethod = downstreamHttpMethod;
-            DownstreamHttpVersion = downstreamHttpVersion;
+            DownstreamHttpVersion = downstreamHttpVersion;
+            UpstreamHeaders = upstreamHeaders ?? new();
         }
 
         public string Key { get; }
@@ -110,6 +112,7 @@ public DownstreamRoute(
         public bool DangerousAcceptAnyServerCertificateValidator { get; }
         public SecurityOptions SecurityOptions { get; }
         public string DownstreamHttpMethod { get; }
-        public Version DownstreamHttpVersion { get; }
+        public Version DownstreamHttpVersion { get; }
+        public Dictionary<string, UpstreamHeaderTemplate> UpstreamHeaders { get; }
     }
 }

src/Ocelot/Configuration/File/FileAggregateRoute.cs

@@ -1,3 +1,5 @@
+using Microsoft.AspNetCore.Http;
+
 namespace Ocelot.Configuration.File
 {
     public class FileAggregateRoute : IRoute
@@ -10,8 +12,15 @@ public class FileAggregateRoute : IRoute
         public string Aggregator { get; set; }
 
         // Only supports GET..are you crazy!! POST, PUT WOULD BE CRAZY!! :)
-        public List<string> UpstreamHttpMethod => new() { "Get" };
-
-        public int Priority { get; set; } = 1;
+        public List<string> UpstreamHttpMethod => new() { HttpMethods.Get };
+        public Dictionary<string, string> UpstreamHeaderTemplates { get; set; }
+        public int Priority { get; set; } = 1;
+
+        public FileAggregateRoute()
+        {
+            RouteKeys = new();
+            RouteKeysConfig = new();
+            UpstreamHeaderTemplates = new();
+        }
     }
 }

src/Ocelot/Configuration/File/FileRoute.cs

@@ -19,7 +19,8 @@ public FileRoute()
             QoSOptions = new FileQoSOptions();
             RateLimitOptions = new FileRateLimitRule();
             RouteClaimsRequirement = new Dictionary<string, string>();
-            SecurityOptions = new FileSecurityOptions();
+            SecurityOptions = new FileSecurityOptions();
+            UpstreamHeaderTemplates = new Dictionary<string, string>();
             UpstreamHeaderTransform = new Dictionary<string, string>();
             UpstreamHttpMethod = new List<string>();
         }
@@ -60,6 +61,7 @@ public FileRoute(FileRoute from)
         public string UpstreamHost { get; set; }
         public List<string> UpstreamHttpMethod { get; set; }
         public string UpstreamPathTemplate { get; set; }
+        public Dictionary<string, string> UpstreamHeaderTemplates { get; set; }
 
         /// <summary>
         /// Clones this object by making a deep copy.
@@ -101,6 +103,7 @@ public static void DeepCopy(FileRoute from, FileRoute to)
             to.ServiceName = from.ServiceName;
             to.ServiceNamespace = from.ServiceNamespace;
             to.Timeout = from.Timeout;
+            to.UpstreamHeaderTemplates = new(from.UpstreamHeaderTemplates);
             to.UpstreamHeaderTransform = new(from.UpstreamHeaderTransform);
             to.UpstreamHost = from.UpstreamHost;
             to.UpstreamHttpMethod = new(from.UpstreamHttpMethod);