org.apache.http.impl.client.BasicResponseHandler Java Examples

public static String[] getHosts() {
	try {
		DefaultHttpClient client = new DefaultHttpClient();
		client.getCredentialsProvider().setCredentials(new AuthScope(host_name, getAdminPort()),
				new UsernamePasswordCredentials("admin", "admin"));
		HttpGet get = new HttpGet("http://" + host_name + ":" + admin_port + "/manage/v2/hosts?format=json");

		HttpResponse response = client.execute(get);
		ResponseHandler<String> handler = new BasicResponseHandler();
		String body = handler.handleResponse(response);
		JsonNode actualObj = new ObjectMapper().readTree(body);
		JsonNode nameNode = actualObj.path("host-default-list").path("list-items");
		List<String> hosts = nameNode.findValuesAsText("nameref");
		String[] s = new String[hosts.size()];
		hosts.toArray(s);
		return s;

	} catch (Exception e) {
		e.printStackTrace();
	}
	return null;
}
 

private boolean isRunning(String host) {
	try {

		DefaultHttpClient client = new DefaultHttpClient();
		client.getCredentialsProvider().setCredentials(new AuthScope(host, 7997),
				new UsernamePasswordCredentials("admin", "admin"));

		HttpGet get = new HttpGet("http://" + host + ":7997?format=json");
		HttpResponse response = client.execute(get);
		ResponseHandler<String> handler = new BasicResponseHandler();
		String body = handler.handleResponse(response);
		if (body.contains("Healthy")) {
			return true;
		}

	} catch (Exception e) {
		return false;
	}
	return false;
}
 

private void postDeviceStatus(String baseURL, Header apiSecretHeader, DefaultHttpClient httpclient) throws Exception {
    String devicestatusURL = baseURL + "devicestatus";
    Log.i(TAG, "devicestatusURL: " + devicestatusURL);

    JSONObject json = new JSONObject();
    json.put("uploaderBattery", getBatteryLevel());
    String jsonString = json.toString();

    HttpPost post = new HttpPost(devicestatusURL);

    if (apiSecretHeader != null) {
        post.setHeader(apiSecretHeader);
    }

    StringEntity se = new StringEntity(jsonString);
    post.setEntity(se);
    post.setHeader("Accept", "application/json");
    post.setHeader("Content-type", "application/json");

    ResponseHandler responseHandler = new BasicResponseHandler();
    httpclient.execute(post, responseHandler);
}
 

public static String post(String url, String fileName, BufferedImage image) {
    Try<String> uploadedFile = Try.of(() -> {
        HttpClient client = HttpClientBuilder.create().build();

        HttpEntity entity = MultipartEntityBuilder
                .create()
                .setCharset(UTF_8)
                .setMode(BROWSER_COMPATIBLE)
                .addBinaryBody("file", getImageBytes(image), DEFAULT_BINARY, fileName)
                .build();

        HttpPost httpPost = new HttpPost(url);
        httpPost.setEntity(entity);

        HttpResponse response = client.execute(httpPost);
        return new BasicResponseHandler().handleResponse(response);
    }).onFailure(t -> logger.error("[POST image]", t));

    return (uploadedFile.isSuccess()) ? uploadedFile.get() : null;
}
 

public static String post(String url, String fileName, String json) {
    Try<String> uploadedFile = Try.of(() -> {
        HttpClient client = HttpClientBuilder.create().build();

        HttpEntity entity = MultipartEntityBuilder
                .create()
                .setCharset(UTF_8)
                .setMode(BROWSER_COMPATIBLE)
                .addBinaryBody("file", json.getBytes(UTF_8), ContentType.create(ContentType.TEXT_PLAIN.getMimeType(), UTF_8), fileName)
                .build();

        HttpPost httpPost = new HttpPost(url);
        httpPost.setEntity(entity);

        HttpResponse response = client.execute(httpPost);
        return new BasicResponseHandler().handleResponse(response);
    }).onFailure(t -> logger.error("[POST json]", t));

    return (uploadedFile.isSuccess()) ? uploadedFile.get() : null;
}
 

public static String getText(String redirectLocation) {
    HttpGet httpget = new HttpGet(redirectLocation);
    // Create a response handler
    ResponseHandler<String> responseHandler = new BasicResponseHandler();
    String responseBody = "";
    try {
        responseBody = httpclient.execute(httpget, responseHandler);
    } catch (Exception e) {
        e.printStackTrace();
        responseBody = null;
    } finally {
        httpget.abort();
        // httpclient.getConnectionManager().shutdown();
    }
    return responseBody;
}
 

