grizzlyClient.executeRequest(connectorRequest, new AsyncHandler<Void>() { private volatile HttpResponseStatus status = null;
return grizzlyClient.executeRequest(connectorRequest, new AsyncHandler<Void>() { private volatile HttpResponseStatus status = null;
/** * Execute an HTTP request. * * @param request {@link Request} * @return a {@link Future} of type Response */ public ListenableFuture<Response> executeRequest(Request request) { return executeRequest(request, new AsyncCompletionHandlerBase()); }
public <T> ListenableFuture<T> execute(AsyncHandler<T> handler) { return AsyncHttpClient.this.executeRequest(build(), handler); }
public ListenableFuture<Response> execute() { return AsyncHttpClient.this.executeRequest(build(), new AsyncCompletionHandlerBase()); }
public static void main(String[] args) { SecureRandom secureRandom = new SecureRandom(); SSLContext sslContext = null; try { sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, null, secureRandom); } catch (Exception e) { e.printStackTrace(); } AsyncHttpClientConfig config = new AsyncHttpClientConfig.Builder() .setConnectTimeout(5000) .setSSLContext(sslContext).build(); AsyncHttpClient client = new AsyncHttpClient(new GrizzlyAsyncHttpProvider(config), config); long start = System.currentTimeMillis(); try { client.executeRequest(client.prepareGet("http://www.google.com").build()).get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } LOGGER.debug("COMPLETE: " + (System.currentTimeMillis() - start) + "ms"); } }
try { LOG.trace("Sending request to leader: {}", httpRequest); response = httpClient.executeRequest(httpRequest).get(); } catch (IOException|ExecutionException|InterruptedException e) { LOG.error("Could not proxy request {} to leader", e);
private LoadBalancerUpdateHolder sendRequest(LoadBalancerRequestId loadBalancerRequestId, Request request, BaragonRequestState onFailure) { try { LOG.trace("Sending LB {} request for {} to {}", request.getMethod(), loadBalancerRequestId, request.getUrl()); ListenableFuture<Response> future = httpClient.executeRequest(request); Response response = future.get(loadBalancerTimeoutMillis, TimeUnit.MILLISECONDS); LOG.trace("LB {} request {} returned with code {}", request.getMethod(), loadBalancerRequestId, response.getStatusCode()); if (response.getStatusCode() == 504) { return new LoadBalancerUpdateHolder(BaragonRequestState.UNKNOWN, Optional.of(String.format("LB %s request %s timed out", request.getMethod(), loadBalancerRequestId))); } else if (!JavaUtils.isHttpSuccess(response.getStatusCode())) { return new LoadBalancerUpdateHolder(onFailure, Optional.of(String.format("Response status code %s", response.getStatusCode()))); } BaragonResponse lbResponse = readResponse(response); return new LoadBalancerUpdateHolder(lbResponse.getLoadBalancerState(), lbResponse.getMessage()); } catch (TimeoutException te) { LOG.trace("LB {} request {} timed out after waiting {}", request.getMethod(), loadBalancerRequestId, JavaUtils.durationFromMillis(loadBalancerTimeoutMillis)); return new LoadBalancerUpdateHolder(BaragonRequestState.UNKNOWN, Optional.of(String.format("Timed out after %s", JavaUtils.durationFromMillis(loadBalancerTimeoutMillis)))); } catch (Throwable t) { LOG.error("LB {} request {} to {} threw error", request.getMethod(), loadBalancerRequestId, request.getUrl(), t); return new LoadBalancerUpdateHolder(BaragonRequestState.UNKNOWN, Optional.of(String.format("Exception %s - %s", t.getClass().getSimpleName(), t.getMessage()))); } }
private void downloadFilesFromLocalDownloadService(List<? extends S3Artifact> s3Artifacts, SingularityExecutorTask task) throws InterruptedException { final List<FutureHolder> futures = Lists.newArrayListWithCapacity(s3Artifacts.size()); for (S3Artifact s3Artifact : s3Artifacts) { String destination = task.getArtifactPath(s3Artifact, task.getTaskDefinition().getTaskDirectoryPath()).toString(); ArtifactDownloadRequest artifactDownloadRequest = new ArtifactDownloadRequest(destination, s3Artifact, Optional.of(SingularityExecutorArtifactFetcher.this.executorConfiguration.getLocalDownloadServiceTimeoutMillis())); task.getLog().debug("Requesting {} from {}", artifactDownloadRequest, localDownloadUri); BoundRequestBuilder postRequestBldr = localDownloadHttpClient.preparePost(localDownloadUri); try { postRequestBldr.setBody(objectMapper.writeValueAsBytes(artifactDownloadRequest)); } catch (JsonProcessingException e) { throw Throwables.propagate(e); } try { ListenableFuture<Response> future = localDownloadHttpClient.executeRequest(postRequestBldr.build()); futures.add(new FutureHolder(future, System.currentTimeMillis(), s3Artifact)); } catch (IOException ioe) { throw Throwables.propagate(ioe); } } for (FutureHolder future : futures) { Response response = future.getReponse(); task.getLog().debug("Future for {} got status code {} after {}", future.s3Artifact.getName(), response.getStatusCode(), JavaUtils.duration(future.start)); if (response.getStatusCode() != 200) { throw new IllegalStateException("Got status code:" + response.getStatusCode()); } } }
private Future<Response> execute(RequestBuilder rb, BodyConsumer bodyConsumer, ThrowableHandler throwableHandler) throws IOException { if (throwableHandler == null) { throwableHandler = defaultThrowableHandler; } Request request = rb.build(); ProgressAsyncHandler<Response> handler = new BodyConsumerAsyncHandler(bodyConsumer, throwableHandler, errorDocumentBehaviour, request.getUri(), listener); if (resumeEnabled && request.getMethod().equals("GET") && bodyConsumer != null && bodyConsumer instanceof ResumableBodyConsumer) { ResumableBodyConsumer fileBodyConsumer = (ResumableBodyConsumer) bodyConsumer; long length = fileBodyConsumer.getTransferredBytes(); fileBodyConsumer.resume(); handler = new ResumableBodyConsumerAsyncHandler(length, handler); } return asyncHttpClient().executeRequest(request, handler); }
/** * Execute an HTTP request. * * @param request {@link Request} * @return a {@link Future} of type Response */ public ListenableFuture<Response> executeRequest(Request request) { return executeRequest(request, new AsyncCompletionHandlerBase()); }
private Future<Response> execute() { Future<Response> future = null; AsyncEntityHandler handler = new AsyncEntityHandler(); handler.setBodyReaders(bodyReaders); try { future = client.executeRequest(request, handler); } catch (IOException ex) { future.cancel(true); } return future; } }
@Override protected CompletionStage<HttpResponse> executeDelegate(final HttpRequest httpRequest) { final Request request = asAhcRequest(httpRequest); try { final CompletionStage<Response> future = wrap(asyncHttpClient.executeRequest(request)); return future.thenApplyAsync(response -> convert(httpRequest, response), threadPool()); } catch (final IOException e) { final CompletableFuture<HttpResponse> future = new CompletableFuture<>(); future.completeExceptionally(new HttpException(e)); return future; } }
private SimpleResponse executeSimpleRequest(Request request) throws IOException, InterruptedException, ExecutionException, TimeoutException { ListenableFuture<SimpleResponse> fResponse = this.client.executeRequest(request, SIMPLE_RESPONSE_HANDLER); return getRequestTimeout() >= 0L ? fResponse.get(getRequestTimeout(), TimeUnit.MILLISECONDS) : fResponse.get(); }
private ListResponse executeListRequest(Request request) throws IOException, InterruptedException, ExecutionException, TimeoutException { ListenableFuture<ListResponse> fResponse = this.client.executeRequest(request, LIST_RESPONSE_HANDLER); return getRequestTimeout() >= 0L ? fResponse.get(getRequestTimeout(), TimeUnit.MILLISECONDS) : fResponse.get(); }
public ListenableRequestBuilder execute( final CompletionListener<Response> listener ) throws IOException { val handler = new AsyncCompletionHandlerBase( requests, listener ); val responseWrapper = new ResponseHolderAsyncHandlerWrapper<Response>( handler, requests.storedContext() ); requests.client().executeRequest( build(), responseWrapper ); return this; }
private DownloadResponse executeDownloadRequest(Request request, File outputFile) throws IOException, InterruptedException, ExecutionException, TimeoutException { ListenableFuture<DownloadResponse> fResponse = this.client.executeRequest(request, new DownloadResponseHandler(outputFile)); return getRequestTimeout() >= 0L ? fResponse.get(getRequestTimeout(), TimeUnit.MILLISECONDS) : fResponse.get(); }
void reconnect() { Map<String, List<String>> c = request.queryString(); FluentStringsMap f = new FluentStringsMap(); f.putAll(c); options.runtime().executeRequest(requestBuilder.setQueryParams(f).build(), StreamTransport.this); }
void reconnect() { Map<String, List<String>> c = request.queryString(); FluentStringsMap f = new FluentStringsMap(); f.putAll(c); options.runtime().executeRequest(requestBuilder.setQueryParams(f).build(), StreamTransport.this); }
@Test public void ntlmProxyTest() throws IOException, InterruptedException, ExecutionException { AsyncHttpClientConfig config = new AsyncHttpClientConfig.Builder().build(); try (AsyncHttpClient client = getAsyncHttpClient(config)) { Request request = new RequestBuilder("GET").setProxyServer(ntlmProxy()).setUrl(getTargetUrl()).build(); Future<Response> responseFuture = client.executeRequest(request); int status = responseFuture.get().getStatusCode(); Assert.assertEquals(status, 200); } }