public static void asyncHttpPost(String url, List<String> headers, Map<String, String> paramValues, AsyncCompletionHandler handler) throws Exception { AsyncHttpClient.BoundRequestBuilder builder = asyncHttpClient.preparePost(url); if (!CollectionUtils.isEmpty(headers)) { for (String header : headers) { builder.setHeader(header.split("=")[0], header.split("=")[1]); } } if (!MapUtils.isEmpty(paramValues)) { FluentStringsMap params = new FluentStringsMap(); for (Map.Entry<String, String> entry : paramValues.entrySet()) { params.put(entry.getKey(), Collections.singletonList(entry.getValue())); } builder.setParameters(params); } builder.setHeader("Accept-Charset", "UTF-8"); if (handler != null) { builder.execute(handler); } else { builder.execute(); } }
@Override public Future<BrokerResponse> executeQueryAsync(String brokerAddress, final String query) { try { ObjectNode json = JsonNodeFactory.instance.objectNode(); json.put("pql", query); final String url = "http://" + brokerAddress + "/query"; final Future<Response> response = _httpClient.preparePost(url).setBody(json.toString()).execute(); return new BrokerResponseFuture(response, query, url); } catch (Exception e) { throw new PinotClientException(e); } }
public static void asyncHttpPostLarge(String url, List<String> headers, String content, AsyncCompletionHandler handler) throws Exception { AsyncHttpClient.BoundRequestBuilder builder = asyncHttpClient.preparePost(url); if (!CollectionUtils.isEmpty(headers)) { for (String header : headers) { builder.setHeader(header.split("=")[0], header.split("=")[1]); } } builder.setBody(content.getBytes("UTF-8")); builder.setHeader("Content-Type", "application/json; charset=UTF-8"); builder.setHeader("Accept-Charset", "UTF-8"); builder.setHeader("Accept-Encoding", "gzip"); builder.setHeader("Content-Encoding", "gzip"); if (handler != null) { builder.execute(handler); } else { builder.execute(); } }
/** Execute a DELETE request. */ @Override public HttpResponse delete() { this.type = "DELETE"; try { return new HttpAsyncResponse(prepare(prepareDelete()).execute().get()); } catch (Exception e) { throw new RuntimeException(e); } }
ListenableFuture<Response> future = requestBuilder.execute();
responseFuture = request.execute(new HttpAsyncHandler( this)); timeoutDuration = Duration.create(
final Response response = builder.execute().get();
public Collection<MesosFileObject> browse(String slaveHostname, String fullPath) throws SlaveNotFoundException { try { PerRequestConfig timeoutConfig = new PerRequestConfig(); timeoutConfig.setRequestTimeoutInMs((int) configuration.getSandboxHttpTimeoutMillis()); Response response = asyncHttpClient .prepareGet(String.format("http://%s:5051/files/browse", slaveHostname)) .setPerRequestConfig(timeoutConfig) .addQueryParameter("path", fullPath) .execute() .get(); if (response.getStatusCode() == 404) { return Collections.emptyList(); } if (response.getStatusCode() != 200) { throw new RuntimeException(String.format("Got HTTP %s from Mesos slave", response.getStatusCode())); } return objectMapper.readValue(response.getResponseBodyAsStream(), MESOS_FILE_OBJECTS); } catch (ConnectException ce) { throw new SlaveNotFoundException(ce); } catch (Exception e) { if (e.getCause().getClass() == ConnectException.class) { throw new SlaveNotFoundException(e); } else { throw Throwables.propagate(e); } } }
private SingularityUserPermissionsResponse verifyUncached(String authHeaderValue) { try { Response response = asyncHttpClient.prepareGet(webhookAuthConfiguration.getAuthVerificationUrl()) .addHeader("Authorization", authHeaderValue) .execute() .get(); if (response.getStatusCode() > 299) { throw WebExceptions.unauthorized(String.format("Got status code %d when verifying jwt", response.getStatusCode())); } else { String responseBody = response.getResponseBody(); SingularityUserPermissionsResponse permissionsResponse = objectMapper.readValue(responseBody, SingularityUserPermissionsResponse.class); if (!permissionsResponse.getUser().isPresent()) { throw WebExceptions.unauthorized(String.format("No user present in response %s", permissionsResponse)); } if (!permissionsResponse.getUser().get().isAuthenticated()) { throw WebExceptions.unauthorized(String.format("User not authenticated (response: %s)", permissionsResponse)); } permissionsCache.put(authHeaderValue, permissionsResponse); return permissionsResponse; } } catch (Throwable t) { throw new RuntimeException(t); } } }
private void asyncHealthcheck(final SingularityTask task) { final SingularityHealthcheckAsyncHandler handler = new SingularityHealthcheckAsyncHandler(exceptionNotifier, configuration, this, newTaskChecker, taskManager, task); final Optional<String> uri = getHealthcheckUri(task); if (!uri.isPresent()) { saveFailure(handler, "Invalid healthcheck uri or ports not present"); return; } final Integer timeoutSeconds = task.getTaskRequest().getDeploy().getHealthcheck().isPresent() ? task.getTaskRequest().getDeploy().getHealthcheck().get().getResponseTimeoutSeconds().or(configuration.getHealthcheckTimeoutSeconds()) : configuration.getHealthcheckTimeoutSeconds(); try { PerRequestConfig prc = new PerRequestConfig(); prc.setRequestTimeoutInMs((int) TimeUnit.SECONDS.toMillis(timeoutSeconds)); RequestBuilder builder = new RequestBuilder("GET"); builder.setFollowRedirects(true); builder.setUrl(uri.get()); builder.setPerRequestConfig(prc); LOG.trace("Issuing a healthcheck ({}) for task {} with timeout {}s", uri.get(), task.getTaskId(), timeoutSeconds); http.prepareRequest(builder.build()).execute(handler); } catch (Throwable t) { LOG.debug("Exception while preparing healthcheck ({}) for task ({})", uri, task.getTaskId(), t); exceptionNotifier.notify(String.format("Error preparing healthcheck (%s)", t.getMessage()), t, ImmutableMap.of("taskId", task.getTaskId().toString())); saveFailure(handler, String.format("Healthcheck failed due to exception: %s", t.getMessage())); } }
private <T> CompletableFuture<Response> executeWebhookAsync(String uri, Object payload, AbstractSingularityWebhookAsyncHandler<T> handler) { LOG.trace("Sending {} to {}", payload, uri); BoundRequestBuilder postRequest = http.preparePost(uri); postRequest.setHeader(HttpHeaders.CONTENT_TYPE, "application/json"); try { postRequest.setBody(objectMapper.writeValueAsBytes(payload)); } catch (JsonProcessingException e) { throw Throwables.propagate(e); } CompletableFuture<Response> webhookFuture = new CompletableFuture<>(); try { handler.setCompletableFuture(webhookFuture); postRequest.execute(handler); } catch (IOException e) { LOG.warn("Couldn't execute webhook to {}", uri, e); if (handler.shouldDeleteUpdateDueToQueueAboveCapacity()) { handler.deleteWebhookUpdate(); } webhookFuture.completeExceptionally(e); } return webhookFuture; }
@Override public void write(OutputStream output) throws WebApplicationException, IOException { if (wrappedOutputStream == null) { wrappedOutputStream = output; try { requestBuilder.execute(this).get(); } catch (ExecutionException | InterruptedException e) { LOG.error("Failed or interrupted while proxying a download from Mesos", e); } } } }
socket = client.prepareGet(url).execute(handler).get(); LOG.info("Successfully connected to {}.", url); } catch (ExecutionException e) {
.addHeader("Content-Type", MediaType.sse.name()) .addHeader("last-event-id", count + "") .execute(new AsyncHandler<String>() {
try { final ListenableFuture<Response> futureStatus = builder.execute(new AsyncCompletionHandler<Response>() { @Override public Response onCompleted(final Response response) throws Exception {
builder.execute(new HttpHealthCheckCallback(ip, task)); MetricsMonitor.getHttpHealthCheckMonitor().incrementAndGet(); } catch (Throwable e) {
private Response doGetRequest(final String path) { final BoundRequestBuilder builder = httpClient.prepareGet(securityConfig.getShiroOktaUrl() + path); builder.addHeader("Authorization", "SSWS " + securityConfig.getShiroOktaAPIToken()); builder.addHeader("Content-Type", "application/json; charset=UTF-8"); final Response response; try { final ListenableFuture<Response> futureStatus = builder.execute(new AsyncCompletionHandler<Response>() { @Override public Response onCompleted(final Response response) throws Exception { return response; } }); response = futureStatus.get(DEFAULT_TIMEOUT_SECS, TimeUnit.SECONDS); } catch (final TimeoutException toe) { log.warn("Timeout while connecting to Okta"); throw new AuthorizationException(toe); } catch (final Exception e) { log.warn("Error while connecting to Okta"); throw new AuthorizationException(e); } return response; }
public Task<Response> task(final String desc) { return Task.async(desc, () -> { final SettablePromise<Response> result = Promises.settable(); _delegate.execute(new AsyncCompletionHandler<Response>() { @Override public Response onCompleted(final Response response) throws Exception { result.done(response); return response; } @Override public void onThrowable(Throwable t) { result.fail(t); } }); return result; }); }
public static void asyncHttpPostLarge(String url, List<String> headers, byte[] content, AsyncCompletionHandler handler) throws Exception { AsyncHttpClient.BoundRequestBuilder builder = asyncHttpClient.preparePost(url); if (!CollectionUtils.isEmpty(headers)) { for (String header : headers) { builder.setHeader(header.split("=")[0], header.split("=")[1]); } } builder.setBody(content); builder.setHeader("Content-Type", "application/json; charset=UTF-8"); builder.setHeader("Accept-Charset", "UTF-8"); builder.setHeader("Accept-Encoding", "gzip"); builder.setHeader("Content-Encoding", "gzip"); if (handler != null) { builder.execute(handler); } else { builder.execute(); } }
public static void asyncHttpGet(String url, List<String> headers, Map<String, String> paramValues, AsyncCompletionHandler handler) throws Exception { if (!MapUtils.isEmpty(paramValues)) { String encodedContent = encodingParams(paramValues, "UTF-8"); url += (null == encodedContent) ? "" : ("?" + encodedContent); } AsyncHttpClient.BoundRequestBuilder builder = asyncHttpClient.prepareGet(url); if (!CollectionUtils.isEmpty(headers)) { for (String header : headers) { builder.setHeader(header.split("=")[0], header.split("=")[1]); } } builder.setHeader("Accept-Charset", "UTF-8"); if (handler != null) { builder.execute(handler); } else { builder.execute(); } }