Example usage for org.apache.http.client.utils HttpClientUtils closeQuietly

List of usage examples for org.apache.http.client.utils HttpClientUtils closeQuietly

Introduction

In this page you can find the example usage for org.apache.http.client.utils HttpClientUtils closeQuietly.

Prototype

public static void closeQuietly(final HttpClient httpClient) 

Source Link

Document

Unconditionally close a httpClient.

Usage

From source file:org.wso2.appcloud.integration.test.utils.clients.LogsClient.java

public String[] getSnapshotLogs(String applicationKey, String applicationRevision)
        throws AppCloudIntegrationTestException {
    HttpClient httpclient = null;/*from w  w w.  j a v a  2 s  .c  o  m*/
    org.apache.http.HttpResponse response = null;
    try {
        httpclient = HttpClients.custom().setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE).build();
        int timeout = (int) AppCloudIntegrationTestUtils.getTimeOutPeriod();
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout)
                .setConnectTimeout(timeout).build();
        HttpPost httppost = new HttpPost(this.endpoint);
        httppost.setConfig(requestConfig);
        List<NameValuePair> params = new ArrayList<NameValuePair>(3);
        params.add(new BasicNameValuePair(PARAM_NAME_ACTION, "getSnapshotLogs"));
        params.add(new BasicNameValuePair(PARAM_NAME_APPLICATION_HASH_ID, applicationKey));
        params.add(new BasicNameValuePair(PARAM_NAME_APPLICATION_REVISION, applicationRevision));
        httppost.setEntity(new UrlEncodedFormEntity(params, UTF_8_ENCODING));
        httppost.setHeader(HEADER_COOKIE, getRequestHeaders().get(HEADER_COOKIE));
        response = httpclient.execute(httppost);
        String[] resultArray = new String[2];
        resultArray[0] = String.valueOf(response.getStatusLine().getStatusCode());
        resultArray[1] = EntityUtils.toString(response.getEntity());
        return resultArray;
    } catch (IOException e) {
        log.error("Failed to invoke app icon update API.", e);
        throw new AppCloudIntegrationTestException("Failed to invoke app icon update API.", e);
    } finally {
        HttpClientUtils.closeQuietly(response);
        HttpClientUtils.closeQuietly(httpclient);
    }

}

From source file:com.seyren.core.service.notification.SlackNotificationService.java

@Override
public void sendNotification(Check check, Subscription subscription, List<Alert> alerts)
        throws NotificationFailedException {
    String token = seyrenConfig.getSlackToken();
    String channel = subscription.getTarget();
    String username = seyrenConfig.getSlackUsername();
    String iconUrl = seyrenConfig.getSlackIconUrl();

    List<String> emojis = Lists.newArrayList(
            Splitter.on(',').omitEmptyStrings().trimResults().split(seyrenConfig.getSlackEmojis()));

    String url = String.format("%s/api/chat.postMessage", baseUrl);
    HttpClient client = HttpClientBuilder.create().useSystemProperties().build();
    HttpPost post = new HttpPost(url);
    post.addHeader("accept", "application/json");

    List<BasicNameValuePair> parameters = new ArrayList<BasicNameValuePair>();
    parameters.add(new BasicNameValuePair("token", token));
    parameters.add(new BasicNameValuePair("channel", StringUtils.removeEnd(channel, "!")));
    parameters.add(new BasicNameValuePair("text", formatContent(emojis, check, subscription, alerts)));
    parameters.add(new BasicNameValuePair("username", username));
    parameters.add(new BasicNameValuePair("icon_url", iconUrl));

    try {/* w w w  .  jav  a  2s .  co m*/
        post.setEntity(new UrlEncodedFormEntity(parameters));
        if (LOGGER.isDebugEnabled()) {
            LOGGER.info("> parameters: {}", parameters);
        }
        HttpResponse response = client.execute(post);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.info("> parameters: {}", parameters);
            LOGGER.debug("Status: {}, Body: {}", response.getStatusLine(),
                    new BasicResponseHandler().handleResponse(response));
        }
    } catch (Exception e) {
        LOGGER.warn("Error posting to Slack", e);
    } finally {
        post.releaseConnection();
        HttpClientUtils.closeQuietly(client);
    }

}

