Feature/transform headers (ThreeMammals#204)

* New feature that lets a user do find and replace on an upstream header

* can transform downstream and upstream headers, not sure if interface is good

* can replace location header with placeholder

* added some syntax

docs/features/headerstransformation.rst

@@ -0,0 +1,70 @@
+Headers Transformation
+=====================
+
+Ocelot allows the user to transform headers pre and post downstream request. At the moment Ocelot only supports find and replace. This feature was requested `GitHub #190 <https://github.com/TomPallister/Ocelot/issues/190>`_ and I decided that it was going to be useful in various ways.
+
+Syntax
+^^^^^^
+
+In order to transform a header first we specify the header key and then the type of transform we want e.g.
+
+.. code-block:: json
+
+    "Test": "http://www.bbc.co.uk/, http://ocelot.com/"
+
+The key is "Test" and the value is "http://www.bbc.co.uk/, http://ocelot.com/". The value is saying replace http://www.bbc.co.uk/ with http://ocelot.com/. The syntax is {find}, {replace}. Hopefully pretty simple. There are examples below that explain more.
+
+Pre Downstream Request
+^^^^^^^^^^^^^^^^^^^^^^
+
+Add the following to a ReRoute in configuration.json in order to replace http://www.bbc.co.uk/ with http://ocelot.com/. This header will be changed before the request downstream and will be sent to the downstream server.
+
+.. code-block:: json
+
+     "UpstreamHeaderTransform": {
+        "Test": "http://www.bbc.co.uk/, http://ocelot.com/"
+    },
+
+Post Downstream Request
+^^^^^^^^^^^^^^^^^^^^^^
+
+Add the following to a ReRoute in configuration.json in order to replace http://www.bbc.co.uk/ with http://ocelot.com/. This transformation will take place after Ocelot has received the response from the downstream service.
+
+.. code-block:: json
+
+    "DownstreamHeaderTransform": {
+        "Test": "http://www.bbc.co.uk/, http://ocelot.com/"
+    },
+
+Placeholders
+^^^^^^^^^^^^
+
+Ocelot allows placeholders that can be used in header transformation. At the moment there is only one placeholder.
+
+{BaseUrl} - This will use Ocelot's base url e.g. http://localhost:5000 as its value.
+
+Handling 302 Redirects
+^^^^^^^^^^^^^^^^^^^^^^
+Ocelot will by default automatically follow redirects however if you want to return the location header to the client you might want to change the location to be Ocelot not the downstream service. Ocelot allows this with the following configuration.
+
+.. code-block:: json
+
+    "DownstreamHeaderTransform": {
+        "Location": "http://www.bbc.co.uk/, http://ocelot.com/"
+    },
+     "HttpHandlerOptions": {
+        "AllowAutoRedirect": false,
+    },
+
+or you could use the BaseUrl placeholder.
+
+.. code-block:: json
+
+    "DownstreamHeaderTransform": {
+        "Location": "http://localhost:6773, {BaseUrl}"
+    },
+     "HttpHandlerOptions": {
+        "AllowAutoRedirect": false,
+    },
+
+Ocelot will not try and replace the location header returned by the downstream service with its own URL.

docs/index.rst

@@ -27,6 +27,7 @@ Thanks for taking a look at the Ocelot documentation. Please use the left hand n
    features/raft
    features/caching
    features/qualityofservice
+   features/headerstransformation 
    features/claimstransformation 
    features/logging
    features/requestid

src/Ocelot/Configuration/Builder/ReRouteBuilder.cs

@@ -36,6 +36,9 @@ public class ReRouteBuilder
         private bool _useServiceDiscovery;
         private string _serviceName;
 
+        private List<HeaderFindAndReplace> _upstreamHeaderFindAndReplace;
+        private List<HeaderFindAndReplace> _downstreamHeaderFindAndReplace;
+
         public ReRouteBuilder WithLoadBalancer(string loadBalancer)
         {
           _loadBalancer = loadBalancer;
@@ -198,6 +201,18 @@ public ReRouteBuilder WithServiceName(string serviceName)
             return this;
         }
 
+        public ReRouteBuilder WithUpstreamHeaderFindAndReplace(List<HeaderFindAndReplace> upstreamHeaderFindAndReplace)
+        {
+            _upstreamHeaderFindAndReplace = upstreamHeaderFindAndReplace;
+            return this;
+        }
+
+        public ReRouteBuilder WithDownstreamHeaderFindAndReplace(List<HeaderFindAndReplace> downstreamHeaderFindAndReplace)
+        {
+            _downstreamHeaderFindAndReplace = downstreamHeaderFindAndReplace;
+            return this;
+        }
+
         public ReRoute Build()
         {
             return new ReRoute(
@@ -226,7 +241,9 @@ public ReRoute Build()
                 _rateLimitOptions,
                 _httpHandlerOptions,
                 _useServiceDiscovery,
-                _serviceName);
+                _serviceName,
+                _upstreamHeaderFindAndReplace,
+                _downstreamHeaderFindAndReplace);
         }
     }
 }

