Example usage for org.apache.http.client AuthCache put

List of usage examples for org.apache.http.client AuthCache put

Introduction

In this page you can find the example usage for org.apache.http.client AuthCache put.

Prototype

void put(HttpHost host, AuthScheme authScheme);

Source Link

Usage

From source file:org.hyperledger.fabric_ca.sdk.HFCAClient.java

/**
 * Http Post Request./*from  w  w w  .j a  v a 2  s. co m*/
 *
 * @param url         Target URL to POST to.
 * @param body        Body to be sent with the post.
 * @param credentials Credentials to use for basic auth.
 * @return Body of post returned.
 * @throws Exception
 */
String httpPost(String url, String body, UsernamePasswordCredentials credentials) throws Exception {
    logger.debug(format("httpPost %s, body:%s", url, body));

    final HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    CredentialsProvider provider = null;
    if (credentials != null) {
        provider = new BasicCredentialsProvider();

        provider.setCredentials(AuthScope.ANY, credentials);
        httpClientBuilder.setDefaultCredentialsProvider(provider);
    }

    if (registry != null) {

        httpClientBuilder.setConnectionManager(new PoolingHttpClientConnectionManager(registry));

    }

    HttpClient client = httpClientBuilder.build();

    HttpPost httpPost = new HttpPost(url);
    httpPost.setConfig(getRequestConfig());

    AuthCache authCache = new BasicAuthCache();

    HttpHost targetHost = new HttpHost(httpPost.getURI().getHost(), httpPost.getURI().getPort());

    if (credentials != null) {
        authCache.put(targetHost, new

        BasicScheme());

    }

    final HttpClientContext context = HttpClientContext.create();

    if (null != provider) {
        context.setCredentialsProvider(provider);
    }

    if (credentials != null) {
        context.setAuthCache(authCache);
    }

    httpPost.setEntity(new StringEntity(body));
    if (credentials != null) {
        httpPost.addHeader(new

        BasicScheme().

                authenticate(credentials, httpPost, context));
    }

    HttpResponse response = client.execute(httpPost, context);
    int status = response.getStatusLine().getStatusCode();

    HttpEntity entity = response.getEntity();
    logger.trace(format("httpPost %s  sending...", url));
    String responseBody = entity != null ? EntityUtils.toString(entity) : null;
    logger.trace(format("httpPost %s  responseBody %s", url, responseBody));

    if (status >= 400) {

        Exception e = new Exception(format(
                "POST request to %s  with request body: %s, " + "failed with status code: %d. Response: %s",
                url, body, status, responseBody));
        logger.error(e.getMessage());
        throw e;
    }
    logger.debug(format("httpPost Status: %d returning: %s ", status, responseBody));

    return responseBody;
}

From source file:com.adobe.aem.demomachine.communities.Loader.java

private static void doDelete(String hostname, String port, String url, String user, String password) {

    try {//from   w  w  w.  j a  va  2  s  .c  o  m

        HttpHost target = new HttpHost(hostname, Integer.parseInt(port), "http");
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(new AuthScope(target.getHostName(), target.getPort()),
                new UsernamePasswordCredentials(user, password));
        CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultCredentialsProvider(credsProvider)
                .build();

        try {

            // Adding the Basic Authentication data to the context for this command
            AuthCache authCache = new BasicAuthCache();
            BasicScheme basicAuth = new BasicScheme();
            authCache.put(target, basicAuth);
            HttpClientContext localContext = HttpClientContext.create();
            localContext.setAuthCache(authCache);

            // Composing the root URL for all subsequent requests
            String postUrl = "http://" + hostname + ":" + port + url;
            logger.debug("Deleting request as " + user + " to " + postUrl);
            HttpDelete request = new HttpDelete(postUrl);
            httpClient.execute(target, request, localContext);

        } catch (Exception ex) {
            logger.error(ex.getMessage());
        } finally {
            httpClient.close();
        }

    } catch (IOException e) {
        logger.error(e.getMessage());
    }

}

