Example usage for org.apache.http.impl.client.cache Proxies enhanceResponse

Introduction

In this page you can find the example usage for org.apache.http.impl.client.cache Proxies enhanceResponse.

Prototype

public static CloseableHttpResponse enhanceResponse(final HttpResponse original) 

Source Link

Usage

From source file:org.apache.http.impl.client.cache.CachingExec.java

public CloseableHttpResponse execute(final HttpRoute route, final HttpRequestWrapper request,
        final HttpClientContext context, final HttpExecutionAware execAware) throws IOException, HttpException {

    final HttpHost target = context.getTargetHost();
    final String via = generateViaHeader(request.getOriginal());

    // default response context
    setResponseStatus(context, CacheResponseStatus.CACHE_MISS);

    if (clientRequestsOurOptions(request)) {
        setResponseStatus(context, CacheResponseStatus.CACHE_MODULE_RESPONSE);
        return Proxies.enhanceResponse(new OptionsHttp11Response());
    }/* w ww . ja va2  s  .  c  o  m*/

    final HttpResponse fatalErrorResponse = getFatallyNoncompliantResponse(request, context);
    if (fatalErrorResponse != null) {
        return Proxies.enhanceResponse(fatalErrorResponse);
    }

    requestCompliance.makeRequestCompliant(request);
    request.addHeader("Via", via);

    flushEntriesInvalidatedByRequest(context.getTargetHost(), request);

    if (!cacheableRequestPolicy.isServableFromCache(request)) {
        log.debug("Request is not servable from cache");
        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);
    }
}

---

From source file:org.apache.http.impl.client.cache.CachingExec.java

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);/*from w  ww .  java  2s  .  c om*/

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

---

From source file:org.apache.http.impl.client.cache.CachingExec.java

private CloseableHttpResponse generateGatewayTimeout(final HttpContext context) {
    setResponseStatus(context, CacheResponseStatus.CACHE_MODULE_RESPONSE);
    return Proxies.enhanceResponse(
            new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_GATEWAY_TIMEOUT, "Gateway Timeout"));
}

---

From source file:org.apache.http.impl.client.cache.CachingHttpAsyncClient.java

void callBackend(final BasicFuture<HttpResponse> future, final HttpHost target,
        final HttpRequestWrapper request, final HttpCacheContext clientContext) {
    final Date requestDate = getCurrentDate();
    this.log.trace("Calling the backend");

    final ChainedFutureCallback<HttpResponse> chainedFutureCallback = new ChainedFutureCallback<HttpResponse>(
            future) {// w w w  .jav  a  2  s. com

        @Override
        public void completed(final HttpResponse httpResponse) {
            httpResponse.addHeader(HeaderConstants.VIA, generateViaHeader(httpResponse));
            try {
                final CloseableHttpResponse backendResponse = handleBackendResponse(target, request,
                        requestDate, getCurrentDate(), Proxies.enhanceResponse(httpResponse));
                super.completed(backendResponse);
            } catch (final IOException e) {
                super.failed(e);
            }

        }

    };
    this.backend.execute(target, request, clientContext, chainedFutureCallback);
}

---

From source file:org.apache.http.impl.client.cache.CachingHttpAsyncClient.java

