Example usage for org.apache.http.impl.client.cache ChainedFutureCallback ChainedFutureCallback

Introduction

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

Prototype

public ChainedFutureCallback(final BasicFuture<T> delegate) 

Source Link

Usage

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

private void revalidateCacheEntry(final BasicFuture<HttpResponse> future, final HttpHost target,
        final HttpRequestWrapper request, final HttpCacheContext clientContext, final HttpCacheEntry entry,
        final Date now) throws ClientProtocolException {

    try {/*from  w  w  w  .j  a v a 2  s .  com*/
        if (this.asynchAsyncRevalidator != null && !staleResponseNotAllowed(request, entry, now)
                && this.validityPolicy.mayReturnStaleWhileRevalidating(entry, now)) {
            this.log.debug("Serving stale with asynchronous revalidation");
            final HttpResponse resp = this.responseGenerator.generateResponse(request, entry);
            resp.addHeader(HeaderConstants.WARNING, "110 localhost \"Response is stale\"");

            this.asynchAsyncRevalidator.revalidateCacheEntry(target, request, clientContext, entry);

            future.completed(resp);
            return;
        }

        final ChainedFutureCallback<HttpResponse> chainedFutureCallback = new ChainedFutureCallback<HttpResponse>(
                future) {

            @Override
            public void failed(final Exception ex) {
                if (ex instanceof IOException) {
                    super.completed(handleRevalidationFailure(request, clientContext, entry, now));
                } else {
                    super.failed(ex);
                }
            }

        };

        final BasicFuture<HttpResponse> compositeFuture = new BasicFuture<HttpResponse>(chainedFutureCallback);
        revalidateCacheEntry(compositeFuture, target, request, clientContext, entry);
    } catch (final ProtocolException e) {
        throw new ClientProtocolException(e);
    }
}

---

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) {/*from w w  w . ja v a  2 s.  co  m*/

        @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) {//  w  ww  .  j a va  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

void revalidateCacheEntry(final BasicFuture<HttpResponse> future, final HttpHost target,
        final HttpRequestWrapper request, final HttpCacheContext clientContext, final HttpCacheEntry cacheEntry)
        throws ProtocolException {

    final HttpRequestWrapper conditionalRequest = this.conditionalRequestBuilder
            .buildConditionalRequest(request, cacheEntry);
    final Date requestDate = getCurrentDate();

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

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

            if (revalidationResponseIsTooOld(httpResponse, cacheEntry)) {
                final HttpRequest unconditional = CachingHttpAsyncClient.this.conditionalRequestBuilder
                        .buildUnconditionalRequest(request, cacheEntry);
                final Date innerRequestDate = getCurrentDate();

                final ChainedFutureCallback<HttpResponse> chainedFutureCallback2 = new ChainedFutureCallback<HttpResponse>(
                        future) {

                    @Override
                    public void completed(final HttpResponse innerHttpResponse) {
                        final Date innerResponseDate = getCurrentDate();
                        revalidateCacheEntryCompleted(future, target, request, clientContext, cacheEntry,
                                conditionalRequest, innerRequestDate, innerHttpResponse, innerResponseDate);
                    }

                };
                CachingHttpAsyncClient.this.backend.execute(target, unconditional, clientContext,
                        chainedFutureCallback2);
            }

            revalidateCacheEntryCompleted(future, target, request, clientContext, cacheEntry,
                    conditionalRequest, requestDate, httpResponse, responseDate);
        }

    };

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

---