public void testHttpProxy() throws IOException {
    Settings.setLoggingLevel("org.apache.http.wire", Level.DEBUG);
    Settings.setLoggingLevel("org.apache.http", Level.DEBUG);

    String proxyHost = Settings.getProperty("davmail.proxyHost");
    int proxyPort = Settings.getIntProperty("davmail.proxyPort");
    HttpHost proxy = new HttpHost(proxyHost, proxyPort);
    HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    clientBuilder.setProxy(proxy).setUserAgent(DavGatewayHttpClientFacade.IE_USER_AGENT);

    clientBuilder.setDefaultCredentialsProvider(getProxyCredentialProvider());

    try (CloseableHttpClient httpClient = clientBuilder.build()) {
        HttpGet httpget = new HttpGet("http://davmail.sourceforge.net/version.txt");
        try (CloseableHttpResponse response = httpClient.execute(httpget)) {
            String responseString = new BasicResponseHandler().handleResponse(response);
            System.out.println(responseString);
        }
    }
}
 

private boolean isRunning(String host) {
	try {

		DefaultHttpClient client = new DefaultHttpClient();
		client.getCredentialsProvider().setCredentials(new AuthScope(host, 7997),
				new UsernamePasswordCredentials("admin", "admin"));

		HttpGet get = new HttpGet("http://" + host + ":7997?format=json");
		HttpResponse response = client.execute(get);
		ResponseHandler<String> handler = new BasicResponseHandler();
		String body = handler.handleResponse(response);
		if (body.toLowerCase().contains("healthy")) {
			return true;
		} else {
			return false;
		}

	} catch (Exception e) {
		return false;
	}
}
 

@SuppressWarnings({"rawtypes", "unchecked"})
private void postDeviceStatus(String baseURL, DefaultHttpClient httpclient) throws Exception {
    String devicestatusURL = baseURL + "devicestatus";
    Log.i(TAG, "devicestatusURL: " + devicestatusURL);

    JSONObject json = new JSONObject();
    json.put("uploaderBattery", DexcomG4Activity.batLevel);
    String jsonString = json.toString();

    HttpPost post = new HttpPost(devicestatusURL);
    StringEntity se = new StringEntity(jsonString);
    post.setEntity(se);
    post.setHeader("Accept", "application/json");
    post.setHeader("Content-type", "application/json");

    ResponseHandler responseHandler = new BasicResponseHandler();
    httpclient.execute(post, responseHandler);
}
 

@Override
public List<EarthQuakeRec> handleResponse(HttpResponse response)
		throws ClientProtocolException, IOException {
	List<EarthQuakeRec> result = new ArrayList<EarthQuakeRec>();
	String JSONResponse = new BasicResponseHandler()
			.handleResponse(response);
	try {
		JSONObject object = (JSONObject) new JSONTokener(JSONResponse)
				.nextValue();
		JSONArray earthquakes = object.getJSONArray("earthquakes");
		for (int i = 0; i < earthquakes.length(); i++) {
			JSONObject tmp = (JSONObject) earthquakes.get(i);
			result.add(new EarthQuakeRec(
					tmp.getDouble("lat"),
					tmp.getDouble("lng"),
					tmp.getDouble("magnitude")));
		}
	} catch (JSONException e) {
		e.printStackTrace();
	}
	return result;
}
 

public static RateLimitsDto generateRateLimits(String apiKey, String opsGenieHost) throws IOException {
    try {
        HttpClient client = HttpClientBuilder.create().build();

        HttpGet httpGet = new HttpGet(opsGenieHost + "/v2/request-limits/");
        httpGet.addHeader(HttpHeaders.AUTHORIZATION, "GenieKey " + apiKey);

        String body = client.execute(httpGet, new BasicResponseHandler());
        DataDto result = new DataDto();
        BackupUtils.fromJson(result, body);

        return result.getData();
    } catch (Exception e) {
        logger.error("Could not initiate rate limits. " + e.getMessage());
        System.exit(1);
        return null;
    }
}
 

/**
 * Send HTTP GET request to {@link #endpointUrl}, updates {@link #csrfToken}
 * token
 *
 * @return true if {@link #endpointUrl} is accessible
 * @throws IOException
 * @throws ClientProtocolException
 * @throws AuthenticationException
 */
