#1172 Default CacheKeyGenerator

docs/features/caching.rst

@@ -30,11 +30,14 @@ Finally, in order to use caching on a route in your Route configuration add this
 
 .. code-block:: json
 
-    "FileCacheOptions": { "TtlSeconds": 15, "Region": "europe-central" }
+    "FileCacheOptions": { "TtlSeconds": 15, "Region": "europe-central", "Header": "Authorization" }
 
 In this example **TtlSeconds** is set to 15 which means the cache will expire after 15 seconds.
 The **Region** represents a region of caching. 
 
+Additionally, if a header name is defined in the **Header** property, that header value is looked up by the key (header name) in the ``HttpRequest`` headers,
+and if the header is found, its value will be included in caching key. This causes the cache to become invalid due to the header value changing.
+
 If you look at the example `here <https://github.com/ThreeMammals/Ocelot/blob/main/test/Ocelot.ManualTest/Program.cs>`_ you can see how the cache manager is setup and then passed into the Ocelot ``AddCacheManager`` configuration method.
 You can use any settings supported by the **CacheManager** package and just pass them in.
 

src/Ocelot.Cache.CacheManager/OcelotBuilderExtensions.cs

@@ -34,7 +34,7 @@ public static IOcelotBuilder AddCacheManager(this IOcelotBuilder builder, Action
             builder.Services.AddSingleton<IOcelotCache<FileConfiguration>>(fileConfigCacheManager);
 
             builder.Services.RemoveAll(typeof(ICacheKeyGenerator));
-            builder.Services.AddSingleton<ICacheKeyGenerator, CacheKeyGenerator>();
+            builder.Services.AddSingleton<ICacheKeyGenerator, DefaultCacheKeyGenerator>();
 
             return builder;
         }

src/Ocelot/Cache/DefaultCacheKeyGenerator.cs

@@ -0,0 +1,48 @@
+using Ocelot.Configuration;
+using Ocelot.Request.Middleware;
+
+namespace Ocelot.Cache
+{
+    public class DefaultCacheKeyGenerator : ICacheKeyGenerator
+    {
+        private const char Delimiter = '-';
+
+        public async ValueTask<string> GenerateRequestCacheKey(DownstreamRequest downstreamRequest, DownstreamRoute downstreamRoute)
+        {
+            var builder = new StringBuilder()
+                .Append(downstreamRequest.Method)
+                .Append(Delimiter)
+                .Append(downstreamRequest.OriginalString);
+
+            var options = downstreamRoute?.CacheOptions;
+            var cacheOptionsHeader = options?.Header ?? string.Empty;
+            if (!string.IsNullOrEmpty(cacheOptionsHeader))
+            {
+                var header = downstreamRequest.Headers
+                    .FirstOrDefault(r => r.Key.Equals(cacheOptionsHeader, StringComparison.OrdinalIgnoreCase))
+                    .Value?.FirstOrDefault();
+
+                if (!string.IsNullOrEmpty(header))
+                {
+                    builder.Append(Delimiter)
+                        .Append(header);
+                }
+            }
+
+            if (!downstreamRequest.HasContent || !options.EnableRequestBodyHashing)
+            {
+                return MD5Helper.GenerateMd5(builder.ToString());
+            }
+
+            var requestContentString = await ReadContentAsync(downstreamRequest);
+            builder.Append(Delimiter)
+                .Append(requestContentString);
+
+            return MD5Helper.GenerateMd5(builder.ToString());
+        }
+
+        private static Task<string> ReadContentAsync(DownstreamRequest downstream) => downstream.HasContent
+            ? downstream?.Request?.Content?.ReadAsStringAsync() ?? Task.FromResult(string.Empty)
+            : Task.FromResult(string.Empty);
+    }
+}

src/Ocelot/Cache/ICacheKeyGenerator.cs

@@ -1,9 +1,10 @@
-using Ocelot.Request.Middleware;
+using Ocelot.Configuration;
+using Ocelot.Request.Middleware;
 
 namespace Ocelot.Cache
 {
     public interface ICacheKeyGenerator
     {
-        string GenerateRequestCacheKey(DownstreamRequest downstreamRequest);
+        ValueTask<string> GenerateRequestCacheKey(DownstreamRequest downstreamRequest, DownstreamRoute downstreamRoute);
     }
 }

src/Ocelot/Cache/Middleware/OutputCacheMiddleware.cs

@@ -33,7 +33,7 @@ public async Task Invoke(HttpContext httpContext)
 
             var downstreamRequest = httpContext.Items.DownstreamRequest();
             var downstreamUrlKey = $"{downstreamRequest.Method}-{downstreamRequest.OriginalString}";
-            var downStreamRequestCacheKey = _cacheGenerator.GenerateRequestCacheKey(downstreamRequest);
+            var downStreamRequestCacheKey = await _cacheGenerator.GenerateRequestCacheKey(downstreamRequest, downstreamRoute);
 
             Logger.LogDebug(() => $"Started checking cache for the '{downstreamUrlKey}' key.");
 

src/Ocelot/Configuration/CacheOptions.cs