From source file:com.adobe.aem.demomachine.communities.Loader.java

private static String doPost(String hostname, String port, String url, String user, String password) {

    String responseString = null;
    if (hostname == null || port == null || url == null || user == null || password == null) {
        logger.error("Can't POST with requested parameters, one is null");
        return responseString;
    }//w  ww . j av  a  2  s  . co  m

    try {

        HttpHost target = new HttpHost(hostname, Integer.parseInt(port), "http");
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(new AuthScope(target.getHostName(), target.getPort()),
                new UsernamePasswordCredentials(user, password));
        CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultCredentialsProvider(credsProvider)
                .build();

        try {

            // Adding the Basic Authentication data to the context for this command
            AuthCache authCache = new BasicAuthCache();
            BasicScheme basicAuth = new BasicScheme();
            authCache.put(target, basicAuth);
            HttpClientContext localContext = HttpClientContext.create();
            localContext.setAuthCache(authCache);

            // Composing the root URL for all subsequent requests
            String postUrl = "http://" + hostname + ":" + port + url;

            // Preparing a standard POST HTTP command
            HttpPost request = new HttpPost(postUrl);

            // Sending the HTTP POST command
            CloseableHttpResponse response = httpClient.execute(target, request, localContext);
            try {
                int returnCode = response.getStatusLine().getStatusCode();
                responseString = EntityUtils.toString(response.getEntity(), "UTF-8");
                if (returnCode >= 500) {
                    logger.fatal("Server error" + responseString);
                }

            } catch (Exception ex) {
                logger.error(ex.getMessage());
            } finally {
                response.close();
            }

        } catch (Exception ex) {
            logger.error(ex.getMessage());
        } finally {
            httpClient.close();
        }

    } catch (IOException e) {
        logger.error(e.getMessage());
    }
    return responseString;
}

From source file:com.adobe.aem.demomachine.communities.Loader.java

private static String doGet(String hostname, String port, String url, String user, String password,
        List<NameValuePair> params) {

    String rawResponse = null;/*www .j  a  va  2s.c  o  m*/
    try {

        HttpHost target = new HttpHost(hostname, Integer.parseInt(port), "http");
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(new AuthScope(target.getHostName(), target.getPort()),
                new UsernamePasswordCredentials(user, password));
        CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultCredentialsProvider(credsProvider)
                .build();

        try {

            // Adding the Basic Authentication data to the context for this command
            AuthCache authCache = new BasicAuthCache();
            BasicScheme basicAuth = new BasicScheme();
            authCache.put(target, basicAuth);
            HttpClientContext localContext = HttpClientContext.create();
            localContext.setAuthCache(authCache);

            // Composing the root URL for all subsequent requests
            URIBuilder uribuilder = new URIBuilder();
            uribuilder.setScheme("http").setHost(hostname).setPort(Integer.parseInt(port)).setPath(url);

            // Adding the params
            if (params != null)
                for (NameValuePair nvp : params) {
                    uribuilder.setParameter(nvp.getName(), nvp.getValue());
                }

            URI uri = uribuilder.build();
            logger.debug("Getting request at " + uri.toString());
            HttpGet httpget = new HttpGet(uri);
            CloseableHttpResponse response = httpClient.execute(httpget, localContext);
            if (response.getStatusLine().getStatusCode() == 200) {
                try {
                    rawResponse = EntityUtils.toString(response.getEntity(), "UTF-8");
                } catch (Exception ex) {
                    logger.error(ex.getMessage());
                } finally {
                    response.close();
                }
            } else {
                logger.debug("GET return code: " + response.getStatusLine().getStatusCode());
            }
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        } finally {
            httpClient.close();
        }

    } catch (IOException e) {

        e.printStackTrace();
    }

    return rawResponse;

}

From source file:com.adobe.aem.demomachine.communities.Loader.java

