Example usage for org.apache.http.impl.client.cache Variant getEntry

Introduction

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

Prototype

public HttpCacheEntry getEntry() 

Source Link

Usage

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

public void reuseVariantEntryFor(HttpHost target, final HttpRequest req, final Variant variant)
        throws IOException {
    final String parentCacheKey = uriExtractor.getURI(target, req);
    final HttpCacheEntry entry = variant.getEntry();
    final String variantKey = uriExtractor.getVariantKey(req, entry);
    final String variantCacheKey = variant.getCacheKey();

    HttpCacheUpdateCallback callback = new HttpCacheUpdateCallback() {
        public HttpCacheEntry update(HttpCacheEntry existing) throws IOException {
            return doGetUpdatedParentEntry(req.getRequestLine().getUri(), existing, entry, variantKey,
                    variantCacheKey);/*from  ww w. j a v a 2  s  . c  o m*/
        }
    };

    try {
        storage.updateEntry(parentCacheKey, callback);
    } catch (HttpCacheUpdateException e) {
        log.warn("Could not update key [" + parentCacheKey + "]", e);
    }
}

---

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

CloseableHttpResponse negotiateResponseFromVariants(final HttpRoute route, final HttpRequestWrapper request,
        final HttpClientContext context, final HttpExecutionAware execAware,
        final Map<String, Variant> variants) throws IOException, HttpException {
    final HttpRequestWrapper conditionalRequest = conditionalRequestBuilder
            .buildConditionalRequestFromVariants(request, variants);

    final Date requestDate = getCurrentDate();
    final CloseableHttpResponse backendResponse = backend.execute(route, conditionalRequest, context,
            execAware);//from  ww  w.  j a  v a 2s  .  co m
    try {
        final Date responseDate = getCurrentDate();

        backendResponse.addHeader("Via", generateViaHeader(backendResponse));

        if (backendResponse.getStatusLine().getStatusCode() != HttpStatus.SC_NOT_MODIFIED) {
            return handleBackendResponse(route, request, context, execAware, requestDate, responseDate,
                    backendResponse);
        }

        final Header resultEtagHeader = backendResponse.getFirstHeader(HeaderConstants.ETAG);
        if (resultEtagHeader == null) {
            log.warn("304 response did not contain ETag");
            IOUtils.consume(backendResponse.getEntity());
            backendResponse.close();
            return callBackend(route, request, context, execAware);
        }

        final String resultEtag = resultEtagHeader.getValue();
        final Variant matchingVariant = variants.get(resultEtag);
        if (matchingVariant == null) {
            log.debug("304 response did not contain ETag matching one sent in If-None-Match");
            IOUtils.consume(backendResponse.getEntity());
            backendResponse.close();
            return callBackend(route, request, context, execAware);
        }

        final HttpCacheEntry matchedEntry = matchingVariant.getEntry();

        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, backendResponse, matchingVariant, matchedEntry);
        backendResponse.close();

        final CloseableHttpResponse resp = responseGenerator.generateResponse(responseEntry);
        tryToUpdateVariantMap(context.getTargetHost(), request, matchingVariant);

        if (shouldSendNotModifiedResponse(request, responseEntry)) {
            return responseGenerator.generateNotModifiedResponse(responseEntry);
        }
        return resp;
    } catch (final IOException ex) {
        backendResponse.close();
        throw ex;
    } catch (final RuntimeException ex) {
        backendResponse.close();
        throw ex;
    }
}

---

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  a v a  2  s.c om*/

        @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.CachingHttpClient.java

HttpResponse negotiateResponseFromVariants(HttpHost target, HttpRequest request, HttpContext context,
        Map<String, Variant> variants) throws IOException {
    HttpRequest conditionalRequest = conditionalRequestBuilder.buildConditionalRequestFromVariants(request,
            variants);//from  w  w w.j a  v a2  s  .c  o  m

    Date requestDate = getCurrentDate();
    HttpResponse backendResponse = backend.execute(target, conditionalRequest, context);
    Date responseDate = getCurrentDate();

    backendResponse.addHeader("Via", generateViaHeader(backendResponse));

    if (backendResponse.getStatusLine().getStatusCode() != HttpStatus.SC_NOT_MODIFIED) {
        return handleBackendResponse(target, request, requestDate, responseDate, backendResponse);
    }

    Header resultEtagHeader = backendResponse.getFirstHeader(HeaderConstants.ETAG);
    if (resultEtagHeader == null) {
        log.warn("304 response did not contain ETag");
        return callBackend(target, request, context);
    }

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

    HttpCacheEntry matchedEntry = matchingVariant.getEntry();

    if (revalidationResponseIsTooOld(backendResponse, matchedEntry)) {
        return retryRequestUnconditionally(target, request, context, matchedEntry);
    }

    recordCacheUpdate(context);

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

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

    if (shouldSendNotModifiedResponse(request, responseEntry)) {
        return responseGenerator.generateNotModifiedResponse(responseEntry);
    }

    return resp;
}

---