@Override public Integer onCompleted(Response response) throws Exception { if (response.getStatusCode() != HttpURLConnection.HTTP_OK) { Loggers.RAFT.error("[NACOS-RAFT] get peer failed: {}, peer: {}", response.getResponseBody(), peer.ip); peer.state = RaftPeer.State.FOLLOWER; return 1; } update(JSON.parseObject(response.getResponseBody(), RaftPeer.class)); return 0; } });
private boolean isAuthenticated(final Response oktaRawResponse) { try { final Map oktaResponse = mapper.readValue(oktaRawResponse.getResponseBodyAsStream(), Map.class); if ("SUCCESS".equals(oktaResponse.get("status"))) { return true; } else { log.warn("Okta authentication failed: " + oktaResponse); return false; } } catch (final IOException e) { log.warn("Unable to read response from Okta"); throw new AuthenticationException(e); } }
public ResponseMetadata(Response response) { this.requestId = response.getHeader("X-Request-Id"); this.cfRay = response.getHeader("CF-RAY"); this.statusCode = response.getStatusCode(); }
@Override public ListResponse onCompleted(Response response) throws Exception { return AbstractPackageManagerClient.parseListResponse( response.getStatusCode(), response.getStatusText(), response.getResponseBodyAsStream(), getResponseEncoding(response) ); } };
if (responseHeaderMeta.isGetAll()) { for (Map.Entry<String, List<String>> header : response .getHeaders()) { responseHeaders.put(header.getKey().toLowerCase(Locale.ROOT), header.getValue()); if (response.getHeaders().containsKey(key)) { responseHeaders.put(key.toLowerCase(Locale.ROOT), response.getHeaders().get(key)); int statusCodeInt = response.getStatusCode(); String statusCode = statusCodeInt + " " + response.getStatusText(); String charset = ParallecGlobalConfig.httpResponseBodyCharsetUsesResponseContentType && response.getContentType()!=null ? AsyncHttpProviderUtils.parseCharset(response.getContentType()) : ParallecGlobalConfig.httpResponseBodyDefaultCharset; if(charset == null){ charset = ParallecGlobalConfig.httpResponseBodyDefaultCharset; reply(response.getResponseBody(charset), false, null, null, statusCode, statusCodeInt, responseHeaders); } catch (IOException e) {
private void fireCompleted(Response response) { if (listener != null) { listener.onCompleted(uri, response.getStatusCode(), response.getStatusText()); } } }
if (response.getStatusCode() > 399) { throw new WebApplicationException(response.getResponseBody(Charsets.UTF_8.toString()), response.getStatusCode()); } else { return objectMapper.readValue(response.getResponseBodyAsStream(), clazz); String message = String.format("Request to leader succeeded with status %s, but could not interpret response", response.getStatusCode()); LOG.error(message, ioe); throw new WebApplicationException(message, ioe, 500);
@Override public Integer onCompleted(Response response) throws Exception { if (response.getStatusCode() != HttpURLConnection.HTTP_OK) { Loggers.RAFT.warn("[RAFT] failed to publish data to peer, datumId={}, peer={}, http code={}", datum.key, server, response.getStatusCode()); return 1; } return 0; }
private HttpResponse convert(final HttpRequest httpRequest, final Response response) { final byte[] responseBodyAsBytes = getResponseBodyAsBytes(response); return HttpResponse.of(response.getStatusCode(), responseBodyAsBytes, httpRequest, HttpHeaders.of(response.getHeaders())); }
@Override public Integer onCompleted(Response response) throws Exception { // get the headers Map<String,List<String>> headers = response.getHeaders(); replyAddress.tell(new HttpResponse(response.getStatusCode(), headers, response.getResponseBodyAsBytes()),serviceAddress); return response.getStatusCode(); }
public HttpResponse create(Response response, InputStream inputStream) throws IOException { HttpResponseBuilder responseBuilder = HttpResponse.builder(); responseBuilder.statusCode(response.getStatusCode()); responseBuilder.reasonPhrase(response.getStatusText()); String contentType = response.getHeader(HEADER_CONTENT_TYPE); String contentLength = response.getHeader(HEADER_CONTENT_LENGTH); responseBuilder.entity(createEntity(inputStream, contentType, contentLength)); if (response.hasResponseHeaders()) { for (Entry<String, List<String>> headerEntry : response.getHeaders().entrySet()) { responseBuilder.addHeaders(headerEntry.getKey(), headerEntry.getValue()); } } return responseBuilder.build(); }
@Override public Response onCompleted(Response response) throws Exception { LOG.trace("Webhook {} for {} completed with {} after {}", webhook.getUri(), update, response.getStatusCode(), JavaUtils.duration(start)); if (response.hasResponseBody()) { LOG.trace("Webhook response message is: '{}'", response.getResponseBody()); } if (JavaUtils.isHttpSuccess(response.getStatusCode()) || shouldDeleteUpdateOnFailure) { deleteWebhookUpdate(); } if (completableFuture != null) { completableFuture.complete(response); } return response; }
@Override public Response onCompleted(Response response) throws Exception { if (response.getStatusCode() != 200) { logger.error("Error while sending command to Plex: {}\r\n{}", response.getStatusText(), response.getResponseBody()); } return response; }
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); } } }
@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"); } }
@Override public Response onCompleted(Response response) throws Exception { Optional<String> responseBody = Optional.absent(); if (response.hasResponseBody()) { responseBody = Optional.of(response.getResponseBodyExcerpt(maxHealthcheckResponseBodyBytes)); } saveResult(Optional.of(response.getStatusCode()), responseBody, Optional.<String> absent(), Optional.<Throwable>absent()); return response; }
static CompletableFuture<Integer> AccessTheWebAsyncNio(){ final AsyncHttpClient asyncHttpClient = new AsyncHttpClient(); final CompletableFuture<Integer> promise = new CompletableFuture<>(); asyncHttpClient .prepareGet("https://msdn.microsoft.com") .execute(new AsyncCompletionHandler<Response>(){ @Override public Response onCompleted(Response resp) throws Exception { promise.complete(resp.getResponseBody().length()); return resp; } }); return promise; }
public List<String> getHeaders(String name) { return response.getHeaders(name); }
@Test(groups = { "online", "default_provider", "async" }) public void asyncDoGetStreamAndBodyTest() throws Throwable { try (AsyncHttpClient client = getAsyncHttpClient(new Builder().build())) { Response r = client.prepareGet("http://www.google.com/").execute().get(); r.getResponseBody(); r.getResponseBodyAsStream(); } }
private byte[] getResponseBodyAsBytes(final Response response) { try { final boolean gzipEncoded = Optional.ofNullable(response.getHeader(HttpHeaders.CONTENT_ENCODING)) .map(v -> v.equalsIgnoreCase("gzip")) .orElse(false); return gzipEncoded ? unzip(response) : response.getResponseBodyAsBytes(); } catch (IOException e) { throw new HttpException(e); } }