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

List of usage examples for org.apache.http.concurrent BasicFuture BasicFuture

Introduction

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

Prototype

public BasicFuture(FutureCallback<T> futureCallback) 

Source Link

Usage

From source file:com.ok2c.lightmtp.impl.protocol.cmd.AbstractAction.java

@Override
public Future<SMTPReply> execute(final T state, final FutureCallback<SMTPReply> callback) {
    synchronized (state) {
        BasicFuture<SMTPReply> future = new BasicFuture<SMTPReply>(callback);
        future.completed(internalExecute(state));
        return future;
    }/* w ww .java  2 s  . co m*/
}

From source file:com.ok2c.lightmtp.impl.protocol.cmd.SimpleAction.java

@Override
public Future<SMTPReply> execute(final ServerState state, final FutureCallback<SMTPReply> callback) {
    BasicFuture<SMTPReply> future = new BasicFuture<SMTPReply>(callback);
    future.completed(this.reply);
    return future;
}

From source file:com.ok2c.lightmtp.impl.protocol.cmd.AbstractAsyncAction.java

@Override
public Future<SMTPReply> execute(final T state, final FutureCallback<SMTPReply> callback) {
    synchronized (state) {
        SMTPReply reply = internalValidateState(state);
        if (reply != null) {
            BasicFuture<SMTPReply> future = new BasicFuture<SMTPReply>(callback);
            future.completed(reply);//w ww.jav a 2 s.  com
            return future;
        } else {
            return internalAsyncExecute(state, new InternalCallback(state, callback));
        }
    }
}

From source file:com.kurento.kmf.jsonrpcconnector.internal.ws.PendingRequests.java

public Future<Response<JsonElement>> prepareResponse(Integer id) {

    Preconditions.checkNotNull(id, "The request id cannot be null");

    BasicFuture<Response<JsonElement>> responseFuture = new BasicFuture<>(null);

    if (pendingRequests.putIfAbsent(id, responseFuture) != null) {
        throw new JsonRpcConnectorException("Can not send a request with the id '" + id
                + "'. There is already a pending request with this id");
    }/*from w  ww . j  a v  a 2  s.  com*/

    return responseFuture;
}

From source file:org.kurento.jsonrpc.internal.ws.PendingRequests.java

public Future<Response<JsonElement>> prepareResponse(Integer id) {

    Preconditions.checkNotNull(id, "The request id cannot be null");

    BasicFuture<Response<JsonElement>> responseFuture = new BasicFuture<>(null);

    if (pendingRequests.putIfAbsent(id, responseFuture) != null) {
        throw new JsonRpcException("Can not send a request with the id '" + id
                + "'. There is already a pending request with this id");
    }//from  w  w w  . ja  v  a  2s. c o m

    return responseFuture;
}

From source file:com.ok2c.lightmtp.impl.pool.MailIOSessionManager.java

public Future<LeasedSession> leaseSession(final SessionEndpoint endpoint, final long connectTimeout,
        final TimeUnit tunit, final FutureCallback<LeasedSession> callback) {
    Args.notNull(endpoint, "Session endpoint");
    if (this.log.isDebugEnabled()) {
        this.log.debug("Session request: " + format(endpoint, null) + formatStats(endpoint));
    }//from  w w w.j  a  va  2s.  co  m
    final BasicFuture<LeasedSession> future = new BasicFuture<LeasedSession>(callback);
    this.pool.lease(endpoint, null, connectTimeout, tunit != null ? tunit : TimeUnit.MILLISECONDS,
            new InternalPoolEntryCallback(future));
    return future;
}

From source file:org.apache.nutch.indexwriter.elasticrest.ElasticRestIndexWriter.java

@Override
public void commit() throws IOException {
    if (basicFuture != null) {
        // wait for previous to finish
        long beforeWait = System.currentTimeMillis();
        try {/*from   w ww .  j  av  a 2s . c om*/
            JestResult result = basicFuture.get();
            if (result == null) {
                throw new RuntimeException();
            }
            long msWaited = System.currentTimeMillis() - beforeWait;
            LOG.info("Previous took in ms {}, including wait {}", millis, msWaited);
        } catch (InterruptedException | ExecutionException e) {
            LOG.error("Error waiting for result ", e);
        }
        basicFuture = null;
    }
    if (bulkBuilder != null) {
        if (bulkDocs > 0) {
            // start a flush, note that this is an asynchronous call
            basicFuture = new BasicFuture<>(null);
            millis = System.currentTimeMillis();
            client.executeAsync(bulkBuilder.build(), new JestResultHandler<BulkResult>() {
                @Override
                public void completed(BulkResult bulkResult) {
                    basicFuture.completed(bulkResult);
                    millis = System.currentTimeMillis() - millis;
                }

                @Override
                public void failed(Exception e) {
                    basicFuture.completed(null);
                    LOG.error("Failed result: ", e);
                }
            });
        }
        bulkBuilder = null;
    }
    if (createNewBulk) {
        // Prepare a new bulk request
        bulkBuilder = new Bulk.Builder().defaultIndex(defaultIndex).defaultType(defaultType);
        bulkDocs = 0;
        bulkLength = 0;
    }
}

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

@Override
public void run() {
    try {//from   w  w w  . j a  v  a  2  s . com
        final FutureCallback<HttpResponse> callback = new FutureCallback<HttpResponse>() {

            @Override
            public void cancelled() {
            }

            @Override
            public void completed(final HttpResponse httpResponse) {
            }

            @Override
            public void failed(final Exception e) {
                log.debug("Asynchronous revalidation failed", e);
            }
        };
        final BasicFuture<HttpResponse> future = new BasicFuture<HttpResponse>(callback);
        this.cachingAsyncClient.revalidateCacheEntry(future, this.target, this.request, this.clientContext,
                this.cacheEntry);
        future.get();
    } catch (final ProtocolException pe) {
        this.log.error("ProtocolException thrown during asynchronous revalidation", pe);
    } catch (final ExecutionException e) {
        this.log.error("Exception thrown during asynchronous revalidation", e.getCause());
    } catch (final InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        this.parent.markComplete(this.identifier);
    }
}

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;
    }//  w  w  w.j  ava  2s.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;
}