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

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

  1. HOME
  2. Java
  3. org.apache.http
  4. org.apache.http.client.utils.*
  5. HttpClientUtils
  6. 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.jboss.additional.testsuite.jdkall.present.clustering.cluster.web.ClusteredWebSimpleTestCase.java

@Test
@OperateOnDeployment(DEPLOYMENT_1)/*from   w  w  w. jav  a  2 s  .co 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:org.gradle.caching.http.internal.HttpBuildCacheService.java

@Override
public boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException {
    final URI uri = root.resolve("./" + key.getHashCode());
    HttpGet httpGet = new HttpGet(uri);
    httpGet.addHeader(HttpHeaders.ACCEPT, BUILD_CACHE_CONTENT_TYPE + ", */*");
    addDiagnosticHeaders(httpGet);//from  w w w  . ja v a2 s  . co  m

    CloseableHttpResponse response = null;
    try {
        response = httpClientHelper.performHttpRequest(httpGet);
        StatusLine statusLine = response.getStatusLine();
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Response for GET {}: {}", safeUri(uri), statusLine);
        }
        int statusCode = statusLine.getStatusCode();
        if (isHttpSuccess(statusCode)) {
            reader.readFrom(response.getEntity().getContent());
            return true;
        } else if (statusCode == HttpStatus.SC_NOT_FOUND) {
            return false;
        } else {
            String defaultMessage = String.format("Loading entry from '%s' response status %d: %s",
                    safeUri(uri), statusCode, statusLine.getReasonPhrase());
            if (isRedirect(statusCode)) {
                return handleRedirect(uri, response, statusCode, defaultMessage, "loading entry from");
            } else {
                return throwHttpStatusCodeException(statusCode, defaultMessage);
            }
        }
    } catch (IOException e) {
        throw wrap(e);
    } finally {
        HttpClientUtils.closeQuietly(response);
    }
}

From source file:org.jboss.as.test.clustering.cluster.singleton.SingletonPolicyServiceTestCase.java

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

    // Needed to be able to inject ArquillianResource
    stop(CONTAINER_2);/*from   w  w  w.  j  ava2  s.co  m*/

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServicePolicyActivator.SERVICE_NAME, NODE_1)));
        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);
        }

        start(CONTAINER_2);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServicePolicyActivator.SERVICE_NAME, NODE_1)));
        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);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServicePolicyActivator.SERVICE_NAME, NODE_1)));
        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);
        }

        stop(CONTAINER_2);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServicePolicyActivator.SERVICE_NAME, NODE_1)));
        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);
        }

        start(CONTAINER_2);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServicePolicyActivator.SERVICE_NAME, NODE_1)));
        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);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServicePolicyActivator.SERVICE_NAME, NODE_1)));
        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);
        }

        stop(CONTAINER_1);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServicePolicyActivator.SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_1);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServicePolicyActivator.SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServicePolicyActivator.SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:org.eclipse.rdf4j.http.client.SharedHttpClientSessionManager.java