private static int doPost(String hostname, String port, String url, String user, String password,
        HttpEntity entity, Map<String, String> elements, String referer) {
    String jsonElement = null;//from   w ww.  j a v  a 2 s. c  o  m

    if (hostname == null || port == null || url == null || user == null || password == null) {
        logger.error("Can't POST with requested parameters, one is null");
        return 500;
    }

    int returnCode = 404;

    try {

        HttpHost target = new HttpHost(hostname, Integer.parseInt(port), "http");
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(new AuthScope(target.getHostName(), target.getPort()),
                new UsernamePasswordCredentials(user, password));
        CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultCredentialsProvider(credsProvider)
                .build();

        try {

            // Adding the Basic Authentication data to the context for this command
            AuthCache authCache = new BasicAuthCache();
            BasicScheme basicAuth = new BasicScheme();
            authCache.put(target, basicAuth);
            HttpClientContext localContext = HttpClientContext.create();
            localContext.setAuthCache(authCache);

            // Composing the root URL for all subsequent requests
            String postUrl = "http://" + hostname + ":" + port + url;
            logger.debug("Posting request as " + user + " to " + postUrl);

            // Preparing a standard POST HTTP command
            HttpPost request = new HttpPost(postUrl);
            request.setEntity(entity);
            if (!entity.getContentType().toString().contains("multipart")) {
                request.addHeader("content-type", "application/x-www-form-urlencoded");
            }
            request.addHeader("Accept", "application/json, text/javascript, */*; q=0.01");
            request.addHeader("Origin", postUrl);
            if (referer != null) {
                request.addHeader("Referer", referer);
            }

            // Sending the HTTP POST command
            CloseableHttpResponse response = httpClient.execute(target, request, localContext);
            try {
                returnCode = response.getStatusLine().getStatusCode();
                String responseString = EntityUtils.toString(response.getEntity(), "UTF-8");
                if (returnCode >= 500) {
                    logger.error("POST return code: " + returnCode);
                    logger.debug(responseString);
                    return returnCode;
                }
                if (returnCode >= 400) {
                    logger.warn("POST return code: " + returnCode);
                    logger.debug(responseString);
                    return returnCode;
                }
                if (elements == null)
                    return returnCode;
                Set<String> keys = elements.keySet();
                if (!isJSONValid(responseString) && keys.size() > 0) {
                    logger.warn(
                            "POST operation didn't return a JSON string, hence cannot extract requested value");
                    return returnCode;
                }
                for (String lookup : keys) {
                    if (lookup != null) {
                        int separatorIndex = lookup.indexOf("/");
                        if (separatorIndex > 0) {

                            // Grabbing element in a nested element
                            Object object = new JSONObject(responseString)
                                    .get(lookup.substring(0, separatorIndex));
                            if (object != null) {

                                if (object instanceof JSONArray) {

                                    JSONArray jsonArray = (JSONArray) object;
                                    if (jsonArray.length() == 1) {
                                        JSONObject jsonObject = jsonArray.getJSONObject(0);
                                        jsonElement = jsonObject
                                                .getString(lookup.substring(1 + separatorIndex));
                                        //logger.debug("JSON value (jsonArray) returned is " + jsonElement);
                                    }

                                } else if (object instanceof JSONObject) {

                                    JSONObject jsonobject = (JSONObject) object;
                                    jsonElement = jsonobject.getString(lookup.substring(1 + separatorIndex));
                                    //logger.debug("JSON value (jsonObject) returned is " + jsonElement);

                                }
                            }

                        } else {
                            // Grabbing element at the top of the JSON response
                            jsonElement = new JSONObject(responseString).getString(lookup);
                            //logger.debug("JSON (top) value returned is " + jsonElement);
                        }
                    }
                    elements.put(lookup, jsonElement);
                }

            } catch (Exception ex) {
                logger.error(ex.getMessage());
            } finally {
                response.close();
            }

        } catch (Exception ex) {
            logger.error(ex.getMessage());
        } finally {
            httpClient.close();
        }

    } catch (IOException e) {
        logger.error(e.getMessage());
    }
    return returnCode;
}