update with code review feedback

Author: lanlanlee2008

src/OutputCacheModuleAsync/OutputCacheHelper.cs

@@ -155,7 +155,7 @@ private static CachedRawResponse Convert(OutputCacheEntry oce) {
             };
         }
 
-        public async Task<object> Get(string key) {
+        internal async Task<object> GetAsync(string key) {
             OutputCacheProviderAsync provider = GetProvider(HttpContext.Current);
             object result = await provider.GetAsync(key);
             var oce = result as OutputCacheEntry;
@@ -170,7 +170,7 @@ public async Task<object> Get(string key) {
             return result;
         }
 
-        public async Task Remove(string key, HttpContext context) {
+        internal async Task RemoveAsync(string key, HttpContext context) {
             // we don't know if it's in the internal cache or
             // one of the providers.  If a context is given,
             // then we can narrow down to at most one provider.
@@ -189,7 +189,7 @@ public async Task Remove(string key, HttpContext context) {
             }
         }
 
-        public async Task InsertResponse(string cachedVaryKey,
+        internal async Task InsertResponseAsync(string cachedVaryKey,
             CachedVary cachedVary,
             string rawResponseKey,
             CachedRawResponse rawResponse,
@@ -258,7 +258,7 @@ public async Task InsertResponse(string cachedVaryKey,
             }
         }
 
-        public static bool IsCacheableEncoding(string coding, string[] contentEncodings) {
+        internal static bool IsCacheableEncoding(string coding, string[] contentEncodings) {
             // return true if we are not varying by content encoding.
             if (contentEncodings == null) {
                 return true;
@@ -268,7 +268,7 @@ public static bool IsCacheableEncoding(string coding, string[] contentEncodings)
             // return true if the Content-Encoding header is listed
         }
 
-        public static bool ContainsNonShareableCookies(HttpResponse response) {
+        internal static bool ContainsNonShareableCookies(HttpResponse response) {
             HttpCookieCollection cookies = response.Cookies;
             for (int i = 0; i < cookies.Count; i++) {
                 HttpCookie httpCookie = cookies[i];
@@ -279,7 +279,7 @@ public static bool ContainsNonShareableCookies(HttpResponse response) {
             return false;
         }
 
-        public static void UseSnapshot(HttpRawResponse rawResponse, bool sendBody, HttpResponse response) {
+        internal static void UseSnapshot(HttpRawResponse rawResponse, bool sendBody, HttpResponse response) {
             if (response.HeadersWritten)
                 throw new HttpException(SR.Cannot_use_snapshot_after_headers_sent);
             response.Clear();
@@ -296,7 +296,7 @@ public static void UseSnapshot(HttpRawResponse rawResponse, bool sendBody, HttpR
             response.SuppressContent = !sendBody;
         }
 
-        public static HttpRawResponse GetSnapshot(HttpResponse response) {
+        internal static HttpRawResponse GetSnapshot(HttpResponse response) {
             var headers = new NameValueCollection();
             const bool hasSubstBlocks = false;
             if (response.HeadersWritten)
@@ -328,7 +328,7 @@ public static HttpRawResponse GetSnapshot(HttpResponse response) {
             };
         }
 
-        public static HttpCachePolicySettings GetCurrentSettings(HttpResponse response) {
+        internal static HttpCachePolicySettings GetCurrentSettings(HttpResponse response) {
             IEnumerable<KeyValuePair<HttpCacheValidateHandler, object>> validationCallbackInfo =
                 OutputCacheUtility.GetValidationCallbacks(response);
 
@@ -353,7 +353,7 @@ public static HttpCachePolicySettings GetCurrentSettings(HttpResponse response)
             };
         }
 
-        public static void ResetFromHttpCachePolicySettings(HttpCachePolicySettings settings,
+        internal static void ResetFromHttpCachePolicySettings(HttpCachePolicySettings settings,
             DateTime utcTimestampRequest, HttpResponse response) {
             response.Cache.SetCacheability(settings.Cacheability);
             response.Cache.VaryByContentEncodings.SetContentEncodings(settings.VaryByContentEncodings);
@@ -385,13 +385,99 @@ public static void ResetFromHttpCachePolicySettings(HttpCachePolicySettings sett
             }
         }
 
-        public static void UpdateCachedHeaders(HttpResponse response) {
+        internal static void UpdateCachedHeaders(HttpResponse response) {
+            //To enable Out of Band OutputCache Module support, we will always refresh the UtcTimestampRequest.
             if (response.Cache.UtcTimestampCreated == DateTime.MinValue) {
                 response.Cache.UtcTimestampCreated = HttpContext.Current.Timestamp.ToUniversalTime();
+            }         
+            UpdateFromDependencies(response);
+        }
+
+        private static void UpdateFromDependencies(HttpResponse response) {
+            CacheDependency dep = null;
+            // if response.Cache.GetETag() != null && response.Cache.GetETagFromFileDependencies() == true, then this HttpCachePolicy
+            // was created from HttpCachePolicySettings and we don't need to update _etag.
+            if (response.Cache.GetETag() == null && response.Cache.GetETagFromFileDependencies()) {
+                dep = OutputCacheUtility.CreateCacheDependency(response);
+                if (dep == null) {
+                    return;
+                }
+                string id = dep.GetUniqueID();
+                if (id == null) {
+                    throw new HttpException(SR.No_UniqueId_Cache_Dependency);
+                }
+                DateTime utcFileLastModifiedMax = UpdateLastModifiedTimeFromDependency(dep, response);
+                var sb = new StringBuilder(256);
+                sb.Append(HttpRuntime.AppDomainId);
+                sb.Append(id);
+                sb.Append("+LM");
+                sb.Append(utcFileLastModifiedMax.Ticks.ToString(CultureInfo.InvariantCulture));
+                response.Cache.SetETag("\"" +
+                                       System.Convert.ToBase64String(
+                                           CryptoUtil.ComputeSha256Hash(Encoding.UTF8.GetBytes(sb.ToString()))) + "\"");
+
+
+                if (!response.Cache.GetLastModifiedFromFileDependencies())
+                    return;
+            }
+
+            {
+                if (dep == null) {
+                    dep = OutputCacheUtility.CreateCacheDependency(response);
+                    if (dep == null) {
+                        return;
+                    }
+                }
+                DateTime utcFileLastModifiedMax = UpdateLastModifiedTimeFromDependency(dep,response);
+                UtcSetLastModified(utcFileLastModifiedMax, response);
             }
         }
 
-        public static string CreateOutputCachedItemKey(
+        private static void UtcSetLastModified(DateTime utcDate, HttpResponse response) {
+        
+                /*
+                 * Time may differ if the system time changes in the middle of the request. 
+                 * Adjust the timestamp to Now if necessary.
+                 */
+
+                DateTime utcNow = DateTime.UtcNow;
+                if (utcDate > utcNow) {
+                    utcDate = utcNow;
+                }
+
+                /*
+                 * Because HTTP dates have a resolution of 1 second, we
+                 * need to store dates with 1 second resolution or comparisons
+                 * will be off.
+                 */
+
+                utcDate = new DateTime(utcDate.Ticks - (utcDate.Ticks % TimeSpan.TicksPerSecond));
+                if (response.Cache.GetUtcLastModified()!= DateTime.MinValue || utcDate > response.Cache.GetUtcLastModified()) {
+                 response.Cache.SetLastModified(utcDate);
+                }
+            
+
+        }
+
+
+        private static DateTime UpdateLastModifiedTimeFromDependency(CacheDependency dep, HttpResponse response) {
+                  DateTime utcFileLastModifiedMax = dep.UtcLastModified;
+                if (utcFileLastModifiedMax <  response.Cache.GetUtcLastModified()) {
+                    utcFileLastModifiedMax = response.Cache.GetUtcLastModified();
+                }
+                // account for difference between file system time 
+                // and DateTime.Now. On some machines it appears that
+                // the last modified time is further in the future
+                // that DateTime.Now                
+                DateTime utcNow = DateTime.UtcNow;
+                if (utcFileLastModifiedMax > utcNow) {
+                    utcFileLastModifiedMax = utcNow;
+                }
+                return utcFileLastModifiedMax;
+            
+        }
+
+        private static string CreateOutputCachedItemKey(
             string path,
             string verb,
             HttpContext context,
@@ -530,7 +616,7 @@ public static string CreateOutputCachedItemKey(
          * and form posted data.
          */
 
-        public static string CreateOutputCachedItemKeyAsync(HttpContext context, CachedVary cachedVary) {
+        internal static string CreateOutputCachedItemKey(HttpContext context, CachedVary cachedVary) {
             return CreateOutputCachedItemKey(context.Request.Path, context.Request.HttpMethod, context, cachedVary);
         }
 
@@ -540,7 +626,7 @@ public static string CreateOutputCachedItemKeyAsync(HttpContext context, CachedV
          * returns either i) an acceptable index in contentEncodings, ii) -1 if the identity is acceptable, or iii) -2 if nothing is acceptable
          */
 
-        public static int GetAcceptableEncoding(string[] contentEncodings, int startIndex, string acceptEncoding) {
+        internal static int GetAcceptableEncoding(string[] contentEncodings, int startIndex, string acceptEncoding) {
             // The format of Accept-Encoding is ( 1#( codings [ ";" "q" "=" qvalue ] ) | "*" )
             if (string.IsNullOrEmpty(acceptEncoding)) {
                 return -1; // use "identity"
@@ -604,9 +690,9 @@ public static int GetAcceptableEncoding(string[] contentEncodings, int startInde
             return bestCodingIndex; // coding index with highest weight, possibly -1 or -2
         }
 
-        public static double Tolerance { get; set; }
+        private static double Tolerance { get; set; }
 
-        // Get the weight of the specified coding from the Accept-Encoding header.
+        // GetAsync the weight of the specified coding from the Accept-Encoding header.
         // 1 means use this coding.  0 means don't use this coding.  A number between
         // 1 and 0 must be compared with other codings.  -1 means the coding was not found
         private static double GetAcceptableEncodingHelper(string coding, string acceptEncoding) {
@@ -689,7 +775,7 @@ private static bool IsIdentityAcceptable(string acceptEncoding) {
             return result;
         }
 
-        public static bool IsAcceptableEncoding(string contentEncoding, string acceptEncoding) {
+        internal static bool IsAcceptableEncoding(string contentEncoding, string acceptEncoding) {
             if (string.IsNullOrEmpty(contentEncoding)) {
                 // if Content-Encoding is not set treat it as the identity
                 contentEncoding = Identity;
@@ -703,5 +789,7 @@ public static bool IsAcceptableEncoding(string contentEncoding, string acceptEnc
             return !(Math.Abs(weight) < tolerance) &&
                    (!(weight <= 0) || Math.Abs(GetAcceptableEncodingHelper(Asterisk, acceptEncoding)) > 0);
         }
+
+
     }
 }

src/OutputCacheModuleAsync/OutputCacheModuleAsync.cs

@@ -64,11 +64,11 @@ private async Task OnEnterAsync(object source, EventArgs eventArgs) {
             }
 
             // Create a lookup key. Also store the key in global parameter _key to be used inside OnLeave() later   
-            string key = _key = OutputCacheHelper.CreateOutputCachedItemKeyAsync(context, null);
+            string key = _key = OutputCacheHelper.CreateOutputCachedItemKey(context, null);
 
             // Lookup the cache vary using the key
-            object item = await _outputCacheHelper.Get(key);
-            if (await _outputCacheHelper.Get(key) == null) {
+            object item = await _outputCacheHelper.GetAsync(key);
+            if (item == null) {
                 return;
             }
             // 'item' may be one of the following:
@@ -87,7 +87,7 @@ private async Task OnEnterAsync(object source, EventArgs eventArgs) {
                 return;
             }
 
-            if (await CheckHeadersToDetermineAcceptCachedCopy(key, settings, request, context)) {
+            if (await CheckHeadersToDetermineAcceptCachedCopyAsync(key, settings, request, context)) {
                 return;
             }
 
@@ -114,7 +114,7 @@ private async Task OnLeaveAsync(object source, EventArgs eventArgs) {
             if (!IsResponseCacheable(response, request, context)) {
                 return;
             }
-            await CacheResponse(context, response);
+            await CacheResponseAsync(context, response);
             _key = null;
         }
 
@@ -167,7 +167,7 @@ private static bool IsResponseCacheable(HttpResponse response, HttpRequest reque
                        cache.VaryByContentEncodings.GetContentEncodings());
         }
 
-        private async Task CacheResponse(HttpContext context, HttpResponse response) {
+        private async Task CacheResponseAsync(HttpContext context, HttpResponse response) {
             CachedVary cachedVary;
             string keyRawResponse;
             /*
@@ -180,7 +180,7 @@ private async Task CacheResponse(HttpContext context, HttpResponse response) {
             string[] varyByParams = settings.IgnoreParams ? null : settings.VaryByParams;
             /* Create the key if it was not created in OnEnter */
             if (_key == null) {
-                _key = OutputCacheHelper.CreateOutputCachedItemKeyAsync(context, null);
+                _key = OutputCacheHelper.CreateOutputCachedItemKey(context, null);
                 Debug.Assert(_key != null, "_key != null");
             }
             if (settings.VaryByContentEncodings == null && varyByHeaders == null && varyByParams == null &&
@@ -223,7 +223,7 @@ private async Task CacheResponse(HttpContext context, HttpResponse response) {
                     VaryByAllParams = varyByAllParams,
                     VaryByCustom = settings.VaryByCustom
                 };
-                keyRawResponse = OutputCacheHelper.CreateOutputCachedItemKeyAsync(context, cachedVary);
+                keyRawResponse = OutputCacheHelper.CreateOutputCachedItemKey(context, cachedVary);
                 if (keyRawResponse == null) {
                     Debug.WriteLine(SR.OutputCacheModuleLeave, string.Format(SR.Couldnot_add_non_cacheable_post,_key));
                     return;
@@ -265,7 +265,7 @@ private async Task CacheResponse(HttpContext context, HttpResponse response) {
                 Debug.WriteLine(SR.OutputCacheModuleLeave, string.Format(SR.Adding_response_to_cache, keyRawResponse));
                 CacheDependency dep = OutputCacheUtility.CreateCacheDependency(context.Response);
                 try {
-                    await _outputCacheHelper.InsertResponse(_key, cachedVary,
+                    await _outputCacheHelper.InsertResponseAsync(_key, cachedVary,
                         keyRawResponse, cachedRawResponse,
                         dep,
                         utcExpires, slidingDelta);
@@ -364,7 +364,7 @@ private static bool EnsureContentEncodingAcceptable(CachedVary cachedVary, HttpR
             return OutputCacheHelper.IsAcceptableEncoding(contentEncoding, acceptEncoding);
         }
 
-        private async Task<bool> CheckHeadersToDetermineAcceptCachedCopy(string key, HttpCachePolicySettings settings,
+        private async Task<bool> CheckHeadersToDetermineAcceptCachedCopyAsync(string key, HttpCachePolicySettings settings,
             HttpRequest request, HttpContext context) {
             if (!settings.HasValidationPolicy()) {
                 if (request.Headers["Cache-Control"] != null) {
@@ -449,7 +449,7 @@ private async Task<bool> CheckHeadersToDetermineAcceptCachedCopy(string key, Htt
                         Debug.WriteLine(SR.OutputCacheModuleEnter,
                           string.Format(SR.Output_cache_item_found_but_callback_invalidated_it,key) + " OutputCacheModule::Enter");
 
-                        await _outputCacheHelper.Remove(key, context);
+                        await _outputCacheHelper.RemoveAsync(key, context);
                         return true;
                     case HttpValidationStatus.IgnoreThisRequest:
                         validationStatusFinal = HttpValidationStatus.IgnoreThisRequest;
@@ -502,7 +502,7 @@ private async Task<CachedItem> CheckCacheVaryAsync(CachedVary cachedVary, HttpCo
                  *
                  * Skip this step if it's a VaryByNone vary policy.
                  */
-            string key = OutputCacheHelper.CreateOutputCachedItemKeyAsync(context, cachedVary);
+            string key = OutputCacheHelper.CreateOutputCachedItemKey(context, cachedVary);
             if (key == null) {
                 Debug.WriteLine(SR.OutputCacheModuleEnter,
                    string.Format(SR.Miss_key_could_not_be_created_for_varyby_item,"Vary-By") + " OutputCacheModule::Enter");
@@ -511,7 +511,7 @@ private async Task<CachedItem> CheckCacheVaryAsync(CachedVary cachedVary, HttpCo
             if (cachedVary.ContentEncodings == null) {
                 // With the new key, look up the in-memory key.
                 // At this point, we've exhausted the lookups in memory for this item.
-                item = await _outputCacheHelper.Get(key);
+                item = await _outputCacheHelper.GetAsync(key);
             }
             else {
                 bool identityIsAcceptable = true;
@@ -526,7 +526,7 @@ private async Task<CachedItem> CheckCacheVaryAsync(CachedVary cachedVary, HttpCo
                         if (index > -1) {
                             identityIsAcceptable = false;
                             // the client Accept-Encoding header contains an encoding that's in the VaryByContentEncoding list
-                            item = await _outputCacheHelper.Get(key + contentEncodings[index]);
+                            item = await _outputCacheHelper.GetAsync(key + contentEncodings[index]);
                             if (item != null) {
                                 continue;
                             }
@@ -543,15 +543,15 @@ private async Task<CachedItem> CheckCacheVaryAsync(CachedVary cachedVary, HttpCo
                 }
                 // the identity should not be used if the client Accept-Encoding contains an entry in the VaryByContentEncoding list or "identity" is not acceptable
                 if (item == null && identityIsAcceptable) {
-                    item = await _outputCacheHelper.Get(key);
+                    item = await _outputCacheHelper.GetAsync(key);
                 }
             }
             if (item != null && ((CachedRawResponse) item).CachedVaryId == cachedVary.CachedVaryId) {
                 return new CachedItem {DoReturn = false, Item = item};
             }
             if (item != null) {
                 // explicitly remove entry because _cachedVaryId does not match
-                await _outputCacheHelper.Remove(key, context);
+                await _outputCacheHelper.RemoveAsync(key, context);
             }
             return new CachedItem {DoReturn = true, Item = item};
         }