@Override
public void shutDown() {
    try {/* w ww.  j  av a  2  s. com*/
        CloseableHttpClient toCloseDependentClient = dependentClient;
        dependentClient = null;
        if (toCloseDependentClient != null) {
            HttpClientUtils.closeQuietly(toCloseDependentClient);
        }
    } finally {
        try {
            executor.shutdown();
            executor.awaitTermination(10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // Preserve the interrupt status so others can check it as necessary
            Thread.currentThread().interrupt();
        } finally {
            if (!executor.isTerminated()) {
                executor.shutdownNow();
            }
        }
    }
}

From source file:org.jboss.as.test.integration.jsf.doctype.DoctypeDeclTestCase.java

private String register(String name, int expectedStatusCode) throws Exception {
    DefaultHttpClient client = new DefaultHttpClient();

    try {/*from w  w  w  .  j  a  va2 s . c  om*/
        // Create and execute a GET request
        String jsfViewState = null;
        String requestUrl = url.toString() + "register.jsf";
        HttpGet getRequest = new HttpGet(requestUrl);
        HttpResponse response = client.execute(getRequest);
        try {
            // Get the JSF view state
            String responseString = IOUtils.toString(response.getEntity().getContent(), "UTF-8");
            Matcher jsfViewMatcher = viewStatePattern.matcher(responseString);
            if (jsfViewMatcher.find()) {
                jsfViewState = jsfViewMatcher.group(1);
            }
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        // Create and execute a POST request with the given name
        HttpPost post = new HttpPost(requestUrl);
        List<NameValuePair> list = new ArrayList<NameValuePair>();
        list.add(new BasicNameValuePair("javax.faces.ViewState", jsfViewState));
        list.add(new BasicNameValuePair("register", "register"));
        list.add(new BasicNameValuePair("register:inputName", name));
        list.add(new BasicNameValuePair("register:registerButton", "Register"));
        post.setEntity(new StringEntity(URLEncodedUtils.format(list, "UTF-8"),
                ContentType.APPLICATION_FORM_URLENCODED));
        response = client.execute(post);

        try {
            assertEquals(expectedStatusCode, response.getStatusLine().getStatusCode());
            return IOUtils.toString(response.getEntity().getContent(), "UTF-8");
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    } finally {
        HttpClientUtils.closeQuietly(client);
    }
}

From source file:org.mobicents.servlet.restcomm.http.client.Downloader.java

public HttpResponseDescriptor fetch(final HttpRequestDescriptor descriptor)
        throws IllegalArgumentException, IOException, URISyntaxException, XMLStreamException {
    int code = -1;
    HttpRequest request = null;//from   w  w  w .jav a  2s  . c o  m
    CloseableHttpResponse response = null;
    HttpRequestDescriptor temp = descriptor;
    CloseableHttpClient client = null;
    HttpResponseDescriptor responseDescriptor = null;
    try {
        do {
            client = (CloseableHttpClient) CustomHttpClientBuilder
                    .build(RestcommConfiguration.getInstance().getMain());
            //            client.getParams().setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY);
            //            client.getParams().setParameter("http.protocol.content-charset", "UTF-8");
            request = request(temp);
            request.setHeader("http.protocol.content-charset", "UTF-8");

            response = client.execute((HttpUriRequest) request);
            code = response.getStatusLine().getStatusCode();
            if (isRedirect(code)) {
                final Header header = response.getFirstHeader(HttpHeaders.LOCATION);
                if (header != null) {
                    final String location = header.getValue();
                    final URI uri = URI.create(location);
                    temp = new HttpRequestDescriptor(uri, temp.getMethod(), temp.getParameters());
                    continue;
                } else {
                    break;
                }
            }
            //                HttpResponseDescriptor httpResponseDescriptor = response(request, response);
            responseDescriptor = validateXML(response(request, response));
        } while (isRedirect(code));
        if (isHttpError(code)) {
            String requestUrl = request.getRequestLine().getUri();
            String errorReason = response.getStatusLine().getReasonPhrase();
            String httpErrorMessage = String.format(
                    "Error while fetching http resource: %s \n Http error code: %d \n Http error message: %s",
                    requestUrl, code, errorReason);
            logger.warning(httpErrorMessage);
        }
    } catch (IllegalArgumentException | URISyntaxException | IOException e) {
        logger.error("Exception during HTTP request execution: " + e.getCause());
        HttpClientUtils.closeQuietly(client);
        client = null;
    } finally {
        response.close();
        HttpClientUtils.closeQuietly(client);
        client = null;
    }
    return responseDescriptor;
}

From source file:org.sonatype.nexus.kenai.internal.KenaiRealm.java

private boolean authenticateViaUrl(final UsernamePasswordToken usernamePasswordToken) {
    final HttpClient client = httpClientFactory.create();

    try {/* ww  w.jav a  2s . co  m*/
        final String url = configuration().getBaseUrl() + "api/login/authenticate.json";
        final List<NameValuePair> nameValuePairs = Lists.newArrayListWithCapacity(2);
        nameValuePairs.add(new BasicNameValuePair("username", usernamePasswordToken.getUsername()));
        nameValuePairs.add(new BasicNameValuePair("password", new String(usernamePasswordToken.getPassword())));
        final HttpPost post = new HttpPost(url);
        post.setEntity(new UrlEncodedFormEntity(nameValuePairs, Consts.UTF_8));
        final HttpResponse response = client.execute(post);

        try {
            logger.debug("Kenai Realm user \"{}\" validated against URL={} as {}",
                    usernamePasswordToken.getUsername(), url, response.getStatusLine());
            final boolean success = response.getStatusLine().getStatusCode() >= 200
                    && response.getStatusLine().getStatusCode() <= 299;
            return success;
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    } catch (IOException e) {
        logger.info("Kenai Realm was unable to perform authentication", e);
        return false;
    }
}

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

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

    // Needed to be able to inject ArquillianResource
    stop(CONTAINER_2);/*from ww w. ja v  a2  s .  c  o  m*/

    try (CloseableHttpClient client = TestHttpClientUtils.promiscuousCookieHttpClient()) {
        HttpResponse response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_1)));
        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);
        }

        response = client.execute(
                new HttpGet(NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.QUORUM_SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(NodeServiceServlet.NODE_HEADER));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_2);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.QUORUM_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.QUORUM_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        stop(CONTAINER_2);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_1)));
        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);
        }

        response = client.execute(
                new HttpGet(NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.QUORUM_SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(NodeServiceServlet.NODE_HEADER));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_2);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.QUORUM_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.QUORUM_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        stop(CONTAINER_1);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(
                new HttpGet(NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.QUORUM_SERVICE_NAME)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertFalse(response.containsHeader(NodeServiceServlet.NODE_HEADER));
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        start(CONTAINER_1);

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL1, NodeServiceActivator.QUORUM_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.DEFAULT_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }

        response = client.execute(new HttpGet(
                NodeServiceServlet.createURI(baseURL2, NodeServiceActivator.QUORUM_SERVICE_NAME, NODE_2)));
        try {
            Assert.assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode());
            Assert.assertTrue(response.containsHeader(NodeServiceServlet.NODE_HEADER));
            Assert.assertEquals(NODE_2, response.getFirstHeader(NodeServiceServlet.NODE_HEADER).getValue());
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    }
}

From source file:org.sonatype.nexus.examples.url.UrlRealm.java

private boolean authenticateViaUrl(final UsernamePasswordToken usernamePasswordToken) {
    final DefaultRemoteStorageContext ctx = new DefaultRemoteStorageContext(
            applicationConfiguration.getGlobalRemoteStorageContext());
    ctx.setRemoteAuthenticationSettings(new UsernamePasswordRemoteAuthenticationSettings(
            usernamePasswordToken.getUsername(), new String(usernamePasswordToken.getPassword())));
    final HttpClient client = hc4Provider.createHttpClient(ctx);
    try {//from  www  .j  ava2  s  .  com
        final HttpResponse response = client.execute(new HttpGet(baseUrl));

        try {
            logger.debug("URL Realm user \"{}\" validated against URL={} as {}",
                    usernamePasswordToken.getUsername(), baseUrl, response.getStatusLine());
            final boolean success = response.getStatusLine().getStatusCode() >= 200
                    && response.getStatusLine().getStatusCode() <= 299;
            return success;
        } finally {
            HttpClientUtils.closeQuietly(response);
        }
    } catch (IOException e) {
        logger.info("URL Realm was unable to perform authentication", e);
        return false;
    }
}