Drop IResponseCache async methods (#15393)

Kahbazi · John Luo · commit 93432bd41706 · 2019-11-04T11:06:19.000-08:00
diff --git a/src/Middleware/ResponseCaching/src/Interfaces/IResponseCache.cs b/src/Middleware/ResponseCaching/src/Interfaces/IResponseCache.cs
@@ -1,4 +1,4 @@
-﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -16,29 +16,12 @@ internal interface IResponseCache
         /// <returns>The response cache entry if it exists; otherwise <c>null</c>.</returns>
         IResponseCacheEntry Get(string key);
 
-        /// <summary>
-        /// Gets the cached response for the given key, if it exists.
-        /// If no cached response exists for the given key, <c>null</c> is returned.
-        /// </summary>
-        /// <param name="key">The cache key to look up.</param>
-        /// <returns>The response cache entry if it exists; otherwise <c>null</c>.</returns>
-        Task<IResponseCacheEntry> GetAsync(string key);
-
         /// <summary>
         /// Stores the given response in the response cache.
         /// </summary>
         /// <param name="key">The cache key to store the response under.</param>
         /// <param name="entry">The response cache entry to store.</param>
         /// <param name="validFor">The amount of time the entry will be kept in the cache before expiring, relative to now.</param>
         void Set(string key, IResponseCacheEntry entry, TimeSpan validFor);
-
-        /// <summary>
-        /// Stores the given response in the response cache.
-        /// </summary>
-        /// <param name="key">The cache key to store the response under.</param>
-        /// <param name="entry">The response cache entry to store.</param>
-        /// <param name="validFor">The amount of time the entry will be kept in the cache before expiring, relative to now.</param>
-        /// <returns>No result is returned.</returns>
-        Task SetAsync(string key, IResponseCacheEntry entry, TimeSpan validFor);
     }
 }
diff --git a/src/Middleware/ResponseCaching/src/MemoryResponseCache.cs b/src/Middleware/ResponseCaching/src/MemoryResponseCache.cs
@@ -36,11 +36,6 @@ public IResponseCacheEntry Get(string key)
             }
         }
 
-        public Task<IResponseCacheEntry> GetAsync(string key)
-        {
-            return Task.FromResult(Get(key));
-        }
-
         public void Set(string key, IResponseCacheEntry entry, TimeSpan validFor)
         {
             if (entry is CachedResponse cachedResponse)
@@ -76,11 +71,5 @@ public void Set(string key, IResponseCacheEntry entry, TimeSpan validFor)
                     });
             }
         }
-
-        public Task SetAsync(string key, IResponseCacheEntry entry, TimeSpan validFor)
-        {
-            Set(key, entry, validFor);
-            return Task.CompletedTask;
-        }
     }
 }
diff --git a/src/Middleware/ResponseCaching/src/ResponseCachingMiddleware.cs b/src/Middleware/ResponseCaching/src/ResponseCachingMiddleware.cs
@@ -113,10 +113,10 @@ public async Task Invoke(HttpContext httpContext)
                         await _next(httpContext);
 
                         // If there was no response body, check the response headers now. We can cache things like redirects.
-                        await StartResponseAsync(context);
+                        StartResponse(context);
 
                         // Finalize the cache entry
