@Override public void sendAsyncRequestImpl(HttpUriRequest request, Callback<HttpResponse> callback) throws IOException { this.client.execute(request, new FutureCallback<HttpResponse>() { @Override public void completed(HttpResponse result) { callback.onSuccess(result); } @Override public void failed(Exception ex) { callback.onFailure(ex); } @Override public void cancelled() { throw new UnsupportedOperationException(); } }); }
private void checkServerHealth() { long startCheckTime = System.currentTimeMillis(); for (String serverIp : serverList) { // Compatible with old codes,use status.taobao String url = "http://" + serverIp + servletContext.getContextPath() + Constants.HEALTH_CONTROLLER_PATH; // "/nacos/health"; HttpGet request = new HttpGet(url); httpclient.execute(request, new AyscCheckServerHealthCallBack(serverIp)); } long endCheckTime = System.currentTimeMillis(); long cost = endCheckTime - startCheckTime; defaultLog.debug("checkServerHealth cost: {}", cost); }
final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<String> reference = new AtomicReference<>(); httpClient.execute(httpGet, new FutureCallback<HttpResponse>() { @Override public void completed(final HttpResponse response) {
@Override protected void get(CloseableHttpAsyncClient client) throws Exception { EntityUtils.consume(client.execute(new HttpGet(baseUrl()), null).get().getEntity()); }
protected <T extends JestResult> Future<HttpResponse> executeAsyncRequest(Action<T> clientRequest, JestResultHandler<? super T> resultHandler, HttpUriRequest request) { if (httpClientContextTemplate != null) { return asyncClient.execute(request, createContextInstance(), new DefaultCallback<T>(clientRequest, request, resultHandler)); } return asyncClient.execute(request, new DefaultCallback<T>(clientRequest, request, resultHandler)); }
httpClient.execute(httpGet, new FutureCallback<HttpResponse>() { @Override public void completed(final HttpResponse response) {
final HttpGet httpGet = new HttpGet(url); httpGet.setHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE); httpclient.execute(httpGet, new FutureCallback<HttpResponse>() { @Override public void completed(final HttpResponse response) {
@Override public <T> Future<T> execute(HttpAsyncRequestProducer requestProducer, HttpAsyncResponseConsumer<T> responseConsumer, HttpContext context, FutureCallback<T> callback) { context.setAttribute(TraceContext.class.getName(), currentTraceContext.get()); return delegate.execute( new TracingAsyncRequestProducer(requestProducer, context), new TracingAsyncResponseConsumer<>(responseConsumer, context), context, callback ); }
@Override public HttpResponse sendRequestImpl(HttpUriRequest request) throws IOException { SyncHttpResponseCallback callback = new SyncHttpResponseCallback(request); this.client.execute(request, callback); try { callback.await(); if (callback.getException() != null) { throw new IOException(callback.getException()); } return callback.getResponse(); } catch (InterruptedException e) { throw new IOException(e); } }
request.setHeader("isBeta", "true"); httpclient.execute(request, new AyscNotifyCallBack(httpclient, task));
final CloseableHttpAsyncClient asyncClient = getHttpAsyncClient(); final HttpGet get = createGetControllerRequest(); final Future<HttpResponse> getResult = asyncClient.execute(get, null); try { final HttpResponse getResponse = getResult.get(readTimeoutMillis, TimeUnit.MILLISECONDS); final Future<HttpResponse> responseFuture = getHttpAsyncClient().execute(asyncRequestProducer, new BasicAsyncResponseConsumer(), null); final HttpResponse response; try {
postResult = getHttpAsyncClient().execute(asyncRequestProducer, new BasicAsyncResponseConsumer(), null);
static Future<HttpResp> request(HttpReq config, CloseableHttpAsyncClient client, Callback<HttpResp> callback, boolean close) { HttpRequestBase req = createRequest(config); if (Log.isDebugEnabled()) Log.debug("Starting HTTP request", "request", req.getRequestLine()); Promise<HttpResp> promise = Promises.create(); FutureCallback<HttpResponse> cb = callback(client, callback, promise, close); client.execute(req, cb); return promise; }
public static <T> Future<HttpResponse<T>> requestAsync(HttpRequest request, final Class<T> responseClass, Callback<T> callback) { HttpUriRequest requestObj = prepareRequest(request, true); CloseableHttpAsyncClient asyncHttpClient = ClientFactory.getAsyncHttpClient(); if (!asyncHttpClient.isRunning()) { asyncHttpClient.start(); AsyncIdleConnectionMonitorThread asyncIdleConnectionMonitorThread = (AsyncIdleConnectionMonitorThread) Options.getOption(Option.ASYNC_MONITOR); asyncIdleConnectionMonitorThread.start(); } final Future<org.apache.http.HttpResponse> future = asyncHttpClient.execute(requestObj, prepareCallback(responseClass, callback)); return new Future<HttpResponse<T>>() { public boolean cancel(boolean mayInterruptIfRunning) { return future.cancel(mayInterruptIfRunning); } public boolean isCancelled() { return future.isCancelled(); } public boolean isDone() { return future.isDone(); } public HttpResponse<T> get() throws InterruptedException, ExecutionException { org.apache.http.HttpResponse httpResponse = future.get(); return new HttpResponse<T>(httpResponse, responseClass); } public HttpResponse<T> get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { org.apache.http.HttpResponse httpResponse = future.get(timeout, unit); return new HttpResponse<T>(httpResponse, responseClass); } }; }
FutureCallback<T> httpCallback = callback != null ? new CallbackAdapter<T>(callback) : null; return client.execute(requestProducer, responseConsumer, httpCallback); StreamingResponseConsumer<T> responseConsumer = new StreamingResponseConsumer<T>(request, extractor); Future<T> httpFuture = client.execute(requestProducer, responseConsumer, null); return responseConsumer.future(httpFuture);
@Override public <T> Future<T> execute(HttpAsyncRequestProducer requestProducer, HttpAsyncResponseConsumer<T> responseConsumer, HttpContext context, FutureCallback<T> callback) { return delegate.execute(requestProducer, responseConsumer, context, callback); }
protected <T extends JestResult> Future<HttpResponse> executeAsyncRequest(Action<T> clientRequest, JestResultHandler<? super T> resultHandler, HttpUriRequest request) { if (httpClientContextTemplate != null) { return asyncClient.execute(request, createContextInstance(), new DefaultCallback<T>(clientRequest, request, resultHandler)); } return asyncClient.execute(request, new DefaultCallback<T>(clientRequest, request, resultHandler)); }
@Override protected CompletionStage<HttpResponse> executeDelegate(final HttpRequest httpRequest) throws Throwable { final HttpUriRequest realHttpRequest = toApacheRequest(httpRequest); final CompletableFuture<org.apache.http.HttpResponse> apacheResponseFuture = new CompletableFuture<>(); apacheHttpClient.execute(realHttpRequest, new CompletableFutureCallbackAdapter<>(apacheResponseFuture)); return apacheResponseFuture.thenApply(apacheResponse -> convertApacheToSphereResponse(apacheResponse, httpRequest)); }
@Override public <T> Future<T> execute(HttpAsyncRequestProducer requestProducer, HttpAsyncResponseConsumer<T> responseConsumer, HttpContext context, FutureCallback<T> callback) { context.setAttribute(TraceContext.class.getName(), currentTraceContext.get()); return delegate.execute( new TracingAsyncRequestProducer(requestProducer, context), new TracingAsyncResponseConsumer<>(responseConsumer, context), context, callback ); }
@Override public Future<HttpResponse> execute(HttpHost target, HttpRequest request, HttpContext context, FutureCallback<HttpResponse> callback) { BoundedAsyncResponseConsumer consumer = new BoundedAsyncResponseConsumer(Ints.saturatedCast(maxEntitySize)); return delegate.execute( HttpAsyncMethods.create(target, request), consumer, context, callback); }