Example usage for org.apache.http.concurrent BasicFuture failed

Introduction

In this page you can find the example usage for org.apache.http.concurrent BasicFuture failed.

Prototype

public boolean failed(Exception exception) 

Source Link

Usage

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

@Override
public Future<HttpResponse> execute(final HttpHost target, final HttpRequest originalRequest,
        final HttpContext context, final FutureCallback<HttpResponse> futureCallback) {
    final BasicFuture<HttpResponse> future = new BasicFuture<HttpResponse>(futureCallback);
    final HttpRequestWrapper request = HttpRequestWrapper.wrap(originalRequest);
    final HttpCacheContext clientContext = HttpCacheContext.adapt(context);
    // default response context
    setResponseStatus(clientContext, CacheResponseStatus.CACHE_MISS);

    final String via = generateViaHeader(request);

    if (clientRequestsOurOptions(request)) {
        setResponseStatus(clientContext, CacheResponseStatus.CACHE_MODULE_RESPONSE);
        future.completed(new OptionsHttp11Response());
        return future;
    }/*from  w  ww.j a  v  a  2 s  .c  o m*/

    final HttpResponse fatalErrorResponse = getFatallyNoncompliantResponse(request, clientContext);
    if (fatalErrorResponse != null) {
        future.completed(fatalErrorResponse);
        return future;
    }

    try {
        this.requestCompliance.makeRequestCompliant(request);
    } catch (final ClientProtocolException e) {
        future.failed(e);
        return future;
    }
    request.addHeader(HeaderConstants.VIA, via);

    flushEntriesInvalidatedByRequest(target, request);

    if (!this.cacheableRequestPolicy.isServableFromCache(request)) {
        log.debug("Request is not servable from cache");
        callBackend(future, target, request, clientContext);
        return future;
    }

    final HttpCacheEntry entry = satisfyFromCache(target, request);
    if (entry == null) {
        log.debug("Cache miss");
        handleCacheMiss(future, target, request, clientContext);
    } else {
        try {
            handleCacheHit(future, target, request, clientContext, entry);
        } catch (final IOException e) {
            future.failed(e);
        }
    }
    return future;
}

---

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 www  .  j  av  a  2 s.  com

        @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. ja  v a2 s.  c o  m*/

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

---

From source file:org.apache.http.impl.nio.client.AbstractHttpAsyncClient.java

@Override
public Future<HttpResponse> execute(final HttpUriRequest request, final HttpContext context,
        final FutureCallback<HttpResponse> callback) {
    HttpHost target;/*  w  w w . ja va2  s.  co  m*/
    try {
        target = determineTarget(request);
    } catch (final ClientProtocolException ex) {
        final BasicFuture<HttpResponse> future = new BasicFuture<HttpResponse>(callback);
        future.failed(ex);
        return future;
    }
    return execute(target, request, context, callback);
}

---

From source file:org.apache.http.impl.nio.conn.PoolingNHttpClientConnectionManager.java

@Override
public Future<NHttpClientConnection> requestConnection(final HttpRoute route, final Object state,
        final long connectTimeout, final long leaseTimeout, final TimeUnit tunit,
        final FutureCallback<NHttpClientConnection> callback) {
    Args.notNull(route, "HTTP route");
    if (this.log.isDebugEnabled()) {
        this.log.debug("Connection request: " + format(route, state) + formatStats(route));
    }/*  ww  w.j a va  2  s . c  o  m*/
    final BasicFuture<NHttpClientConnection> future = new BasicFuture<NHttpClientConnection>(callback);
    final HttpHost host;
    if (route.getProxyHost() != null) {
        host = route.getProxyHost();
    } else {
        host = route.getTargetHost();
    }
    final SchemeIOSessionStrategy sf = this.iosessionFactoryRegistry.lookup(host.getSchemeName());
    if (sf == null) {
        future.failed(new UnsupportedSchemeException(host.getSchemeName() + " protocol is not supported"));
        return future;
    }
    this.pool.lease(route, state, connectTimeout, leaseTimeout, tunit != null ? tunit : TimeUnit.MILLISECONDS,
            new InternalPoolEntryCallback(future));
    return future;
}

---