From source file:org.jboss.as.test.clustering.single.singleton.SingletonServiceTestCase.java

@Test
public void testSingletonService(@ArquillianResource(NodeServiceServlet.class) URL baseURL)
        throws IOException, URISyntaxException {

    // URLs look like "http://IP:PORT/singleton/service"
    URI defaultURI = NodeServiceServlet.createURI(baseURL, NodeServiceActivator.DEFAULT_SERVICE_NAME);
    URI quorumURI = NodeServiceServlet.createURI(baseURL, NodeServiceActivator.QUORUM_SERVICE_NAME);

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(defaultURI));
        try {/*from  w ww . j a  v a2s .c  om*/
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_1, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // Service should be started regardless of whether a quorum was required.
        response = client.execute(new HttpGet(quorumURI));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_1, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:org.jboss.as.test.clustering.cluster.web.NonDistributableTestCase.java

@Test
public void test(@ArquillianResource(SimpleServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource(SimpleServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws IOException, URISyntaxException {
    URI uri1 = SimpleServlet.createURI(baseURL1);
    URI uri2 = SimpleServlet.createURI(baseURL2);

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(uri1));
        try {/*w  w  w . j  a v a 2  s.c o m*/
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(1,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
            Map.Entry<String, String> entry = parseSessionRoute(response);
            // Session identifier should contain the route for this node
            Assert.assertEquals(NODE_1, entry.getValue());
            // Session identifier seen by servlet should *not* contain the route
            Assert.assertEquals(entry.getKey(),
                    response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(uri1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(2,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
            Map.Entry<String, String> entry = parseSessionRoute(response);
            Assert.assertNull(entry);
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(uri2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            // Session should not be replicated
            Assert.assertEquals(1,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
            Map.Entry<String, String> entry = parseSessionRoute(response);
            // Session identifier should contain the route for this node
            Assert.assertEquals(NODE_2, entry.getValue());
            // Session identifier seen by servlet should *not* contain the route
            Assert.assertEquals(entry.getKey(),
                    response.getFirstHeader(SimpleServlet.SESSION_ID_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(uri2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(2,
                    Integer.parseInt(response.getFirstHeader(SimpleServlet.VALUE_HEADER).getValue()));
            Map.Entry<String, String> entry = parseSessionRoute(response);
            Assert.assertNull(entry);
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:org.jboss.as.test.clustering.cluster.web.context.InvalidateConversationTestCase.java

@Test
public void testInvalidate(
        @ArquillianResource(ConversationServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource(ConversationServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws IOException, URISyntaxException {

    String conversation = null;/*from  w ww. j  a va  2s  .  com*/

    establishTopology(baseURL1, NODES);

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(ConversationServlet.createURI(baseURL1)));
        try {
            assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            assertTrue(response.containsHeader(ConversationServlet.COUNT_HEADER));
            assertEquals(1,
                    Integer.parseInt(response.getFirstHeader(ConversationServlet.COUNT_HEADER).getValue()));
            conversation = response.getFirstHeader(ConversationServlet.CONVERSATION_ID).getValue();
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(ConversationServlet.createURI(baseURL2, conversation)));
        try {
            assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            assertTrue(response.containsHeader(ConversationServlet.COUNT_HEADER));
            assertEquals(2,
                    Integer.parseInt(response.getFirstHeader(ConversationServlet.COUNT_HEADER).getValue()));
            assertEquals(conversation, response.getFirstHeader(ConversationServlet.CONVERSATION_ID).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(LogoutServlet.createURI(baseURL1, conversation)));
        try {
            assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            assertTrue(response.containsHeader(ConversationServlet.COUNT_HEADER));
            assertEquals(3,
                    Integer.parseInt(response.getFirstHeader(ConversationServlet.COUNT_HEADER).getValue()));
            assertEquals(conversation, response.getFirstHeader(ConversationServlet.CONVERSATION_ID).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:org.jboss.as.test.clustering.cluster.web.DistributableTestCase.java

@Test
@OperateOnDeployment(DEPLOYMENT_1)/* www  .  j a  v  a2 s  . c  o m*/
public void testSerialized(@ArquillianResource(SimpleServlet.class) URL baseURL)
        throws IOException, URISyntaxException {

    // returns the URL of the deployment (http://127.0.0.1:8180/distributable)
    URI uri = SimpleServlet.createURI(baseURL);

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(uri));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(1, Integer.parseInt(response.getFirstHeader("value").getValue()));
            Assert.assertFalse(Boolean.valueOf(response.getFirstHeader("serialized").getValue()));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(uri));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(2, Integer.parseInt(response.getFirstHeader("value").getValue()));
            // This won't be true unless we have somewhere to which to replicate
            Assert.assertTrue(Boolean.valueOf(response.getFirstHeader("serialized").getValue()));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:com.android.tools.idea.stats.UsageTrackerAnalyticsImpl.java

/**
 * Send a ping to Analytics on a separate thread
 *///from   w  w  w  .  j  av a2s  .co  m
private static void sendPing(@NotNull final List<? extends NameValuePair> postData) {
    ApplicationManager.getApplication().executeOnPooledThread(new Runnable() {
        @Override
        public void run() {
            CloseableHttpClient client = HttpClientBuilder.create().build();
            HttpPost request = new HttpPost(ANALYTICS_URL);
            try {
                request.setEntity(new UrlEncodedFormEntity(postData));
                HttpResponse response = client.execute(request);
                StatusLine status = response.getStatusLine();
                HttpEntity entity = response.getEntity(); // throw it away, don't care, not sure if we need to read in the response?
                if (status.getStatusCode() >= 300) {
                    LOG.debug("Non 200 status code : " + status.getStatusCode() + " - "
                            + status.getReasonPhrase());
                    // something went wrong, fail quietly, we probably have to diagnose analytics errors on our side
                    // usually analytics accepts ANY request and always returns 200
                }
            } catch (IOException e) {
                LOG.debug("IOException during Analytics Ping", e.getMessage());
                // something went wrong, fail quietly
            } finally {
                HttpClientUtils.closeQuietly(client);
            }
        }
    });
}

From source file:org.jboss.as.test.clustering.cluster.web.authentication.BasicAuthenticationWebFailoverTestCase.java

@Test
public void test(@ArquillianResource(SecureServlet.class) @OperateOnDeployment(DEPLOYMENT_1) URL baseURL1,
        @ArquillianResource(SecureServlet.class) @OperateOnDeployment(DEPLOYMENT_2) URL baseURL2)
        throws IOException, URISyntaxException {

    CredentialsProvider provider = new BasicCredentialsProvider();
    HttpClient client = HttpClients.custom().setDefaultCredentialsProvider(provider).build();

    URI uri1 = SecureServlet.createURI(baseURL1);
    URI uri2 = SecureServlet.createURI(baseURL2);

    try {/*from  ww w. ja  v  a 2 s.com*/
        // Valid login, invalid role
        setCredentials(provider, "forbidden", "password", baseURL1, baseURL2);
        HttpResponse response = client.execute(new HttpGet(uri1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_FORBIDDEN, response.getStatusLine().getStatusCode());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // Invalid login, valid role
        setCredentials(provider, "allowed", "bad", baseURL1, baseURL2);
        response = client.execute(new HttpGet(uri1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_UNAUTHORIZED, response.getStatusLine().getStatusCode());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // Valid login, valid role
        setCredentials(provider, "allowed", "password", baseURL1, baseURL2);
        String sessionId = null;
        response = client.execute(new HttpGet(uri1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertNotNull(response.getFirstHeader(SecureServlet.SESSION_ID_HEADER));
            sessionId = response.getFirstHeader(SecureServlet.SESSION_ID_HEADER).getValue();
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        undeploy(DEPLOYMENT_1);

        response = client.execute(new HttpGet(uri2));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(sessionId, response.getFirstHeader(SecureServlet.SESSION_ID_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        deploy(DEPLOYMENT_1);

        response = client.execute(new HttpGet(uri1));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertEquals(sessionId, response.getFirstHeader(SecureServlet.SESSION_ID_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    } finally {
        HttpClientUtils.closeQuietly(client);
    }
}