src/Ocelot/Configuration/Creator/FileOcelotConfigurationCreator.cs

@@ -37,6 +37,7 @@ public class FileOcelotConfigurationCreator : IOcelotConfigurationCreator
         private readonly IRegionCreator _regionCreator;
         private readonly IHttpHandlerOptionsCreator _httpHandlerOptionsCreator;
         private readonly IAdministrationPath _adminPath;
+        private readonly IHeaderFindAndReplaceCreator _headerFAndRCreator;
 
 
         public FileOcelotConfigurationCreator(
@@ -53,9 +54,11 @@ public FileOcelotConfigurationCreator(
             IRateLimitOptionsCreator rateLimitOptionsCreator,
             IRegionCreator regionCreator,
             IHttpHandlerOptionsCreator httpHandlerOptionsCreator,
-            IAdministrationPath adminPath
+            IAdministrationPath adminPath,
+            IHeaderFindAndReplaceCreator headerFAndRCreator
             )
         {
+            _headerFAndRCreator = headerFAndRCreator;
             _adminPath = adminPath;
             _regionCreator = regionCreator;
             _rateLimitOptionsCreator = rateLimitOptionsCreator;
@@ -128,6 +131,8 @@ private ReRoute SetUpReRoute(FileReRoute fileReRoute, FileGlobalConfiguration gl
 
             var httpHandlerOptions = _httpHandlerOptionsCreator.Create(fileReRoute);
 
+            var hAndRs = _headerFAndRCreator.Create(fileReRoute);
+
             var reRoute = new ReRouteBuilder()
                 .WithDownstreamPathTemplate(fileReRoute.DownstreamPathTemplate)
                 .WithUpstreamPathTemplate(fileReRoute.UpstreamPathTemplate)
@@ -155,6 +160,8 @@ private ReRoute SetUpReRoute(FileReRoute fileReRoute, FileGlobalConfiguration gl
                 .WithHttpHandlerOptions(httpHandlerOptions)
                 .WithServiceName(fileReRoute.ServiceName)
                 .WithUseServiceDiscovery(fileReRoute.UseServiceDiscovery)
+                .WithUpstreamHeaderFindAndReplace(hAndRs.Upstream)
+                .WithDownstreamHeaderFindAndReplace(hAndRs.Downstream)
                 .Build();
 
             return reRoute;

src/Ocelot/Configuration/Creator/HeaderFindAndReplaceCreator.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using Ocelot.Configuration.File;
+using Ocelot.Middleware;
+
+namespace Ocelot.Configuration.Creator
+{
+    public class HeaderFindAndReplaceCreator : IHeaderFindAndReplaceCreator
+    {
+        private IBaseUrlFinder _finder;
+        private Dictionary<string, Func<string>> _placeholders;
+
+        public HeaderFindAndReplaceCreator(IBaseUrlFinder finder)
+        {
+            _finder = finder;
+            _placeholders = new Dictionary<string, Func<string>>();
+            _placeholders.Add("{BaseUrl}", () => {
+                return _finder.Find();
+            });
+        }
+
+        public HeaderTransformations Create(FileReRoute fileReRoute)
+        {
+            var upstream = new List<HeaderFindAndReplace>();
+
+            foreach(var input in fileReRoute.UpstreamHeaderTransform)
+            {
+                var hAndr = Map(input);
+                upstream.Add(hAndr);
+            }
+
+            var downstream = new List<HeaderFindAndReplace>();
+
+            foreach(var input in fileReRoute.DownstreamHeaderTransform)
+            {
+                var hAndr = Map(input);
+                downstream.Add(hAndr);
+            }
+
+            return new HeaderTransformations(upstream, downstream);
+        }
+
+        private HeaderFindAndReplace Map(KeyValuePair<string,string> input)
+        {
+            var findAndReplace = input.Value.Split(",");
+
+            var replace = findAndReplace[1].TrimStart();
+
+            var startOfPlaceholder = replace.IndexOf("{");
+            if(startOfPlaceholder > -1)
+            {
+                var endOfPlaceholder = replace.IndexOf("}", startOfPlaceholder);
+
+                var placeholder = replace.Substring(startOfPlaceholder, startOfPlaceholder + (endOfPlaceholder + 1));
+
+                if(_placeholders.ContainsKey(placeholder))
+                {
+                    var value = _placeholders[placeholder].Invoke();
+                    replace = replace.Replace(placeholder, value);
+                }
+            }
+
+            var hAndr = new HeaderFindAndReplace(input.Key, findAndReplace[0], replace, 0);
+
+            return hAndr;
+        }
+    }
+}

src/Ocelot/Configuration/Creator/HeaderTransformations.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace Ocelot.Configuration.Creator
+{
+    public class HeaderTransformations
+    {
+        public HeaderTransformations(List<HeaderFindAndReplace> upstream, List<HeaderFindAndReplace> downstream)
+        {
+            Upstream = upstream;
+            Downstream = downstream;
+        }
+
+        public List<HeaderFindAndReplace> Upstream {get;private set;}
+
+        public List<HeaderFindAndReplace> Downstream {get;private set;}
+    }
+}

src/Ocelot/Configuration/Creator/IHeaderFindAndReplaceCreator.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public interface IHeaderFindAndReplaceCreator
+    {
+        HeaderTransformations Create(FileReRoute fileReRoute);
+    }
+}

src/Ocelot/Configuration/File/FileReRoute.cs

@@ -11,17 +11,21 @@ public FileReRoute()
             AddClaimsToRequest = new Dictionary<string, string>();
             RouteClaimsRequirement = new Dictionary<string, string>();
             AddQueriesToRequest = new Dictionary<string, string>();
+            DownstreamHeaderTransform = new Dictionary<string, string>();
             FileCacheOptions = new FileCacheOptions();
             QoSOptions = new FileQoSOptions();
             RateLimitOptions = new FileRateLimitRule();
             AuthenticationOptions = new FileAuthenticationOptions();
             HttpHandlerOptions = new FileHttpHandlerOptions();
+            UpstreamHeaderTransform = new Dictionary<string, string>();
         }
 
         public string DownstreamPathTemplate { get; set; }
         public string UpstreamPathTemplate { get; set; }
         public List<string> UpstreamHttpMethod { get; set; }
         public Dictionary<string, string> AddHeadersToRequest { get; set; }
+        public Dictionary<string, string> UpstreamHeaderTransform { get; set; }
+        public Dictionary<string, string> DownstreamHeaderTransform { get; set; }
         public Dictionary<string, string> AddClaimsToRequest { get; set; }
         public Dictionary<string, string> RouteClaimsRequirement { get; set; }
         public Dictionary<string, string> AddQueriesToRequest { get; set; }

src/Ocelot/Configuration/HeaderFindAndReplace.cs

@@ -0,0 +1,20 @@
+namespace Ocelot.Configuration
+{
+    public class HeaderFindAndReplace
+    {
+        public HeaderFindAndReplace(string key, string find, string replace, int index)
+        {
+            Key = key;
+            Find = find;
+            Replace = replace;
+            Index = index;
+        }
+
+        public string Key {get;}
+        public string Find {get;}
+        public string Replace {get;}
+
+        // only index 0 for now..
+        public int Index {get;}
+    }
+}

src/Ocelot/Configuration/ReRoute.cs

@@ -32,8 +32,12 @@ public ReRoute(PathTemplate downstreamPathTemplate,
             RateLimitOptions ratelimitOptions,
             HttpHandlerOptions httpHandlerOptions,
             bool useServiceDiscovery,
-            string serviceName)
+            string serviceName,
+            List<HeaderFindAndReplace> upstreamHeadersFindAndReplace,
+            List<HeaderFindAndReplace> downstreamHeadersFindAndReplace)
         {
+            DownstreamHeadersFindAndReplace = downstreamHeadersFindAndReplace;
+            UpstreamHeadersFindAndReplace = upstreamHeadersFindAndReplace;
             ServiceName = serviceName;
             UseServiceDiscovery = useServiceDiscovery;
             ReRouteKey = reRouteKey;
@@ -91,5 +95,8 @@ public ReRoute(PathTemplate downstreamPathTemplate,
         public HttpHandlerOptions HttpHandlerOptions { get; private set; }
         public bool UseServiceDiscovery {get;private set;}
         public string ServiceName {get;private set;}
+        public List<HeaderFindAndReplace> UpstreamHeadersFindAndReplace {get;private set;}
+        public List<HeaderFindAndReplace> DownstreamHeadersFindAndReplace {get;private set;}
+
     }
 }

src/Ocelot/DependencyInjection/OcelotBuilder.cs

@@ -75,6 +75,9 @@ public OcelotBuilder(IServiceCollection services, IConfiguration configurationRo
 
             //add ocelot services...
             _services.Configure<FileConfiguration>(configurationRoot);
+            _services.TryAddSingleton<IHttpResponseHeaderReplacer, HttpResponseHeaderReplacer>();
+            _services.TryAddSingleton<IHttpContextRequestHeaderReplacer, HttpContextRequestHeaderReplacer>();
+            _services.TryAddSingleton<IHeaderFindAndReplaceCreator, HeaderFindAndReplaceCreator>();
             _services.TryAddSingleton<IOcelotConfigurationCreator, FileOcelotConfigurationCreator>();
             _services.TryAddSingleton<IOcelotConfigurationRepository, InMemoryOcelotConfigurationRepository>();
             _services.TryAddSingleton<IConfigurationValidator, FileConfigurationFluentValidator>();

src/Ocelot/DownstreamRouteFinder/DownstreamRoute.cs

@@ -13,5 +13,6 @@ public DownstreamRoute(List<PlaceholderNameAndValue> templatePlaceholderNameAndV
         }
         public List<PlaceholderNameAndValue> TemplatePlaceholderNameAndValues { get; private set; }
         public ReRoute ReRoute { get; private set; }
+        public object UpstreamHeadersFindAndReplace {get;private set;}
     }
 }

src/Ocelot/Errors/Middleware/ExceptionHandlerMiddleware.cs

@@ -37,7 +37,7 @@ public ExceptionHandlerMiddleware(RequestDelegate next,
         public async Task Invoke(HttpContext context)
         {
             try
-            {
+            {               
                 await TrySetGlobalRequestId(context);
 
                 _logger.LogDebug("ocelot pipeline started");

src/Ocelot/Headers/HttpContextRequestHeaderReplacer.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Http;
+using Ocelot.Configuration;
+using Ocelot.Responses;
+
+namespace Ocelot.Headers
+{
+    public class HttpContextRequestHeaderReplacer : IHttpContextRequestHeaderReplacer
+    {
+        public Response Replace(HttpContext context, List<HeaderFindAndReplace> fAndRs)
+        {
+            foreach (var f in fAndRs)
+            {
+                if(context.Request.Headers.TryGetValue(f.Key, out var values))
+                {
+                    var replaced = values[f.Index].Replace(f.Find, f.Replace);
+                    context.Request.Headers.Remove(f.Key);
+                    context.Request.Headers.Add(f.Key, replaced);
+                }
+            }
+
+            return new OkResponse();
+        }
+    }
+}