@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(); } }
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(); } }
@Test(groups = { "default_provider", "async" }) public void mirrorByteTest() throws Throwable { try (AsyncHttpClient client = getAsyncHttpClient(null)) { Response r = client.preparePost(getTargetUrl()).setBody("MIRROR").execute().get(); assertEquals(r.getStatusCode(), 200); assertEquals(new String(r.getResponseBodyAsBytes(), "UTF-8"), "MIRROR"); } }
private void setStringBody() throws UnsupportedEncodingException { ningRequestBuilder.setBody(bodyString); ningRequestBuilder.setContentLength(bodyString.getBytes(charset).length); ningRequestBuilder.setBodyEncoding(charset); }
private void setByteArrayBody() { ningRequestBuilder.setBody(bodyByteArray); ningRequestBuilder.setContentLength(bodyByteArray.length); ningRequestBuilder.setBodyEncoding(charset); } }
private void setTypedBody() throws IOException { final byte[] body = marshallingStrategy.marshall(bodyObject); ningRequestBuilder.setBody(body); ningRequestBuilder.setContentLength(body.length); ningRequestBuilder.setBodyEncoding(charset); }
@Override public void accept(AsyncHttpClient.BoundRequestBuilder requestBuilder) { requestBuilder.setBody(bodyContents); } }
requestBuilder.setBody(objectMapper.writeValueAsBytes(body)); LOG.trace("Added body {} to reqeust", body);
builder.setBody(postData); String charset = ""; if (null!=this.httpHeaderMap) {
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 <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; }
private SingularityLoadBalancerUpdate sendBaragonRequest(LoadBalancerRequestId loadBalancerRequestId, BaragonRequest loadBalancerRequest, LoadBalancerMethod method) { try { LOG.trace("Preparing to send request {}", loadBalancerRequest); final BoundRequestBuilder requestBuilder = httpClient.preparePost(loadBalancerUri) .addHeader(HEADER_CONTENT_TYPE, CONTENT_TYPE_JSON) .setBody(objectMapper.writeValueAsBytes(loadBalancerRequest)); if (loadBalancerQueryParams.isPresent()) { addAllQueryParams(requestBuilder, loadBalancerQueryParams.get()); } return sendRequestWrapper(loadBalancerRequestId, method, requestBuilder.build(), BaragonRequestState.FAILED); } catch (IOException e) { return new SingularityLoadBalancerUpdate(BaragonRequestState.UNKNOWN, loadBalancerRequestId, Optional.of(e.getMessage()), System.currentTimeMillis(), method, Optional.of(loadBalancerUri)); } }
final ImmutableMap<String, String> body = ImmutableMap.<String, String>of("username", upToken.getUsername(), "password", String.valueOf(upToken.getPassword())); builder.setBody(mapper.writeValueAsString(body)); } catch (final JsonProcessingException e) { log.warn("Error while generating Okta payload");
public WrappedRequestBuilder setBody(BodyGenerator bodyGenerator) { _delegate.setBody(bodyGenerator); return this; }
public WrappedRequestBuilder setBody(File file) { _delegate.setBody(file); return this; }
public WrappedRequestBuilder setBody(InputStream stream) { _delegate.setBody(stream); return this; }
public WrappedRequestBuilder setBody(List<byte[]> data) { _delegate.setBody(data); return this; }
public WrappedRequestBuilder setBody(String data) { _delegate.setBody(data); return this; }
public WrappedRequestBuilder setBody(byte[] data) { _delegate.setBody(data); return this; }