protected void fetchCsrfTokenFromHac() throws ClientProtocolException, IOException, AuthenticationException {
	final HttpGet getRequest = new HttpGet(getEndpointUrl());

	try {
		final HttpResponse response = httpClient.execute(getRequest, getContext());
		final String responseString = new BasicResponseHandler().handleResponse(response);
		csrfToken = getCsrfToken(responseString);

		if (StringUtil.isBlank(csrfToken)) {
			throw new AuthenticationException(ErrorMessage.CSRF_TOKEN_CANNOT_BE_OBTAINED);
		}
	} catch (UnknownHostException error) {
		final String errorMessage = error.getMessage();
		final Matcher matcher = HACPreferenceConstants.HOST_REGEXP_PATTERN.matcher(getEndpointUrl());

		if (matcher.find() && matcher.group(1).equals(errorMessage)) {
			throw new UnknownHostException(
					String.format(ErrorMessage.UNKNOWN_HOST_EXCEPTION_MESSAGE_FORMAT, matcher.group(1)));
		}
		throw error;
	}
}
 

static <T extends SparkResponse>  T executeHttpMethodAndGetResponse(HttpClient client, HttpRequestBase httpRequest, Class<T> responseClass) throws FailedSparkRequestException {
    T response;
    try {
        final String stringResponse = client.execute(httpRequest, new BasicResponseHandler());
        if (stringResponse != null) {
            response = MapperWrapper.MAPPER.readValue(stringResponse, responseClass);
        } else {
            throw new FailedSparkRequestException("Received empty string response");
        }
    } catch (IOException e) {
        throw new FailedSparkRequestException(e);
    } finally {
        httpRequest.releaseConnection();
    }

    if (response == null) {
        throw new FailedSparkRequestException("An issue occured with the cluster's response.");
    }

    return response;
}
 

protected void httpClientWebData() {
    DefaultHttpClient httpClinet = new DefaultHttpClient();
    String pediyUrl = ped.getText().toString();

    HttpGet httpGet = new HttpGet(pediyUrl);
    ResponseHandler<String> responseHandler = new BasicResponseHandler();
    try {
        String content = httpClinet.execute(httpGet, responseHandler);
        mHandler.obtainMessage(MSG_SUCCESS, content).sendToTarget();
    } catch (IOException e) {

        e.printStackTrace();
    }


}
 

public String notifyHunter(byte[] content) throws IOException {
    try {
        String request = new String(content);
        SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, (certificate, authType) -> true).build();
        HttpClient httpclient = HttpClients.custom().setSSLContext(sslContext).setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
        HttpPost httpPost = new HttpPost("https://api"+hunterDomain.substring(hunterDomain.indexOf("."))+"/api/record_injection");
        String json = "{\"request\": \""+request.replace("\\", "\\\\").replace("\"", "\\\"").replace("\r\n", "\\n")+"\", \"owner_correlation_key\": \""+hunterKey+"\", \"injection_key\": \""+injectKey+"\"}";
        StringEntity entity = new StringEntity(json);
        entity.setContentType("applicaiton/json");
        httpPost.setEntity(entity);
        HttpResponse response = httpclient.execute(httpPost);
        String responseString = new BasicResponseHandler().handleResponse(response);
        return responseString;
    } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException ex) {
        
        Logger.getLogger(HunterRequest.class.getName()).log(Level.SEVERE, null, ex);
    }
    return "Error Notifying Probe Server!";
}
 

@Test
public void createNetworkTest() throws Exception {
    String networkName = "example network 1";
    String tenant_net_uuid = UUID.randomUUID().toString();
    SspClient sspClient = spy(new SspClient(apiUrl, username, password));

    HttpClient client = mock(HttpClient.class);
    doReturn(client).when(sspClient).getHttpClient();
    String body = "{\"uuid\":\"" + tenant_net_uuid + "\",\"name\":\"" + networkName
            + "\",\"tenant_uuid\":\"" + uuid + "\"}";
    when(client.execute(any(HttpUriRequest.class), any(BasicResponseHandler.class))).thenReturn(body);

    SspClient.TenantNetwork tnet = sspClient.createTenantNetwork(uuid, networkName);
    assertEquals(tnet.name, networkName);
    assertEquals(tnet.uuid, tenant_net_uuid);
    assertEquals(tnet.tenantUuid, uuid);
}
 

