Follow up #1172 #1849: Fix cache issue. IP filtering helpers

src/Ocelot/Cache/CacheKeyGenerator.cs

@@ -6,15 +6,23 @@ public class CacheKeyGenerator : ICacheKeyGenerator
     {
         public string GenerateRequestCacheKey(DownstreamRequest downstreamRequest)
         {
-            var downStreamUrlKeyBuilder = new StringBuilder($"{downstreamRequest.Method}-{downstreamRequest.OriginalString}");
+            var builder = new StringBuilder($"{downstreamRequest.Method}-{downstreamRequest.OriginalString}");
+
+            if (downstreamRequest.Headers?.TryGetValues("Content-Language", out IEnumerable<string> values) ?? false)
+            {
+                var contentLanguage = values.Any()
+                    ? "-" + string.Join(string.Empty, values)
+                    : string.Empty;
+                builder.Append(contentLanguage);
+            }
+
             if (downstreamRequest.Content != null)
             {
-                var requestContentString = Task.Run(async () => await downstreamRequest.Content.ReadAsStringAsync()).Result;
-                downStreamUrlKeyBuilder.Append(requestContentString);
+                var requestContentString = Task.Run(downstreamRequest.Content.ReadAsStringAsync).Result;
+                builder.Append(requestContentString);
             }
 
-            var hashedContent = MD5Helper.GenerateMd5(downStreamUrlKeyBuilder.ToString());
-            return hashedContent;
+            return MD5Helper.GenerateMd5(builder.ToString());
         }
     }
 }

src/Ocelot/Cache/Middleware/OutputCacheMiddleware.cs

@@ -64,15 +64,19 @@ public async Task Invoke(HttpContext httpContext)
 
             var downstreamResponse = httpContext.Items.DownstreamResponse();
 
-            cached = await CreateCachedResponse(downstreamResponse);
-
-            _outputCache.Add(downStreamRequestCacheKey, cached, TimeSpan.FromSeconds(downstreamRoute.CacheOptions.TtlSeconds), downstreamRoute.CacheOptions.Region);
-
-            Logger.LogDebug($"Finished response added to cache for the '{downstreamUrlKey}' key.");
+            if (downstreamResponse.StatusCode == HttpStatusCode.OK)
+            {
+                cached = await CreateCachedResponse(downstreamResponse);
+                _outputCache.Add(downStreamRequestCacheKey, cached, TimeSpan.FromSeconds(downstreamRoute.CacheOptions.TtlSeconds), downstreamRoute.CacheOptions.Region);
+                Logger.LogDebug($"Finished response added to cache for the '{downstreamUrlKey}' key.");
+            }
+            else
+            {
+                Logger.LogDebug($"HTTP request failed: could not create cache for the '{downstreamUrlKey}' key.");
+            }
         }
 
-        private static void SetHttpResponseMessageThisRequest(HttpContext context,
-                                                       DownstreamResponse response)
+        private static void SetHttpResponseMessageThisRequest(HttpContext context, DownstreamResponse response)
         {
             context.Items.UpsertDownstreamResponse(response);
         }

src/Ocelot/Security/IPSecurity/IPSecurityPolicy.cs

@@ -9,7 +9,7 @@ public class IPSecurityPolicy : ISecurityPolicy
     {
         public async Task<Response> Security(DownstreamRoute downstreamRoute, HttpContext httpContext)
         {
-            var clientIp = httpContext.Connection.RemoteIpAddress;
+            var clientIp = httpContext.GetClientIpAddress();
             var securityOptions = downstreamRoute.SecurityOptions;
             if (securityOptions == null)
             {
@@ -18,7 +18,7 @@ public async Task<Response> Security(DownstreamRoute downstreamRoute, HttpContex
 
             if (securityOptions.IPBlockedList != null)
             {
-                if (securityOptions.IPBlockedList.Exists(f => f == clientIp.ToString()))
+                if (securityOptions.IPBlockedList.Exists(f => f == clientIp))
                 {
                     var error = new UnauthenticatedError($" This request rejects access to {clientIp} IP");
                     return new ErrorResponse(error);
@@ -27,7 +27,7 @@ public async Task<Response> Security(DownstreamRoute downstreamRoute, HttpContex
 
             if (securityOptions.IPAllowedList?.Count > 0)
             {
-                if (!securityOptions.IPAllowedList.Exists(f => f == clientIp.ToString()))
+                if (!securityOptions.IPAllowedList.Exists(f => f == clientIp))
                 {
                     var error = new UnauthenticatedError($"{clientIp} does not allow access, the request is invalid");
                     return new ErrorResponse(error);

src/Ocelot/Security/SecurityPolicyExtensions.cs

@@ -0,0 +1,66 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Primitives;
+
+namespace Ocelot.Security;
+
+public static class SecurityPolicyExtensions
+{
+    public static string GetClientIpAddress(this HttpContext httpContext, bool tryUseXForwardHeader = true)
+    {
+        if (httpContext == null)
+        {
+            return null;
+        }
+
+        string ip = null;
+
+        // X-Forwarded-For =>  Using the First entry in the list
+        if (string.IsNullOrWhiteSpace(ip) && tryUseXForwardHeader)
+        {
+            ip = httpContext.GetHeaderValue("X-Forwarded-For").SplitCsv().FirstOrDefault();
+        }
+
+        // RemoteIpAddress is always null in DNX RC1 Update1 (bug).
+        if (string.IsNullOrWhiteSpace(ip) && httpContext.Connection?.RemoteIpAddress != null)
+        {
+            ip = httpContext.Connection.RemoteIpAddress.ToString();
+        }
+
+        if (string.IsNullOrWhiteSpace(ip))
+        {
+            ip = httpContext.GetHeaderValue("REMOTE_ADDR");
+        } 
+
+        if (ip == "::1")
+        {
+            ip = "127.0.0.1";
+        }
+
+        return ip;
+    }
+
+    public static string GetHeaderValue(this HttpContext httpContext, string headerName)
+    {
+        if (httpContext?.Request?.Headers?.TryGetValue(headerName, out StringValues values) ?? false)
+        {
+            return values.ToString();
+        }
+
+        return string.Empty;
+    }
+
+    public static List<string> SplitCsv(this string csvList, bool nullOrWhitespaceInputReturnsNull = false)
+    {
+        if (string.IsNullOrWhiteSpace(csvList))
+        {
+            return nullOrWhitespaceInputReturnsNull ? null : new List<string>();
+        }
+
+        return csvList
+            .TrimEnd(',')
+            .Split(',')
+            .AsEnumerable()
+            .Select(s => s.Trim())
+            .ToList();
+    }
+}