#741 Add filtering options and logic to caching

src/Ocelot/Cache/OutputCacheMiddleware.cs

@@ -60,8 +60,16 @@ public async Task Invoke(HttpContext httpContext)
         cached = await CreateCachedResponse(downstreamResponse);
 
         var ttl = TimeSpan.FromSeconds(options.TtlSeconds);
-        _outputCache.Add(downStreamRequestCacheKey, cached, options.Region, ttl);
-        Logger.LogDebug(() => $"Finished response added to cache for the '{downstreamUrlKey}' key.");
+        if (options.StatusCodeFilter == null || options.StatusCodeFilter.PassesFilter(cached.StatusCode))
+        {
+            _outputCache.Add(downStreamRequestCacheKey, cached, options.Region, ttl);
+            Logger.LogDebug(() => $"Finished response added to cache for the '{downstreamUrlKey}' key.");
+        }
+        else
+        {
+            Logger.LogDebug(() => $"Finished response filtered out from being added to cache due to response status for the '{downstreamUrlKey}' key.");
+        }
+
     }
 
     private static void SetHttpResponseMessageThisRequest(HttpContext context, DownstreamResponse response)

src/Ocelot/Configuration/CacheOptions.cs

@@ -1,4 +1,5 @@
 using Ocelot.Configuration.File;
+using Ocelot.Filter;
 using Ocelot.Infrastructure.Extensions;
 using Ocelot.Request.Middleware;
 
@@ -15,7 +16,11 @@ public class CacheOptions
 
     internal CacheOptions() { }
     public CacheOptions(FileCacheOptions from, string defaultRegion)
-        : this(from.TtlSeconds, from.Region.IfEmpty(defaultRegion), from.Header, from.EnableContentHashing)
+        : this(from.TtlSeconds, from.Region.IfEmpty(defaultRegion), from.Header, from.EnableContentHashing, from.StatusCodeFilter)
+    { }
+
+    public CacheOptions(int ttlSeconds, string region, string header, bool? enableContentHashing) 
+        : this(ttlSeconds, region, header, enableContentHashing, null)
     { }
 
     /// <summary>
@@ -31,13 +36,15 @@ public CacheOptions(FileCacheOptions from, string defaultRegion)
     /// <param name="ttlSeconds">Time-to-live seconds. If not speciefied, zero value is used by default.</param>
     /// <param name="region">The region of caching.</param>
     /// <param name="header">The header name to control cached value.</param>
-    /// <param name="enableContentHashing">The switcher for content hashing. If not speciefied, false value is used by default.</param>
-    public CacheOptions(int? ttlSeconds, string region, string header, bool? enableContentHashing)
+    /// <param name="enableContentHashing">The switcher for content hashing. If not speciefied, false value is used by default.</param>
+    /// <param name="statusCodeFilter">The filter for discriminating what gets cached. <code>null</code> means "everything is whitelisted".</param>
+    public CacheOptions(int? ttlSeconds, string region, string header, bool? enableContentHashing, HttpStatusCodeFilter statusCodeFilter)
     {
         TtlSeconds = ttlSeconds ?? NoSeconds;
         Region = region;
         Header = header.IfEmpty(Oc_Cache_Control);
         EnableContentHashing = enableContentHashing ?? false;
+        StatusCodeFilter = statusCodeFilter;
     }
 
     /// <summary>Time-to-live seconds.</summary>
@@ -53,4 +60,6 @@ public CacheOptions(int? ttlSeconds, string region, string header, bool? enableC
     public bool EnableContentHashing { get; }
 
     public bool UseCache => TtlSeconds > NoSeconds;
+
+    public HttpStatusCodeFilter StatusCodeFilter { get; }
 }

src/Ocelot/Configuration/Creator/CacheOptionsCreator.cs

