Example usage for org.apache.http.impl.nio.client HttpAsyncClientBuilder setDefaultCredentialsProvider

List of usage examples for org.apache.http.impl.nio.client HttpAsyncClientBuilder setDefaultCredentialsProvider

Introduction

In this page you can find the example usage for org.apache.http.impl.nio.client HttpAsyncClientBuilder setDefaultCredentialsProvider.

Prototype

public final HttpAsyncClientBuilder setDefaultCredentialsProvider(
        final CredentialsProvider credentialsProvider) 

Source Link

Document

Assigns default CredentialsProvider instance which will be used for request execution if not explicitly set in the client execution context.

Usage

From source file:org.talend.components.elasticsearch.runtime_2_4.ElasticsearchConnection.java

public static RestClient createClient(ElasticsearchDatastoreProperties datastore) throws MalformedURLException {
    String urlStr = datastore.nodes.getValue();
    String[] urls = urlStr.split(",");
    HttpHost[] hosts = new HttpHost[urls.length];
    int i = 0;/*from w  w  w.  ja  v  a2s  .co  m*/
    for (String address : urls) {
        URL url = new URL("http://" + address);
        hosts[i] = new HttpHost(url.getHost(), url.getPort(), url.getProtocol());
        i++;
    }
    RestClientBuilder restClientBuilder = RestClient.builder(hosts);
    if (datastore.auth.useAuth.getValue()) {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(
                datastore.auth.userId.getValue(), datastore.auth.password.getValue()));
        restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {

            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                return httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            }
        });
    }
    return restClientBuilder.build();
}

From source file:io.wcm.caravan.commons.httpasyncclient.impl.HttpAsyncClientItem.java

private static CloseableHttpAsyncClient buildHttpAsyncClient(HttpClientConfig config,
        PoolingNHttpClientConnectionManager connectionManager, CredentialsProvider credentialsProvider) {

    // prepare HTTPClient builder
    HttpAsyncClientBuilder httpClientAsyncBuilder = HttpAsyncClientBuilder.create()
            .setConnectionManager(connectionManager);

    // timeout settings
    httpClientAsyncBuilder.setDefaultRequestConfig(RequestConfig.custom()
            .setConnectTimeout(config.getConnectTimeout()).setSocketTimeout(config.getSocketTimeout()).build());

    httpClientAsyncBuilder.setDefaultCredentialsProvider(credentialsProvider);

    // optional proxy support
    if (StringUtils.isNotEmpty(config.getProxyHost())) {
        httpClientAsyncBuilder.setProxy(new HttpHost(config.getProxyHost(), config.getProxyPort()));

        // optional proxy authentication
        if (StringUtils.isNotEmpty(config.getProxyUser())) {
            httpClientAsyncBuilder.setProxyAuthenticationStrategy(new ProxyAuthenticationStrategy());
        }//w  w  w.  j  av a 2 s .co m
    }

    return httpClientAsyncBuilder.build();
}

From source file:org.elasticsearch.client.RestClientSingleHostIntegTests.java

private static RestClient createRestClient(final boolean useAuth, final boolean usePreemptiveAuth) {
    // provide the username/password for every request
    final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("user", "pass"));

    final RestClientBuilder restClientBuilder = RestClient
            .builder(new HttpHost(httpServer.getAddress().getHostString(), httpServer.getAddress().getPort()))
            .setDefaultHeaders(defaultHeaders);
    if (pathPrefix.length() > 0) {
        // sometimes cut off the leading slash
        restClientBuilder.setPathPrefix(randomBoolean() ? pathPrefix.substring(1) : pathPrefix);
    }//from   w w w  .j a v  a2s.c om

    if (useAuth) {
        restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(final HttpAsyncClientBuilder httpClientBuilder) {
                if (usePreemptiveAuth == false) {
                    // disable preemptive auth by ignoring any authcache
                    httpClientBuilder.disableAuthCaching();
                }

                return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            }
        });
    }

    return restClientBuilder.build();
}