-                        await FinalizeCacheBodyAsync(context);
+                        FinalizeCacheBody(context);
                     }
                     finally
                     {
@@ -211,7 +211,7 @@ internal async Task<bool> TryServeCachedResponseAsync(ResponseCachingContext con
         internal async Task<bool> TryServeFromCacheAsync(ResponseCachingContext context)
         {
             context.BaseKey = _keyProvider.CreateBaseKey(context);
-            var cacheEntry = await _cache.GetAsync(context.BaseKey);
+            var cacheEntry = _cache.Get(context.BaseKey);
 
             if (cacheEntry is CachedVaryByRules cachedVaryByRules)
             {
@@ -220,7 +220,7 @@ internal async Task<bool> TryServeFromCacheAsync(ResponseCachingContext context)
 
                 foreach (var varyKey in _keyProvider.CreateLookupVaryByKeys(context))
                 {
-                    if (await TryServeCachedResponseAsync(context, await _cache.GetAsync(varyKey)))
+                    if (await TryServeCachedResponseAsync(context, _cache.Get(varyKey)))
                     {
                         return true;
                     }
@@ -339,16 +339,7 @@ internal void FinalizeCacheHeaders(ResponseCachingContext context)
             }
         }
 
-        internal Task FinalizeCacheHeadersAsync(ResponseCachingContext context)
-        {
-            if (OnFinalizeCacheHeaders(context))
-            {
-                return _cache.SetAsync(context.BaseKey, context.CachedVaryByRules, context.CachedResponseValidFor);
-            }
-            return Task.CompletedTask;
-        }
-
-        internal async Task FinalizeCacheBodyAsync(ResponseCachingContext context)
+        internal void FinalizeCacheBody(ResponseCachingContext context)
         {
             if (context.ShouldCacheResponse && context.ResponseCachingStream.BufferingEnabled)
             {
@@ -365,7 +356,7 @@ internal async Task FinalizeCacheBodyAsync(ResponseCachingContext context)
 
                     context.CachedResponse.Body = bufferStream;
                     _logger.ResponseCached();
-                    await _cache.SetAsync(context.StorageVaryKey ?? context.BaseKey, context.CachedResponse, context.CachedResponseValidFor);
+                    _cache.Set(context.StorageVaryKey ?? context.BaseKey, context.CachedResponse, context.CachedResponseValidFor);
                 }
                 else
                 {
@@ -403,15 +394,6 @@ internal void StartResponse(ResponseCachingContext context)
             }
         }
 
-        internal Task StartResponseAsync(ResponseCachingContext context)
-        {
-            if (OnStartResponse(context))
-            {
-                return FinalizeCacheHeadersAsync(context);
-            }
-            return Task.CompletedTask;
-        }
-
         internal static void AddResponseCachingFeature(HttpContext context)
         {
             if (context.Features.Get<IResponseCachingFeature>() != null)
@@ -429,8 +411,7 @@ internal void ShimResponseStream(ResponseCachingContext context)
                 context.OriginalResponseStream,
                 _options.MaximumBodySize,
                 StreamUtilities.BodySegmentSize,
-                () => StartResponse(context),
-                () => StartResponseAsync(context));
+                () => StartResponse(context));
             context.HttpContext.Response.Body = context.ResponseCachingStream;
 
             // Add IResponseCachingFeature
diff --git a/src/Middleware/ResponseCaching/src/Streams/ResponseCachingStream.cs b/src/Middleware/ResponseCaching/src/Streams/ResponseCachingStream.cs
@@ -1,4 +1,4 @@
-﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -15,15 +15,13 @@ internal class ResponseCachingStream : Stream
         private readonly int _segmentSize;
         private readonly SegmentWriteStream _segmentWriteStream;
         private readonly Action _startResponseCallback;
-        private readonly Func<Task> _startResponseCallbackAsync;
 
-        internal ResponseCachingStream(Stream innerStream, long maxBufferSize, int segmentSize, Action startResponseCallback, Func<Task> startResponseCallbackAsync)
+        internal ResponseCachingStream(Stream innerStream, long maxBufferSize, int segmentSize, Action startResponseCallback)
         {
             _innerStream = innerStream;
             _maxBufferSize = maxBufferSize;
             _segmentSize = segmentSize;
             _startResponseCallback = startResponseCallback;
-            _startResponseCallbackAsync = startResponseCallbackAsync;
             _segmentWriteStream = new SegmentWriteStream(_segmentSize);
         }
 
@@ -92,7 +90,7 @@ public override async Task FlushAsync(CancellationToken cancellationToken)
         {
             try
             {
-                await _startResponseCallbackAsync();
+                _startResponseCallback();
                 await _innerStream.FlushAsync();
             }
             catch
@@ -136,7 +134,7 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc
         {
             try
             {
-                await _startResponseCallbackAsync();
+                _startResponseCallback();
                 await _innerStream.WriteAsync(buffer, offset, count, cancellationToken);
             }
             catch
diff --git a/src/Middleware/ResponseCaching/test/ResponseCachingMiddlewareTests.cs b/src/Middleware/ResponseCaching/test/ResponseCachingMiddlewareTests.cs
diff --git a/src/Middleware/ResponseCaching/test/TestUtils.cs b/src/Middleware/ResponseCaching/test/TestUtils.cs

Original file line number	Diff line number	Diff line change
`@@ -36,11 +36,6 @@ public IResponseCacheEntry Get(string key)`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`- public Task<IResponseCacheEntry> GetAsync(string key)`
`40`		`- {`
`41`		`- return Task.FromResult(Get(key));`
`42`		`- }`
`43`		`-`
`44`	`39`	`public void Set(string key, IResponseCacheEntry entry, TimeSpan validFor)`
`45`	`40`	`{`
`46`	`41`	`if (entry is CachedResponse cachedResponse)`
`@@ -76,11 +71,5 @@ public void Set(string key, IResponseCacheEntry entry, TimeSpan validFor)`
`76`	`71`	`});`
`77`	`72`	`}`
`78`	`73`	`}`
`79`		`-`
`80`		`- public Task SetAsync(string key, IResponseCacheEntry entry, TimeSpan validFor)`
`81`		`- {`
`82`		`- Set(key, entry, validFor);`
`83`		`- return Task.CompletedTask;`
`84`		`- }`
`85`	`74`	`}`
`86`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,10 +113,10 @@ public async Task Invoke(HttpContext httpContext)`
`113`	`113`	`await _next(httpContext);`
`114`	`114`
`115`	`115`	`// If there was no response body, check the response headers now. We can cache things like redirects.`
`116`		`- await StartResponseAsync(context);`
	`116`	`+ StartResponse(context);`
`117`	`117`
`118`	`118`	`// Finalize the cache entry`
`119`		`- await FinalizeCacheBodyAsync(context);`
	`119`	`+ FinalizeCacheBody(context);`
`120`	`120`	`}`
`121`	`121`	`finally`
`122`	`122`	`{`
`@@ -211,7 +211,7 @@ internal async Task<bool> TryServeCachedResponseAsync(ResponseCachingContext con`
`211`	`211`	`internal async Task<bool> TryServeFromCacheAsync(ResponseCachingContext context)`
`212`	`212`	`{`
`213`	`213`	`context.BaseKey = _keyProvider.CreateBaseKey(context);`
`214`		`- var cacheEntry = await _cache.GetAsync(context.BaseKey);`
	`214`	`+ var cacheEntry = _cache.Get(context.BaseKey);`
`215`	`215`
`216`	`216`	`if (cacheEntry is CachedVaryByRules cachedVaryByRules)`
`217`	`217`	`{`
`@@ -220,7 +220,7 @@ internal async Task<bool> TryServeFromCacheAsync(ResponseCachingContext context)`
`220`	`220`
`221`	`221`	`foreach (var varyKey in _keyProvider.CreateLookupVaryByKeys(context))`
`222`	`222`	`{`
`223`		`- if (await TryServeCachedResponseAsync(context, await _cache.GetAsync(varyKey)))`
	`223`	`+ if (await TryServeCachedResponseAsync(context, _cache.Get(varyKey)))`
`224`	`224`	`{`
`225`	`225`	`return true;`
`226`	`226`	`}`
`@@ -339,16 +339,7 @@ internal void FinalizeCacheHeaders(ResponseCachingContext context)`
`339`	`339`	`}`
`340`	`340`	`}`
`341`	`341`
`342`		`- internal Task FinalizeCacheHeadersAsync(ResponseCachingContext context)`
`343`		`- {`
`344`		`- if (OnFinalizeCacheHeaders(context))`
`345`		`- {`
`346`		`- return _cache.SetAsync(context.BaseKey, context.CachedVaryByRules, context.CachedResponseValidFor);`
`347`		`- }`
`348`		`- return Task.CompletedTask;`
`349`		`- }`
`350`		`-`
`351`		`- internal async Task FinalizeCacheBodyAsync(ResponseCachingContext context)`
	`342`	`+ internal void FinalizeCacheBody(ResponseCachingContext context)`
`352`	`343`	`{`
`353`	`344`	`if (context.ShouldCacheResponse && context.ResponseCachingStream.BufferingEnabled)`
`354`	`345`	`{`
`@@ -365,7 +356,7 @@ internal async Task FinalizeCacheBodyAsync(ResponseCachingContext context)`
`365`	`356`
`366`	`357`	`context.CachedResponse.Body = bufferStream;`
`367`	`358`	`_logger.ResponseCached();`
`368`		`- await _cache.SetAsync(context.StorageVaryKey ?? context.BaseKey, context.CachedResponse, context.CachedResponseValidFor);`
	`359`	`+ _cache.Set(context.StorageVaryKey ?? context.BaseKey, context.CachedResponse, context.CachedResponseValidFor);`
`369`	`360`	`}`
`370`	`361`	`else`
`371`	`362`	`{`
`@@ -403,15 +394,6 @@ internal void StartResponse(ResponseCachingContext context)`
`403`	`394`	`}`
`404`	`395`	`}`
`405`	`396`
`406`		`- internal Task StartResponseAsync(ResponseCachingContext context)`
`407`		`- {`
`408`		`- if (OnStartResponse(context))`
`409`		`- {`
`410`		`- return FinalizeCacheHeadersAsync(context);`
`411`		`- }`
`412`		`- return Task.CompletedTask;`
`413`		`- }`
`414`		`-`
`415`	`397`	`internal static void AddResponseCachingFeature(HttpContext context)`
`416`	`398`	`{`
`417`	`399`	`if (context.Features.Get<IResponseCachingFeature>() != null)`
`@@ -429,8 +411,7 @@ internal void ShimResponseStream(ResponseCachingContext context)`
`429`	`411`	`context.OriginalResponseStream,`
`430`	`412`	`_options.MaximumBodySize,`
`431`	`413`	`StreamUtilities.BodySegmentSize,`
`432`		`- () => StartResponse(context),`
`433`		`- () => StartResponseAsync(context));`
	`414`	`+ () => StartResponse(context));`
`434`	`415`	`context.HttpContext.Response.Body = context.ResponseCachingStream;`
`435`	`416`
`436`	`417`	`// Add IResponseCachingFeature`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// Copyright (c) .NET Foundation. All rights reserved.`
	`1`	`+// Copyright (c) .NET Foundation. All rights reserved.`
`2`	`2`	`// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
`3`	`3`
`4`	`4`	`using System;`
`@@ -15,15 +15,13 @@ internal class ResponseCachingStream : Stream`
`15`	`15`	`private readonly int _segmentSize;`
`16`	`16`	`private readonly SegmentWriteStream _segmentWriteStream;`
`17`	`17`	`private readonly Action _startResponseCallback;`
`18`		`- private readonly Func<Task> _startResponseCallbackAsync;`
`19`	`18`
`20`		`- internal ResponseCachingStream(Stream innerStream, long maxBufferSize, int segmentSize, Action startResponseCallback, Func<Task> startResponseCallbackAsync)`
	`19`	`+ internal ResponseCachingStream(Stream innerStream, long maxBufferSize, int segmentSize, Action startResponseCallback)`
`21`	`20`	`{`
`22`	`21`	`_innerStream = innerStream;`
`23`	`22`	`_maxBufferSize = maxBufferSize;`
`24`	`23`	`_segmentSize = segmentSize;`
`25`	`24`	`_startResponseCallback = startResponseCallback;`
`26`		`- _startResponseCallbackAsync = startResponseCallbackAsync;`
`27`	`25`	`_segmentWriteStream = new SegmentWriteStream(_segmentSize);`
`28`	`26`	`}`
`29`	`27`
`@@ -92,7 +90,7 @@ public override async Task FlushAsync(CancellationToken cancellationToken)`
`92`	`90`	`{`
`93`	`91`	`try`
`94`	`92`	`{`
`95`		`- await _startResponseCallbackAsync();`
	`93`	`+ _startResponseCallback();`
`96`	`94`	`await _innerStream.FlushAsync();`
`97`	`95`	`}`
`98`	`96`	`catch`
`@@ -136,7 +134,7 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc`
`136`	`134`	`{`
`137`	`135`	`try`
`138`	`136`	`{`
`139`		`- await _startResponseCallbackAsync();`
	`137`	`+ _startResponseCallback();`
`140`	`138`	`await _innerStream.WriteAsync(buffer, offset, count, cancellationToken);`
`141`	`139`	`}`
`142`	`140`	`catch`