private Snapshot retrieveMetrics(ConsumerId consumer) {
    String metricsUri = node.metricsUri(consumer).toString();
    log.log(FINE, () -> "Retrieving metrics from host " + metricsUri);

    try {
        String metricsJson = httpClient.execute(new HttpGet(metricsUri), new BasicResponseHandler());
        var metricsBuilders = GenericJsonUtil.toMetricsPackets(metricsJson);
        var metrics = processAndBuild(metricsBuilders,
                                      new ServiceIdDimensionProcessor(),
                                      new ClusterIdDimensionProcessor(),
                                      new PublicDimensionsProcessor(MAX_DIMENSIONS));
        snapshotsRetrieved ++;
        log.log(FINE, () -> "Successfully retrieved " + metrics.size() + " metrics packets from " + metricsUri);

        return new Snapshot(Instant.now(clock), metrics);
    } catch (IOException e) {
        log.warning("Unable to retrieve metrics from " + metricsUri + ": " + Exceptions.toMessageString(e));
        return new Snapshot(Instant.now(clock), emptyList());
    }
}
 

/**
 * @return the RAW XML document of ItemLookup (Large Response) from Amazon
 *         product advertisement API
 * @throws InvalidKeyException
 * @throws NoSuchAlgorithmException
 * @throws ClientProtocolException
 * @throws IOException
 */
public String getXMLLargeResponse() throws InvalidKeyException,
		NoSuchAlgorithmException, ClientProtocolException, IOException {
	String responseBody = "";
	String signedurl = signInput();
	try {
		HttpClient httpclient = new DefaultHttpClient();
		HttpGet httpget = new HttpGet(signedurl);
		ResponseHandler<String> responseHandler = new BasicResponseHandler();
		responseBody = httpclient.execute(httpget, responseHandler);
		// responseBody now contains the contents of the page
		// System.out.println(responseBody);
		httpclient.getConnectionManager().shutdown();
	} catch (Exception e) {
		System.out.println("Exception" + " " + itemID + " " + e.getClass());
	}
	return responseBody;
}
 

@Test
@SuppressWarnings("unchecked")
public void shouldAttachTraceIdWhenCallingAnotherServiceForHttpClient()
		throws Exception {
	Span span = this.tracer.nextSpan().name("foo").start();

	try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) {
		String response = this.httpClientBuilder.build().execute(
				new HttpGet("http://localhost:" + this.port),
				new BasicResponseHandler());

		then(response).isNotEmpty();
	}

	then(this.tracer.currentSpan()).isNull();
	then(this.spans).isNotEmpty().extracting("traceId", String.class)
			.containsOnly(span.context().traceIdString());
	then(this.spans).extracting("kind.name").contains("CLIENT");
}
 

@Override
public String get(String url) {
    try {
        return httpClient.execute(new HttpGet(url), new BasicResponseHandler());
    }
    catch (IOException e) {
        throw new UncheckedIOException("Could not get " + url, e);
    }
}
 

protected String doHttpGet(String url) throws ClientProtocolException,
		IOException {

	HttpClient httpclient = new DefaultHttpClient();
	HttpGet httpget = new HttpGet(url);
	ResponseHandler<String> responseHandler = new BasicResponseHandler();

	try {
		String responseBody = httpclient.execute(httpget, responseHandler);
		return responseBody;
	} finally {
		httpclient.getConnectionManager().shutdown();
	}

}
 

@Test
public void loginTest() throws Exception {
    SspClient sspClient = spy(new SspClient(apiUrl, username, password));

    HttpClient client = mock(HttpClient.class);
    doReturn(client).when(sspClient).getHttpClient();
    when(client.execute(any(HttpUriRequest.class), any(BasicResponseHandler.class))).thenReturn("");

    assertTrue(sspClient.login());
    assertTrue(sspClient.login());
    assertTrue(sspClient.login());
}
 

protected String doHttpGet(String url) throws ClientProtocolException,
		IOException {

	HttpClient httpclient = new DefaultHttpClient();
	HttpGet httpget = new HttpGet(url);
	ResponseHandler<String> responseHandler = new BasicResponseHandler();

	try {
		String responseBody = httpclient.execute(httpget, responseHandler);
		return responseBody;
	} finally {
		httpclient.getConnectionManager().shutdown();
	}

}
 