From source file:org.janusgraph.diskstorage.es.rest.util.BasicAuthHttpClientConfigCallback.java

@Override
public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
    httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
    return httpClientBuilder;
}

From source file:io.getlime.push.service.fcm.FcmClient.java

/**
 * Set information about proxy./*from w w w . j  a va  2 s  .  c  om*/
 * @param host Proxy host URL.
 * @param port Proxy port.
 * @param username Proxy username, use 'null' for proxy without authentication.
 * @param password Proxy user password, ignored in case username is 'null'
 */
public void setProxy(String host, int port, String username, String password) {

    HttpAsyncClientBuilder clientBuilder = HttpAsyncClientBuilder.create();
    clientBuilder.useSystemProperties();
    clientBuilder.setProxy(new HttpHost(host, port));

    if (username != null) {
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        UsernamePasswordCredentials user = new UsernamePasswordCredentials(username, password);
        credsProvider.setCredentials(new AuthScope(host, port), user);
        clientBuilder.setDefaultCredentialsProvider(credsProvider);
        clientBuilder.setProxyAuthenticationStrategy(new ProxyAuthenticationStrategy());
    }

    CloseableHttpAsyncClient client = clientBuilder.build();

    HttpComponentsAsyncClientHttpRequestFactory factory = new HttpComponentsAsyncClientHttpRequestFactory();
    factory.setAsyncClient(client);

    restTemplate.setAsyncRequestFactory(factory);
}

From source file:org.jenkinsci.plugins.relution_publisher.net.RequestManager.java

private CloseableHttpAsyncClient createHttpClient() {

    final RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
    requestConfigBuilder.setConnectionRequestTimeout(TIMEOUT_CONNECTION_REQUEST);
    requestConfigBuilder.setConnectTimeout(TIMEOUT_CONNECT);
    requestConfigBuilder.setSocketTimeout(TIMEOUT_SOCKET);

    if (this.mProxyHost != null) {
        requestConfigBuilder.setProxy(this.mProxyHost);
    }/* ww  w .jav  a 2  s.  c  om*/

    final HttpAsyncClientBuilder clientBuilder = HttpAsyncClients.custom();

    final RequestConfig requestConfig = requestConfigBuilder.build();
    clientBuilder.setDefaultRequestConfig(requestConfig);

    if (this.mProxyHost != null && this.mCredentials != null) {
        final AuthScope authScope = new AuthScope(this.mProxyHost);
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(authScope, this.mCredentials);
        clientBuilder.setDefaultCredentialsProvider(credentialsProvider);
    }

    return clientBuilder.build();
}

From source file:com.guardtime.ksi.service.client.http.apache.ApacheHttpClient.java

/**
 * Creates default proxy route planner//ww  w. j a v  a2s. co  m
 *
 * @param settings
 *         - settings to use
 * @param httpClientBuilder
 *         - http client builder
 * @return instance of {@link DefaultProxyRoutePlanner}
 */
private DefaultProxyRoutePlanner createProxyRoutePlanner(AbstractHttpClientSettings settings,
        HttpAsyncClientBuilder httpClientBuilder) {
    HttpHost proxy = new HttpHost(settings.getProxyUrl().getHost(), settings.getProxyUrl().getPort());
    if (settings.getProxyUser() != null) {
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        String proxyUser = settings.getProxyUser();
        String proxyPassword = settings.getProxyPassword();
        UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(proxyUser, proxyPassword);
        credentialsProvider.setCredentials(new AuthScope(proxy), credentials);
        httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
    }
    return new DefaultProxyRoutePlanner(proxy);
}

From source file:org.fuin.esc.eshttp.ESHttpEventStore.java

@Override
public void open() {
    if (open) {//from   ww w  .  j  av a 2 s. com
        // Ignore
        return;
    }
    final HttpAsyncClientBuilder builder = HttpAsyncClients.custom().setThreadFactory(threadFactory);
    if (credentialsProvider != null) {
        builder.setDefaultCredentialsProvider(credentialsProvider);
    }
    httpclient = builder.build();
    httpclient.start();
    this.open = true;
}

