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); }