@@ -6,7 +6,7 @@ namespace Ocelot.Configuration.Creator;
 public class CacheOptionsCreator : ICacheOptionsCreator
 {
     public CacheOptions Create(FileCacheOptions options)
-        => new(options?.TtlSeconds, options?.Region, options?.Header, options?.EnableContentHashing);
+        => new(options?.TtlSeconds, options?.Region, options?.Header, options?.EnableContentHashing, options?.StatusCodeFilter);
 
     public CacheOptions Create(FileRoute route, FileGlobalConfiguration globalConfiguration, string loadBalancingKey)
     {
@@ -58,6 +58,7 @@ protected virtual CacheOptions Merge(FileCacheOptions options, FileCacheOptions
         var header = options.Header.IfEmpty(globalOptions.Header).IfEmpty(CacheOptions.Oc_Cache_Control);
         var ttlSeconds = options.TtlSeconds ?? globalOptions.TtlSeconds;
         var enableHashing = options.EnableContentHashing ?? globalOptions.EnableContentHashing;
-        return new CacheOptions(ttlSeconds, region, header, enableHashing);
+        var statusCodes = options.StatusCodeFilter ?? globalOptions.StatusCodeFilter;
+        return new CacheOptions(ttlSeconds, region, header, enableHashing, statusCodes);
     }
 }

src/Ocelot/Configuration/File/FileCacheOptions.cs

@@ -1,4 +1,6 @@
-namespace Ocelot.Configuration.File;
+using Ocelot.Filter;
+
+namespace Ocelot.Configuration.File;
 
 public class FileCacheOptions
 {
@@ -10,6 +12,7 @@ public FileCacheOptions(FileCacheOptions from)
         TtlSeconds = from.TtlSeconds;
         Header = from.Header;
         EnableContentHashing = from.EnableContentHashing;
+        StatusCodeFilter = from.StatusCodeFilter;
     }
 
     /// <summary>Using <see cref="Nullable{T}"/> where T is <see cref="int"/> to have <see langword="null"/> as default value and allowing global configuration usage.</summary>
@@ -23,4 +26,6 @@ public FileCacheOptions(FileCacheOptions from)
     /// <remarks>If <see langword="null"/> then use global configuration with <see langword="false"/> by default.</remarks>
     /// <value><see langword="true"/> if content hashing is enabled; otherwise, <see langword="false"/>.</value>
     public bool? EnableContentHashing { get; set; }
+
+    public HttpStatusCodeFilter StatusCodeFilter { get; set; }
 }

src/Ocelot/Filter/Filter.cs

@@ -0,0 +1,46 @@
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Filter
+{
+    public abstract class Filter<T> : IFilter<T>
+    {
+        public FilterType FilterType { get; set; }
+        public T[] Values { get; set; }
+
+        public Filter() { }
+        public Filter(FilterType filterType, T[] values)
+        {
+            FilterType = filterType;
+            Values = values;
+        }
+
+        public virtual bool PassesFilter(T value)
+        {
+            // there's probably a clever way to clean this up but this is legible.
+            if (FilterType == FilterType.Blacklist)
+            {
+                foreach (var item in Values)
+                {
+                    if (value.Equals(item))
+                    {
+                        return false; // the value is in the blacklist, so it can't pass the filter
+                    }
+                }
+
+                return true; // the value wasn't found in the blacklist, so it passes the filter
+            }
+            else // filter is whitelist
+            {
+                foreach (var item in Values)
+                {
+                    if (value.Equals(item))
+                    {
+                        return true; // the value is in the whitelist, so it passes the filter
+                    }
+                }
+
+                return false; // the value is not in the whitelist, so it doesn't pass the filter
+            }
+        }
+    }
+}

src/Ocelot/Filter/FilterType.cs

@@ -0,0 +1,8 @@
+namespace Ocelot.Filter
+{
+    public enum FilterType
+    {
+        Whitelist,
+        Blacklist,
+    }
+}

src/Ocelot/Filter/HttpStatusCodeFilter.cs

@@ -0,0 +1,54 @@
+using System;
+
+namespace Ocelot.Filter
+{
+    public class HttpStatusCodeFilter : Filter<HttpStatusCode>
+    {
+        public HttpStatusCodeFilter() { }
+
+        public HttpStatusCodeFilter(FilterType filterType, HttpStatusCode[] values) : base(filterType, values ?? Enum.GetValues(typeof(HttpStatusCode)).Cast<HttpStatusCode>().ToArray())
+        {
+        }
+
+        public HttpStatusCodeFilter(FilterType filterType, string[] values) :base(filterType, ParseInput(values))
+        {
+        }
+
+        static HttpStatusCode[] ParseInput(string[] values)
+        {
+            List<HttpStatusCode> valuesList = new List<HttpStatusCode>();
+            if (values == null)
+            {
+                valuesList.AddRange(Enum.GetValues(typeof(HttpStatusCode)).Cast<HttpStatusCode>());
+            }
+            else
+            {
+                foreach (var value in values)
+                {
+                    int i;
+                    if (int.TryParse(value, out i))
+                    {
+                        if (Enum.IsDefined(typeof(HttpStatusCode), i))
+                        {
+                            valuesList.Add((HttpStatusCode)i);
+                        }
+                    }
+                    else
+                    {
+                        foreach (var code in Enum.GetValues<HttpStatusCode>())
+                        {
+                            string codeClass = ((int)code / 100) + "xx";
+                            bool code_is_in_range = string.Equals(value, codeClass, StringComparison.OrdinalIgnoreCase);
+                            if (code_is_in_range)
+                            {
+                                valuesList.Add(code);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return valuesList.Distinct().ToArray();
+        }
+    }
+}

src/Ocelot/Filter/IFilter.cs

@@ -0,0 +1,7 @@
+namespace Ocelot.Filter
+{
+    public interface IFilter<T>
+    {
+        bool PassesFilter(T value);
+    }
+}