From source file:org.elasticsearch.client.documentation.RestClientDocumentation.java

@SuppressWarnings("unused")
public void testCommonConfiguration() throws Exception {
    {/*from  w ww .  j a v a  2  s  .  c  om*/
        //tag::rest-client-config-timeouts
        RestClientBuilder builder = RestClient.builder(new HttpHost("localhost", 9200))
                .setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
                    @Override
                    public RequestConfig.Builder customizeRequestConfig(
                            RequestConfig.Builder requestConfigBuilder) {
                        return requestConfigBuilder.setConnectTimeout(5000).setSocketTimeout(60000);
                    }
                }).setMaxRetryTimeoutMillis(60000);
        //end::rest-client-config-timeouts
    }
    {
        //tag::rest-client-config-threads
        RestClientBuilder builder = RestClient.builder(new HttpHost("localhost", 9200))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(
                            HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setDefaultIOReactorConfig(
                                IOReactorConfig.custom().setIoThreadCount(1).build());
                    }
                });
        //end::rest-client-config-threads
    }
    {
        //tag::rest-client-config-basic-auth
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("user", "password"));

        RestClientBuilder builder = RestClient.builder(new HttpHost("localhost", 9200))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(
                            HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                    }
                });
        //end::rest-client-config-basic-auth
    }
    {
        //tag::rest-client-config-disable-preemptive-auth
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("user", "password"));

        RestClientBuilder builder = RestClient.builder(new HttpHost("localhost", 9200))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(
                            HttpAsyncClientBuilder httpClientBuilder) {
                        httpClientBuilder.disableAuthCaching(); // <1>
                        return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                    }
                });
        //end::rest-client-config-disable-preemptive-auth
    }
    {
        Path keyStorePath = Paths.get("");
        String keyStorePass = "";
        //tag::rest-client-config-encrypted-communication
        KeyStore truststore = KeyStore.getInstance("jks");
        try (InputStream is = Files.newInputStream(keyStorePath)) {
            truststore.load(is, keyStorePass.toCharArray());
        }
        SSLContextBuilder sslBuilder = SSLContexts.custom().loadTrustMaterial(truststore, null);
        final SSLContext sslContext = sslBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("localhost", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(
                            HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext);
                    }
                });
        //end::rest-client-config-encrypted-communication
    }
}

From source file:com.liferay.petra.json.web.service.client.BaseJSONWebServiceClientImpl.java

public void afterPropertiesSet() throws IOReactorException {
    HttpAsyncClientBuilder httpAsyncClientBuilder = HttpAsyncClients.custom();

    httpAsyncClientBuilder = httpAsyncClientBuilder.useSystemProperties();

    NHttpClientConnectionManager nHttpClientConnectionManager = getPoolingNHttpClientConnectionManager();

    httpAsyncClientBuilder.setConnectionManager(nHttpClientConnectionManager);

    httpAsyncClientBuilder.setDefaultCredentialsProvider(_getCredentialsProvider());

    setProxyHost(httpAsyncClientBuilder);

    try {//from  w w w  .j  a  va2 s  . com
        _closeableHttpAsyncClient = httpAsyncClientBuilder.build();

        _closeableHttpAsyncClient.start();

        _idleConnectionMonitorThread = new IdleConnectionMonitorThread(nHttpClientConnectionManager);

        _idleConnectionMonitorThread.start();

        if (_logger.isDebugEnabled()) {
            StringBuilder sb = new StringBuilder();

            sb.append("Configured client for ");
            sb.append(_protocol);
            sb.append("://");
            sb.append(_hostName);
            sb.append(":");
            sb.append(_hostPort);

            _logger.debug(sb.toString());
        }
    } catch (Exception e) {
        _logger.error("Unable to configure client", e);
    }
}