@@ -2,14 +2,27 @@
 {
     public class CacheOptions
     {
-        public CacheOptions(int ttlSeconds, string region)
+        public CacheOptions(int ttlSeconds, string region, string header)
         {
             TtlSeconds = ttlSeconds;
-            Region = region;
+            Region = region;
+            Header = header;
+        }
+
+        public CacheOptions(int ttlSeconds, string region, string header, bool enableContentHashing)
+        {
+            TtlSeconds = ttlSeconds;
+            Region = region;
+            Header = header;
+            EnableRequestBodyHashing = enableContentHashing;
         }
 
         public int TtlSeconds { get; }
 
-        public string Region { get; }
+        public string Region { get; }
+
+        public string Header { get; }
+
+        public bool EnableRequestBodyHashing { get; }
     }
 }

src/Ocelot/Configuration/Creator/RoutesCreator.cs

@@ -122,7 +122,7 @@ private DownstreamRoute SetUpDownstreamRoute(FileRoute fileRoute, FileGlobalConf
                 .WithClaimsToDownstreamPath(claimsToDownstreamPath)
                 .WithRequestIdKey(requestIdKey)
                 .WithIsCached(fileRouteOptions.IsCached)
-                .WithCacheOptions(new CacheOptions(fileRoute.FileCacheOptions.TtlSeconds, region))
+                .WithCacheOptions(new CacheOptions(fileRoute.FileCacheOptions.TtlSeconds, region, fileRoute.FileCacheOptions.Header))
                 .WithDownstreamScheme(fileRoute.DownstreamScheme)
                 .WithLoadBalancerOptions(lbOptions)
                 .WithDownstreamAddresses(downstreamAddresses)

src/Ocelot/Configuration/File/FileCacheOptions.cs

@@ -13,8 +13,9 @@ public FileCacheOptions(FileCacheOptions from)
             Region = from.Region;
             TtlSeconds = from.TtlSeconds;
         }
-
-        public string Region { get; set; }
+
         public int TtlSeconds { get; set; }
+        public string Region { get; set; }
+        public string Header { get; set; }
     }
 }

src/Ocelot/DependencyInjection/OcelotBuilder.cs

@@ -116,7 +116,7 @@ public OcelotBuilder(IServiceCollection services, IConfiguration configurationRo
             Services.TryAddSingleton<IHttpHandlerOptionsCreator, HttpHandlerOptionsCreator>();
             Services.TryAddSingleton<IDownstreamAddressesCreator, DownstreamAddressesCreator>();
             Services.TryAddSingleton<IDelegatingHandlerHandlerFactory, DelegatingHandlerHandlerFactory>();
-            Services.TryAddSingleton<ICacheKeyGenerator, CacheKeyGenerator>();
+            Services.TryAddSingleton<ICacheKeyGenerator, DefaultCacheKeyGenerator>();
             Services.TryAddSingleton<IOcelotConfigurationChangeTokenSource, OcelotConfigurationChangeTokenSource>();
             Services.TryAddSingleton<IOptionsMonitor<IInternalConfiguration>, OcelotConfigurationMonitor>();
 

src/Ocelot/Request/Middleware/DownstreamRequest.cs

@@ -6,6 +6,8 @@ public class DownstreamRequest
     {
         private readonly HttpRequestMessage _request;
 
+        public DownstreamRequest() { }
+
         public DownstreamRequest(HttpRequestMessage request)
         {
             _request = request;
@@ -17,14 +19,13 @@ public DownstreamRequest(HttpRequestMessage request)
             Headers = _request.Headers;
             AbsolutePath = _request.RequestUri.AbsolutePath;
             Query = _request.RequestUri.Query;
-            Content = _request.Content;
         }
 
-        public HttpRequestHeaders Headers { get; }
+        public virtual HttpHeaders Headers { get; }
 
-        public string Method { get; }
+        public virtual string Method { get; }
 
-        public string OriginalString { get; }
+        public virtual string OriginalString { get; }
 
         public string Scheme { get; set; }
 
@@ -36,7 +37,9 @@ public DownstreamRequest(HttpRequestMessage request)
 
         public string Query { get; set; }
 
-        public HttpContent Content { get; set; }
+        public virtual bool HasContent { get => _request?.Content != null; }
+
+        public virtual HttpRequestMessage Request { get => _request; }
 
         public HttpRequestMessage ToHttpRequestMessage()
         {

src/Ocelot/RequestId/Middleware/RequestIdMiddleware.cs

@@ -63,14 +63,14 @@ private void SetOcelotRequestId(HttpContext httpContext)
             }
         }
 
-        private static bool ShouldAddRequestId(RequestId requestId, HttpRequestHeaders headers)
+        private static bool ShouldAddRequestId(RequestId requestId, HttpHeaders headers)
         {
             return !string.IsNullOrEmpty(requestId?.RequestIdKey)
                    && !string.IsNullOrEmpty(requestId.RequestIdValue)
                    && !RequestIdInHeaders(requestId, headers);
         }
 
-        private static bool RequestIdInHeaders(RequestId requestId, HttpRequestHeaders headers)
+        private static bool RequestIdInHeaders(RequestId requestId, HttpHeaders headers)
         {
             return headers.TryGetValues(requestId.RequestIdKey, out var value);
         }