protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (BypassPrivateCache(request))
{
var response = await base.SendAsync(request, cancellationToken);
response = await ProcessResponseCaching(response);
return(response);
}
var requestUrl = request.RequestUri.AbsoluteUri;
if (_cache.IsExpired(requestUrl))
{
var eTag = _cache.GetETag(requestUrl);
if (eTag != null)
{
request.Headers.IfNoneMatch.TryParseAdd(eTag);
}
var response = await base.SendAsync(request, cancellationToken);
response = await ProcessResponseCaching(response);
if (response.StatusCode == HttpStatusCode.NotModified)
{
response.StatusCode = HttpStatusCode.OK;
}
return(response);
}
var cachedResponse = _cache.Get(requestUrl);
var bytes = Convert.FromBase64String(cachedResponse);
var httpResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
//Content = new StringContent(cachedResponse)
Content = new StreamContent(new MemoryStream(bytes))
};
return(httpResponse);
}
private async Task <IResponseMessage> GetResponseFromCache(string key)
{
var cacheTask = _responseCache.Get(key, false);
if (cacheTask != null)
{
return(await cacheTask.ConfigureAwait(false));
}
return(null);
}
public void GetCallsCacheAndSerializer()
{
_distributedResponseCache.Get(Key);
A.CallTo(() => _fakeDistributedCache.Get(Key))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _fakeCacheSerializer.Deserialize(_serializedValue))
.MustHaveHappenedOnceExactly();
}
private async Task <string> GetResponseFromCache(string key)
{
var cacheTask = _responseCache.Get(key, false);
if (cacheTask != null)
{
var responseText = await cacheTask.ConfigureAwait(false);
return(responseText);
}
return(null);
}
public void HandleResponse(Session session)
{
var key = $"{session.RequestMethod}_{session.hostname}_{session.url}";
_logger.Verbose("{ThisMethod} for {Method} {Url} {StatusCode}", nameof(HandleResponse), session.RequestMethod, session.url, session.responseCode);
if (IsResponseSuccessful(session))
{
_logger.Verbose("Response was successful");
if (!_responseCache.IsCached(key))
{
_logger.Info("Response was not previously cached, adding");
var responseBodyBytes = new byte[session.responseBodyBytes.Length];
session.responseBodyBytes.CopyTo(responseBodyBytes, 0);
_responseCache.Add(key, new ResponseCacheItem
{
ResponseBodyBytes = responseBodyBytes,
ResponseCode = session.responseCode
});
}
else
{
_logger.Verbose("Response was previously cached");
}
}
else
{
_logger.Info("Response was not successful");
if (_responseCache.IsCached(key))
{
_logger.Info("Response was previously cached");
var cachedSession = _responseCache.Get(key);
session.responseCode = cachedSession.ResponseCode;
var newResponseBodyBytes = new byte[cachedSession.ResponseBodyBytes.Length];
cachedSession.ResponseBodyBytes.CopyTo(newResponseBodyBytes, 0);
session.responseBodyBytes = newResponseBodyBytes;
_logger.Info("Replaced failed response with cached response");
}
else
{
_logger.Info("Response was not previously cached");
}
}
}
public IResponse Execute(IRequest request)
{
IResponse cachedResponse = cache.Get(request);
if (cachedResponse != null)
{
return(cachedResponse);
}
IResponse response = proxiedAction.Execute(request);
cache.Insert(request, response);
return(response);
}
internal async Task <bool> TryServeFromCacheAsync(ResponseCachingContext context)
{
context.BaseKey = _keyProvider.CreateBaseKey(context);
var cacheEntry = _cache.Get(context.BaseKey);
if (cacheEntry is CachedVaryByRules cachedVaryByRules)
{
// Request contains vary rules, recompute key(s) and try again
context.CachedVaryByRules = cachedVaryByRules;
foreach (var varyKey in _keyProvider.CreateLookupVaryByKeys(context))
{
if (await TryServeCachedResponseAsync(context, _cache.Get(varyKey)))
{
return(true);
}
}
}
else
{
if (await TryServeCachedResponseAsync(context, cacheEntry))
{
return(true);
}
}
if (HeaderUtilities.ContainsCacheDirective(context.HttpContext.Request.Headers.CacheControl, CacheControlHeaderValue.OnlyIfCachedString))
{
_logger.GatewayTimeoutServed();
context.HttpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;
return(true);
}
_logger.NoResponseServed();
return(false);
}
private Response CacheLookup(Question question)
{
if (!UseCache)
{
return(null);
}
Response response = _cache.Get(question);
if (response == null)
{
return(null);
}
return(response.Answers.Any(x => x.IsExpired(response.TimeStamp)) ? null : response);
}
/// <summary>
/// Called when [next].
/// </summary>
/// <param name="value">The value.</param>
public void OnNext(UrlRequest value)
{
Response response = _cache.Get(value);
if (response == null)
{
// push to processing
Log.DebugFormat("Download needed for url: {0}", value.Url);
_downloadRequired.OnNext(value);
}
else
{
// push to cached results
Log.DebugFormat("Cached response found for url: {0}", value.Url);
_cachedResults.OnNext(new Result(value, response));
}
}
public void CacheGetNullReturnsNull()
{
var result = _distributedResponseCache.Get(Key);
Assert.Null(result);
}