void negotiateResponseFromVariants(final BasicFuture<HttpResponse> future, final HttpHost target,
        final HttpRequestWrapper request, final HttpCacheContext clientContext,
        final Map<String, Variant> variants) {
    final HttpRequest conditionalRequest = this.conditionalRequestBuilder
            .buildConditionalRequestFromVariants(request, variants);

    final Date requestDate = getCurrentDate();

    final ChainedFutureCallback<HttpResponse> chainedFutureCallback = new ChainedFutureCallback<HttpResponse>(
            future) {//from w w  w . j  av a 2s . c o  m

        @Override
        public void completed(final HttpResponse httpResponse) {
            final Date responseDate = getCurrentDate();

            httpResponse.addHeader(HeaderConstants.VIA, generateViaHeader(httpResponse));

            if (httpResponse.getStatusLine().getStatusCode() != HttpStatus.SC_NOT_MODIFIED) {
                try {
                    future.completed(handleBackendResponse(target, request, requestDate, responseDate,
                            Proxies.enhanceResponse(httpResponse)));
                    return;
                } catch (final IOException e) {
                    future.failed(e);
                    return;
                }
            }

            final Header resultEtagHeader = httpResponse.getFirstHeader(HeaderConstants.ETAG);
            if (resultEtagHeader == null) {
                CachingHttpAsyncClient.this.log.warn("304 response did not contain ETag");
                callBackend(future, target, request, clientContext);
                return;
            }

            final String resultEtag = resultEtagHeader.getValue();
            final Variant matchingVariant = variants.get(resultEtag);
            if (matchingVariant == null) {
                CachingHttpAsyncClient.this.log
                        .debug("304 response did not contain ETag matching one sent in If-None-Match");
                callBackend(future, target, request, clientContext);
            }

            final HttpCacheEntry matchedEntry = matchingVariant.getEntry();

            if (revalidationResponseIsTooOld(httpResponse, matchedEntry)) {
                EntityUtils.consumeQuietly(httpResponse.getEntity());
                retryRequestUnconditionally(future, target, request, clientContext, matchedEntry);
                return;
            }

            recordCacheUpdate(clientContext);

            final HttpCacheEntry responseEntry = getUpdatedVariantEntry(target, conditionalRequest, requestDate,
                    responseDate, httpResponse, matchingVariant, matchedEntry);

            final HttpResponse resp = CachingHttpAsyncClient.this.responseGenerator.generateResponse(request,
                    responseEntry);
            tryToUpdateVariantMap(target, request, matchingVariant);

            if (shouldSendNotModifiedResponse(request, responseEntry)) {
                future.completed(CachingHttpAsyncClient.this.responseGenerator
                        .generateNotModifiedResponse(responseEntry));
                return;
            }

            future.completed(resp);
        }

    };

    this.backend.execute(target, conditionalRequest, clientContext, chainedFutureCallback);
}

---

From source file:org.apache.http.impl.client.cache.CachingHttpAsyncClient.java

private void revalidateCacheEntryCompleted(final BasicFuture<HttpResponse> future, final HttpHost target,
        final HttpRequestWrapper request, final HttpCacheContext clientContext, final HttpCacheEntry cacheEntry,
        final HttpRequestWrapper conditionalRequest, final Date requestDate, final HttpResponse httpResponse,
        final Date responseDate) {

    httpResponse.addHeader(HeaderConstants.VIA, generateViaHeader(httpResponse));

    final int statusCode = httpResponse.getStatusLine().getStatusCode();
    if (statusCode == HttpStatus.SC_NOT_MODIFIED || statusCode == HttpStatus.SC_OK) {
        recordCacheUpdate(clientContext);
    }//w  w w .  j a v  a  2  s. c  om

    if (statusCode == HttpStatus.SC_NOT_MODIFIED) {
        final HttpCacheEntry updatedEntry;
        try {
            updatedEntry = CachingHttpAsyncClient.this.responseCache.updateCacheEntry(target, request,
                    cacheEntry, httpResponse, requestDate, responseDate);
        } catch (final IOException e) {
            future.failed(e);
            return;
        }
        if (CachingHttpAsyncClient.this.suitabilityChecker.isConditional(request)
                && CachingHttpAsyncClient.this.suitabilityChecker.allConditionalsMatch(request, updatedEntry,
                        new Date())) {
            future.completed(
                    CachingHttpAsyncClient.this.responseGenerator.generateNotModifiedResponse(updatedEntry));
            return;
        }
        future.completed(CachingHttpAsyncClient.this.responseGenerator.generateResponse(request, updatedEntry));
        return;
    }

    if (staleIfErrorAppliesTo(statusCode) && !staleResponseNotAllowed(request, cacheEntry, getCurrentDate())
            && CachingHttpAsyncClient.this.validityPolicy.mayReturnStaleIfError(request, cacheEntry,
                    responseDate)) {
        final HttpResponse cachedResponse = CachingHttpAsyncClient.this.responseGenerator
                .generateResponse(request, cacheEntry);
        cachedResponse.addHeader(HeaderConstants.WARNING, "110 localhost \"Response is stale\"");
        future.completed(cachedResponse);
        return;
    }

    try {
        final CloseableHttpResponse backendResponse = handleBackendResponse(target, conditionalRequest,
                requestDate, responseDate, Proxies.enhanceResponse(httpResponse));
        future.completed(backendResponse);
    } catch (final IOException e) {
        future.failed(e);
    }
}

---