private String[] executeRequest(HttpUriRequest request) throws IOException {
    HttpClient client = new DefaultHttpClient();
    HttpConnectionParams.setConnectionTimeout(client.getParams(), 15000);
    HttpConnectionParams.setSoTimeout(client.getParams(), 15000);

    try {
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        String response = client.execute(request, responseHandler);
        return response.split("\\n");

    } finally {
        client.getConnectionManager().shutdown();
    }
}
 

private HttpResponse valuesResponse(String consumer) {
    try {
        String uri = metricsProxyUri + consumerQuery(consumer);
        String prometheusText = httpClient.execute(new HttpGet(uri), new BasicResponseHandler());
        return new StringResponse(prometheusText);
    } catch (IOException e) {
        log.warning("Unable to retrieve metrics from " + metricsProxyUri + ": " + Exceptions.toMessageString(e));
        return new ErrorResponse(INTERNAL_SERVER_ERROR, e.getMessage());
    }
}
 

private JsonResponse valuesResponse(String consumer) {
    try {
        String uri = metricsProxyUri + consumerQuery(consumer);
        String metricsJson = httpClient.execute(new HttpGet(uri), new BasicResponseHandler());
        return new JsonResponse(OK, metricsJson);
    } catch (IOException e) {
        log.warning("Unable to retrieve metrics from " + metricsProxyUri + ": " + Exceptions.toMessageString(e));
        return new ErrorResponse(INTERNAL_SERVER_ERROR, e.getMessage());
    }
}
 

private void testUrlRedirection() {

            String urlToTest;
            String url = URL_REDIRECTION_TEST_URL;
            if (settingsService.getUrlRedirectType() == UrlRedirectType.NORMAL) {
                url += "?redirectFrom=" + settingsService.getUrlRedirectFrom();
                urlToTest = settingsService.getUrlRedirectFrom() + ".subsonic.org";
            } else {
                url += "?customUrl=" + settingsService.getUrlRedirectCustomUrl();
                urlToTest = settingsService.getUrlRedirectCustomUrl();
            }

            HttpGet request = new HttpGet(url);
            HttpClient client = new DefaultHttpClient();
            HttpConnectionParams.setConnectionTimeout(client.getParams(), 10000);
            HttpConnectionParams.setSoTimeout(client.getParams(), 30000);

            try {
                urlRedirectionStatus.setText("Testing web address " + urlToTest + ". Please wait...");
                String response = client.execute(request, new BasicResponseHandler());
                urlRedirectionStatus.setText(response);

            } catch (Throwable x) {
                LOG.warn("Failed to test web address.", x);
                urlRedirectionStatus.setText("Failed to test web address. " + x.getMessage() + " (" + x.getClass().getSimpleName() + ")");
            } finally {
                client.getConnectionManager().shutdown();
            }
        }
 

private String executeRequest(HttpUriRequest request) throws IOException {
    HttpClient client = new DefaultHttpClient();
    HttpConnectionParams.setConnectionTimeout(client.getParams(), 10000);
    HttpConnectionParams.setSoTimeout(client.getParams(), 10000);

    try {
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        return client.execute(request, responseHandler);

    } finally {
        client.getConnectionManager().shutdown();
    }
}
 

private void validateLicense() {
    String email = getLicenseEmail();
    Date date = getLicenseDate();

    if (email == null || date == null) {
        licenseValidated = false;
        return;
    }

    HttpClient client = new DefaultHttpClient();
    HttpConnectionParams.setConnectionTimeout(client.getParams(), 120000);
    HttpConnectionParams.setSoTimeout(client.getParams(), 120000);
    HttpGet method = new HttpGet("http://subsonic.org/backend/validateLicense.view" + "?email=" + StringUtil.urlEncode(email) +
            "&date=" + date.getTime() + "&version=" + versionService.getLocalVersion());
    try {
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        String content = client.execute(method, responseHandler);
        licenseValidated = content != null && !content.contains("false");
        if (!licenseValidated) {
            LOG.warn("License key is not valid.");
        }
        String[] lines = StringUtils.split(content);
        if (lines.length > 1) {
            licenseExpires = new Date(Long.parseLong(lines[1]));
        }

    } catch (Throwable x) {
        LOG.warn("Failed to validate license.", x);
    } finally {
        client.getConnectionManager().shutdown();
    }
}
 

private String[] executeRequest(HttpUriRequest request) throws ClientProtocolException, IOException {
    try (CloseableHttpClient client = HttpClients.createDefault()) {
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        String response = client.execute(request, responseHandler);
        return response.split("\\r?\\n");
    }
}