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 String sse(final String path, final int count) throws Exception { CountDownLatch latch = new CountDownLatch(count); String result = client.prepareGet("http://localhost:" + port + path) .addHeader("Content-Type", MediaType.sse.name()) .addHeader("last-event-id", count + "") .execute(new AsyncHandler<String>() {
public HttpRequest(HttpTransport transport, String apiKey, BoundRequestBuilder requestBuilder) throws IOException { this.requestBuilder = requestBuilder; this.requestBuilder.addHeader("Content-Type", "application/json"); this.out = new ByteArrayOutputStream(); }
AsyncHttpClient.BoundRequestBuilder prepareRequest(final String method, final ProtoHttpContent payload) throws IOException { final AsyncHttpClient.BoundRequestBuilder builder = client.preparePost(prefixUri + method); builder.addHeader("Authorization", "Bearer " + accessToken); builder.addHeader("Content-Type", "application/x-protobuf"); builder.addHeader("User-Agent", USER_AGENT); builder.addHeader("Accept-Encoding", "gzip"); builder.setContentLength((int) payload.getLength()); builder.setBody(payload.getMessage().toByteArray()); return builder; }
/** * If generatedContentType is present AND if Content-type header is not already present, add * generatedContentType as Content-Type to headers in requestBuilder */ private void addGeneratedContentType(BoundRequestBuilder requestBuilder) { if (!headers.containsKey("Content-Type") && generatedContentType != null) { requestBuilder.addHeader("Content-Type", generatedContentType); } }
@Test(groups = { "standalone", "default_provider" }) public void testQueryParameters() throws Exception { try (AsyncHttpClient client = getAsyncHttpClient(null)) { Future<Response> f = client.prepareGet("http://127.0.0.1:" + port1 + "/foo").addHeader("Accepts", "*/*").execute(); Response resp = f.get(3, TimeUnit.SECONDS); assertNotNull(resp); assertEquals(resp.getStatusCode(), 400); String respStr = resp.getResponseBody(); assertEquals(BAD_REQUEST_STR, respStr); } } }
@Override public AsyncHttpClient.BoundRequestBuilder authorize(AsyncHttpClient.BoundRequestBuilder requestBuilder) { Header header = getAuthHeader(); return requestBuilder.addHeader(header.getKey(), header.getValue()); }
@Override public RequestBuilder addHeader(final String name, final String value) { ningRequestBuilder.addHeader(name, value); return this; }
private static void addHeadersToRequest (Map<String, String> headersToAdd, AsyncHttpClient.BoundRequestBuilder requestBuilder) { if (headersToAdd != null) { headersToAdd.entrySet().forEach(entry -> requestBuilder.addHeader(entry.getKey(), entry.getValue())); } } }
protected AsyncHttpClient.BoundRequestBuilder getBuilderWithHeaderAndQuery(final String verb, final Map<String, String> headers, final Map<String, String> queryParams) { final AsyncHttpClient.BoundRequestBuilder builder = prepareBuilder(verb, url); addHeadsOrParams(headers, (key, value) -> builder.addHeader(key, value)); addHeadsOrParams(queryParams, (key, value) -> builder.addQueryParam(key, value)); return builder; }
private void crawlURL(String url, TweetFetcherHandler handler) { try { asyncHttpClient.prepareGet(url).addHeader("Accept-Charset", "utf-8") .addHeader("Accept-Language", "en-US").execute(handler); } catch (IOException e) { LOG.warn("Abandoning due to error (" + e + "): " + url); crawl_repair.put(handler.getId(), handler.getLine()); connections.decrementAndGet(); } }
@Override public AsyncHttpClient.BoundRequestBuilder authorize(AsyncHttpClient.BoundRequestBuilder requestBuilder) { Header authHeader = getAuthHeader(); return requestBuilder.addHeader(authHeader.getKey(), authHeader.getValue()); }
private void crawlURL(String url, TweetFetcherHandler handler) { try { asyncHttpClient.prepareGet(url).addHeader("Accept-Charset", "utf-8") .addHeader("Accept-Language", "en-US").execute(handler); } catch (IOException e) { LOG.warn("Abandoning due to error (" + e + "): " + url); crawl_repair.put(handler.getId(), handler.getLine()); connections.decrementAndGet(); } }
requestBuilder.addHeader(HttpHeaderNames.CONTENT_TYPE.toString(), HttpHeaderValues.APPLICATION_X_WWW_FORM_URLENCODED + ";charset" + charset.toString()) .addHeader(HttpHeaderNames.CONNECTION.toString(), HttpHeaderValues.KEEP_ALIVE.toString()) .addHeader(HttpHeaderNames.ACCEPT_ENCODING.toString(), HttpHeaderValues.GZIP_DEFLATE.toString()) .addHeader(HttpHeaderNames.USER_AGENT.toString(), "Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)") .addHeader(HttpHeaderNames.CACHE_CONTROL.toString(), "max-age=0") .addHeader(HttpHeaderNames.HOST.toString(), host + ":" + port) .addHeader("DNT", "1") sendHeaders.forEach((key, value) -> requestBuilder.addHeader(key, value.toString()));
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 copyHeadersAndParams(BoundRequestBuilder requestBuilder, HttpServletRequest request) { Enumeration<String> headerNames = request.getHeaderNames(); if (headerNames != null) { while (headerNames.hasMoreElements()) { String headerName = headerNames.nextElement(); requestBuilder.addHeader(headerName, request.getHeader(headerName)); LOG.trace("Copied header {}:{}", headerName, request.getHeader(headerName)); } } Enumeration<String> parameterNames = request.getParameterNames(); if (parameterNames != null) { while (parameterNames.hasMoreElements()) { String parameterName = parameterNames.nextElement(); requestBuilder.addQueryParameter(parameterName, request.getParameter(parameterName)); LOG.trace("Copied query param {}={}", parameterName, request.getParameter(parameterName)); } } }
/** * Adds the headers. * * @param builder * the builder * @param headerMap * the header map */ public static void addHeaders(BoundRequestBuilder builder, Map<String, String> headerMap) { for (Entry<String, String> entry : headerMap.entrySet()) { String name = entry.getKey(); String value = entry.getValue(); builder.addHeader(name, value); } }
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)); } }
public WrappedRequestBuilder addHeader(String name, String value) { _delegate.addHeader(name, value); return this; }