private CloseableHttpResponse handleCacheMiss( final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context, final HttpExecutionAware execAware) throws IOException, HttpException { final HttpHost target = context.getTargetHost(); recordCacheMiss(target, request); if (!mayCallBackend(request)) { return Proxies.enhanceResponse( new BasicHttpResponse( HttpVersion.HTTP_1_1, HttpStatus.SC_GATEWAY_TIMEOUT, "Gateway Timeout")); } final Map<String, Variant> variants = getExistingCacheVariants(target, request); if (variants != null && variants.size() > 0) { return negotiateResponseFromVariants(route, request, context, execAware, variants); } return callBackend(route, request, context, execAware); }
public CloseableHttpResponse execute( final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context) throws IOException, HttpException { return execute(route, request, context, null); }
private CloseableHttpResponse handleRevalidationFailure( final HttpRequestWrapper request, final HttpContext context, final HttpCacheEntry entry, final Date now) { if (staleResponseNotAllowed(request, entry, now)) { return generateGatewayTimeout(context); } else { return unvalidatedCacheHit(context, entry); } }
CloseableHttpResponse callBackend( final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context, final HttpExecutionAware execAware) throws IOException, HttpException { final Date requestDate = getCurrentDate(); log.trace("Calling the backend"); final CloseableHttpResponse backendResponse = backend.execute(route, request, context, execAware); try { backendResponse.addHeader("Via", generateViaHeader(backendResponse)); return handleBackendResponse(route, request, context, execAware, requestDate, getCurrentDate(), backendResponse); } catch (final IOException ex) { backendResponse.close(); throw ex; } catch (final RuntimeException ex) { backendResponse.close(); throw ex; } }
final Date requestDate = getCurrentDate(); final CloseableHttpResponse backendResponse = backend.execute( route, conditionalRequest, context, execAware); try { final Date responseDate = getCurrentDate(); backendResponse.addHeader("Via", generateViaHeader(backendResponse)); return handleBackendResponse( route, request, context, execAware, requestDate, responseDate, backendResponse); IOUtils.consume(backendResponse.getEntity()); backendResponse.close(); return callBackend(route, request, context, execAware); IOUtils.consume(backendResponse.getEntity()); backendResponse.close(); return callBackend(route, request, context, execAware); if (revalidationResponseIsTooOld(backendResponse, matchedEntry)) { IOUtils.consume(backendResponse.getEntity()); backendResponse.close(); return retryRequestUnconditionally(route, request, context, execAware, matchedEntry); recordCacheUpdate(context); final HttpCacheEntry responseEntry = getUpdatedVariantEntry( context.getTargetHost(), conditionalRequest, requestDate, responseDate,
final String via = generateViaHeader(request.getOriginal()); setResponseStatus(context, CacheResponseStatus.CACHE_MISS); if (clientRequestsOurOptions(request)) { setResponseStatus(context, CacheResponseStatus.CACHE_MODULE_RESPONSE); return Proxies.enhanceResponse(new OptionsHttp11Response()); final HttpResponse fatalErrorResponse = getFatallyNoncompliantResponse(request, context); if (fatalErrorResponse != null) { return Proxies.enhanceResponse(fatalErrorResponse); request.addHeader("Via",via); flushEntriesInvalidatedByRequest(context.getTargetHost(), request); return callBackend(route, request, context, execAware); final HttpCacheEntry entry = satisfyFromCache(target, request); if (entry == null) { log.debug("Cache miss"); return handleCacheMiss(route, request, context, execAware); } else { return handleCacheHit(route, request, context, execAware, entry);
final HttpCacheEntry entry) throws IOException, HttpException { final HttpHost target = context.getTargetHost(); recordCacheHit(target, request); CloseableHttpResponse out = null; final Date now = getCurrentDate(); if (suitabilityChecker.canCachedResponseBeUsed(target, request, entry, now)) { log.debug("Cache hit"); out = generateCachedResponse(request, context, entry, now); } else if (!mayCallBackend(request)) { log.debug("Cache entry not suitable but only-if-cached requested"); out = generateGatewayTimeout(context); } else if (!(entry.getStatusCode() == HttpStatus.SC_NOT_MODIFIED && !suitabilityChecker.isConditional(request))) { log.debug("Revalidating cache entry"); return revalidateCacheEntry(route, request, context, execAware, entry, now); } else { log.debug("Cache entry not usable; calling backend"); return callBackend(route, request, context, execAware);
Date requestDate = getCurrentDate(); CloseableHttpResponse backendResponse = backend.execute( route, conditionalRequest, context, execAware); Date responseDate = getCurrentDate(); if (revalidationResponseIsTooOld(backendResponse, cacheEntry)) { backendResponse.close(); final HttpRequestWrapper unconditional = conditionalRequestBuilder .buildUnconditionalRequest(request, cacheEntry); requestDate = getCurrentDate(); backendResponse = backend.execute(route, unconditional, context, execAware); responseDate = getCurrentDate(); backendResponse.addHeader(HeaderConstants.VIA, generateViaHeader(backendResponse)); recordCacheUpdate(context); if (staleIfErrorAppliesTo(statusCode) && !staleResponseNotAllowed(request, cacheEntry, getCurrentDate()) && validityPolicy.mayReturnStaleIfError(request, cacheEntry, responseDate)) { try { return handleBackendResponse( route, conditionalRequest, context, execAware, requestDate, responseDate, backendResponse);
&& !staleResponseNotAllowed(request, entry, now) && validityPolicy.mayReturnStaleWhileRevalidating(entry, now)) { log.trace("Serving stale with asynchronous revalidation"); final CloseableHttpResponse resp = generateCachedResponse(request, context, entry, now); asynchRevalidator.revalidateCacheEntry(this, route, request, context, execAware, entry); return resp; return revalidateCacheEntry(route, request, context, execAware, entry); } catch (final IOException ioex) { return handleRevalidationFailure(request, context, entry, now);
CloseableHttpResponse handleBackendResponse( final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context, final HttpExecutionAware execAware, final Date requestDate, final Date responseDate, final CloseableHttpResponse backendResponse) throws IOException { log.trace("Handling Backend response"); responseCompliance.ensureProtocolCompliance(request, backendResponse); final HttpHost target = context.getTargetHost(); final boolean cacheable = responseCachingPolicy.isResponseCacheable(request, backendResponse); responseCache.flushInvalidatedCacheEntriesFor(target, request, backendResponse); if (cacheable && !alreadyHaveNewerCacheEntry(target, request, backendResponse)) { storeRequestIfModifiedSinceFor304Response(request, backendResponse); return responseCache.cacheAndReturnResponse(target, request, backendResponse, requestDate, responseDate); } if (!cacheable) { try { responseCache.flushCacheEntriesFor(target, request); } catch (final IOException ioe) { log.warn("Unable to flush invalid cache entries", ioe); } } return backendResponse; }
private CloseableHttpResponse retryRequestUnconditionally( final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context, final HttpExecutionAware execAware, final HttpCacheEntry matchedEntry) throws IOException, HttpException { final HttpRequestWrapper unconditional = conditionalRequestBuilder .buildUnconditionalRequest(request, matchedEntry); return callBackend(route, unconditional, context, execAware); }
private boolean staleResponseNotAllowed( final HttpRequestWrapper request, final HttpCacheEntry entry, final Date now) { return validityPolicy.mustRevalidate(entry) || (cacheConfig.isSharedCache() && validityPolicy.proxyRevalidate(entry)) || explicitFreshnessRequest(request, entry, now); }
return new CachingExec(mainExec, new BasicHttpCache( resourceFactory,