/** * Constructs a caching HttpJsonHomeClient using a HttpClient, HttpCacheStorage and a CacheConfig. * * @param httpClient non-caching HttpClient used to get resources. * @param storage the HttpCacheStorage used to cache HTTP responses. * @param cacheConfig configuration of the HttpCacheStorage */ public HttpJsonHomeClient(final HttpClient httpClient, final HttpCacheStorage storage, final CacheConfig cacheConfig) { this.cacheStorage = storage; this.httpClient = new CachingHttpClient(httpClient, cacheStorage, cacheConfig); }
private HttpResponse handleCacheMiss(final HttpHost target, final HttpRequestWrapper request, final HttpContext context) throws IOException { recordCacheMiss(target, request); if (!mayCallBackend(request)) { return 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(target, request, context, variants); } return callBackend(target, request, context); }
public <T> T execute(HttpHost target, HttpRequest request, ResponseHandler<? extends T> responseHandler, HttpContext context) throws IOException { HttpResponse resp = execute(target, request, context); return handleAndConsume(responseHandler,resp); }
Date requestDate = getCurrentDate(); HttpResponse backendResponse = backend.execute(target, conditionalRequest, context); Date responseDate = getCurrentDate(); backendResponse.addHeader("Via", generateViaHeader(backendResponse)); return handleBackendResponse(target, request, requestDate, responseDate, backendResponse); if (resultEtagHeader == null) { log.warn("304 response did not contain ETag"); return callBackend(target, request, context); if (matchingVariant == null) { log.debug("304 response did not contain ETag matching one sent in If-None-Match"); return callBackend(target, request, context); if (revalidationResponseIsTooOld(backendResponse, matchedEntry)) { EntityUtils.consume(backendResponse.getEntity()); return retryRequestUnconditionally(target, request, context, matchedEntry); recordCacheUpdate(context); HttpCacheEntry responseEntry = getUpdatedVariantEntry(target, conditionalRequest, requestDate, responseDate, backendResponse, matchingVariant, matchedEntry); tryToUpdateVariantMap(target, request, matchingVariant);
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) throws IOException { // default response context setResponseStatus(context, CacheResponseStatus.CACHE_MISS); String via = generateViaHeader(request); if (clientRequestsOurOptions(request)) { setResponseStatus(context, CacheResponseStatus.CACHE_MODULE_RESPONSE); return new OptionsHttp11Response(); } HttpResponse fatalErrorResponse = getFatallyNoncompliantResponse( request, context); if (fatalErrorResponse != null) return fatalErrorResponse; request = requestCompliance.makeRequestCompliant(request); request.addHeader("Via",via); flushEntriesInvalidatedByRequest(target, request); if (!cacheableRequestPolicy.isServableFromCache(request)) { return callBackend(target, request, context); } HttpCacheEntry entry = satisfyFromCache(target, request); if (entry == null) { return handleCacheMiss(target, request, context); } return handleCacheHit(target, request, context, entry); }
private HttpResponse handleCacheHit(HttpHost target, HttpRequest request, HttpContext context, HttpCacheEntry entry) throws ClientProtocolException, IOException { recordCacheHit(target, request); HttpResponse out = null; Date now = getCurrentDate(); if (suitabilityChecker.canCachedResponseBeUsed(target, request, entry, now)) { out = generateCachedResponse(request, context, entry, now); } else if (!mayCallBackend(request)) { out = generateGatewayTimeout(context); } else if (validityPolicy.isRevalidatable(entry)) { return revalidateCacheEntry(target, request, context, entry, now); } else { return callBackend(target, request, context); } if (context != null) { context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target); context.setAttribute(ExecutionContext.HTTP_REQUEST, request); context.setAttribute(ExecutionContext.HTTP_RESPONSE, out); context.setAttribute(ExecutionContext.HTTP_REQ_SENT, true); } return out; }
public <T> T execute(final HttpHost target, final HttpRequest request, final ResponseHandler<? extends T> responseHandler) throws IOException { return execute(target, request, responseHandler, null); }
private boolean staleResponseNotAllowed(final HttpRequestWrapper request, final HttpCacheEntry entry, final Date now) { return validityPolicy.mustRevalidate(entry) || (isSharedCache() && validityPolicy.proxyRevalidate(entry)) || explicitFreshnessRequest(request, entry, now); }
HttpResponse handleBackendResponse( final HttpHost target, final HttpRequestWrapper request, final Date requestDate, final Date responseDate, final HttpResponse backendResponse) throws IOException { log.trace("Handling Backend response"); responseCompliance.ensureProtocolCompliance(request, backendResponse); final boolean cacheable = responseCachingPolicy.isResponseCacheable(request, backendResponse); responseCache.flushInvalidatedCacheEntriesFor(target, request, backendResponse); if (cacheable && !alreadyHaveNewerCacheEntry(target, request, backendResponse)) { try { storeRequestIfModifiedSinceFor304Response(request, backendResponse); return responseCache.cacheAndReturnResponse(target, request, backendResponse, requestDate, responseDate); } catch (final IOException ioe) { log.warn("Unable to store entries in cache", ioe); } } if (!cacheable) { try { responseCache.flushCacheEntriesFor(target, request); } catch (final IOException ioe) { log.warn("Unable to flush invalid cache entries", ioe); } } return backendResponse; }
private HttpResponse retryRequestUnconditionally(final HttpHost target, final HttpRequestWrapper request, final HttpContext context, final HttpCacheEntry matchedEntry) throws IOException { final HttpRequestWrapper unconditional = conditionalRequestBuilder .buildUnconditionalRequest(request, matchedEntry); return callBackend(target, unconditional, context); }
HttpResponse handleBackendResponse( HttpHost target, HttpRequest request, Date requestDate, Date responseDate, HttpResponse backendResponse) throws IOException { log.trace("Handling Backend response"); responseCompliance.ensureProtocolCompliance(request, backendResponse); boolean cacheable = responseCachingPolicy.isResponseCacheable(request, backendResponse); responseCache.flushInvalidatedCacheEntriesFor(target, request, backendResponse); if (cacheable && !alreadyHaveNewerCacheEntry(target, request, backendResponse)) { try { return responseCache.cacheAndReturnResponse(target, request, backendResponse, requestDate, responseDate); } catch (IOException ioe) { log.warn("Unable to store entries in cache", ioe); } } if (!cacheable) { try { responseCache.flushCacheEntriesFor(target, request); } catch (IOException ioe) { log.warn("Unable to flush invalid cache entries", ioe); } } return backendResponse; }
final Date requestDate = getCurrentDate(); final HttpResponse backendResponse = backend.execute(target, conditionalRequest, context); final Date responseDate = getCurrentDate(); backendResponse.addHeader("Via", generateViaHeader(backendResponse)); return handleBackendResponse(target, request, requestDate, responseDate, backendResponse); if (resultEtagHeader == null) { log.warn("304 response did not contain ETag"); return callBackend(target, request, context); if (matchingVariant == null) { log.debug("304 response did not contain ETag matching one sent in If-None-Match"); return callBackend(target, request, context); if (revalidationResponseIsTooOld(backendResponse, matchedEntry)) { IOUtils.consume(backendResponse.getEntity()); return retryRequestUnconditionally(target, request, context, matchedEntry); recordCacheUpdate(context); final HttpCacheEntry responseEntry = getUpdatedVariantEntry(target, conditionalRequest, requestDate, responseDate, backendResponse, matchingVariant, matchedEntry); tryToUpdateVariantMap(target, request, matchingVariant);
request = HttpRequestWrapper.wrap(originalRequest); final String via = generateViaHeader(originalRequest); setResponseStatus(context, CacheResponseStatus.CACHE_MISS); if (clientRequestsOurOptions(request)) { setResponseStatus(context, CacheResponseStatus.CACHE_MODULE_RESPONSE); return new OptionsHttp11Response(); final HttpResponse fatalErrorResponse = getFatallyNoncompliantResponse( request, context); if (fatalErrorResponse != null) { request.addHeader("Via",via); flushEntriesInvalidatedByRequest(target, request); return callBackend(target, request, context); final HttpCacheEntry entry = satisfyFromCache(target, request); if (entry == null) { log.debug("Cache miss"); return handleCacheMiss(target, request, context); return handleCacheHit(target, request, context, entry);
public <T> T execute(HttpHost target, HttpRequest request, ResponseHandler<? extends T> responseHandler) throws IOException { return execute(target, request, responseHandler, null); }
private boolean staleResponseNotAllowed(HttpRequest request, HttpCacheEntry entry, Date now) { return validityPolicy.mustRevalidate(entry) || (isSharedCache() && validityPolicy.proxyRevalidate(entry)) || explicitFreshnessRequest(request, entry, now); }
private HttpResponse retryRequestUnconditionally(HttpHost target, HttpRequest request, HttpContext context, HttpCacheEntry matchedEntry) throws IOException { HttpRequest unconditional = conditionalRequestBuilder .buildUnconditionalRequest(request, matchedEntry); return callBackend(target, unconditional, context); }
/** * Constructs a HttpJsonHomeClient using a HttpClient and a CacheConfig. * * Internally, these two are used to build a CachingHttpClient using a BasicHttpCacheStorage. * * @param httpClient non-caching HttpClient used to get resources. * @param cacheConfig configuration of the HttpCacheStorage */ public HttpJsonHomeClient(final HttpClient httpClient, final CacheConfig cacheConfig) { this.cacheStorage = new BasicHttpCacheStorage(cacheConfig); this.httpClient = new CachingHttpClient(httpClient, cacheStorage, cacheConfig); }
private HttpResponse handleCacheMiss(HttpHost target, HttpRequest request, HttpContext context) throws IOException { recordCacheMiss(target, request); if (!mayCallBackend(request)) { return new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_GATEWAY_TIMEOUT, "Gateway Timeout"); } Map<String, Variant> variants = getExistingCacheVariants(target, request); if (variants != null && variants.size() > 0) { return negotiateResponseFromVariants(target, request, context, variants); } return callBackend(target, request, context); }
public <T> T execute(final HttpHost target, final HttpRequest request, final ResponseHandler<? extends T> responseHandler, final HttpContext context) throws IOException { final HttpResponse resp = execute(target, request, context); return handleAndConsume(responseHandler,resp); }
public HttpResponse execute(HttpHost target, HttpRequest request) throws IOException { HttpContext defaultContext = null; return execute(target, request, defaultContext); }