Example usage for org.apache.http.config RegistryBuilder register

Introduction

In this page you can find the example usage for org.apache.http.config RegistryBuilder register.

Prototype

public RegistryBuilder<I> register(String str, I i) 

Source Link

Usage

From source file:com.northernwall.hadrian.Main.java

private void startHttpClient() {
    try {//from w  w  w.  jav a 2  s.c om
        int maxConnections = Integer.parseInt(properties.getProperty("http.maxConnections", "100"));
        int maxPerRoute = Integer.parseInt(properties.getProperty("http.maxPerRoute", "10"));
        int socketTimeout = Integer.parseInt(properties.getProperty("http.socketTimeout", "1000"));
        int connectionTimeout = Integer.parseInt(properties.getProperty("http.connectionTimeout", "1000"));

        RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder
                .<ConnectionSocketFactory>create();
        Registry<ConnectionSocketFactory> registry = registryBuilder
                .register("http", PlainConnectionSocketFactory.INSTANCE).build();

        PoolingHttpClientConnectionManager ccm = new PoolingHttpClientConnectionManager(registry);
        ccm.setMaxTotal(maxConnections);
        ccm.setDefaultMaxPerRoute(maxPerRoute);

        HttpClientBuilder clientBuilder = HttpClients.custom().setConnectionManager(ccm)
                .setDefaultConnectionConfig(ConnectionConfig.custom().setCharset(Consts.UTF_8).build())
                .setDefaultRequestConfig(RequestConfig.custom().setSocketTimeout(socketTimeout)
                        .setConnectTimeout(connectionTimeout).build());
        client = clientBuilder.build();
    } catch (NumberFormatException nfe) {
        throw new IllegalStateException("Error Creating HTTPClient, could not parse property");
    } catch (Exception e) {
        throw new IllegalStateException("Error Creating HTTPClient: ", e);
    }
}

---

From source file:com.liferay.jsonwebserviceclient.JSONWebServiceClientImpl.java

protected Registry<ConnectionSocketFactory> getSocketFactoryRegistry() {
    RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder
            .<ConnectionSocketFactory>create();

    registryBuilder.register("http", new PlainConnectionSocketFactory());
    registryBuilder.register("https", getSSLConnectionSocketFactory());

    return registryBuilder.build();
}

---

From source file:com.joyent.manta.http.MantaConnectionFactory.java

/**
 * Configures a connection manager with all of the setting needed to connect
 * to Manta.//from  ww  w .j a  va 2  s  .  co m
 *
 * @param metricConfig potentially-null configuration for tracking client metrics
 * @return fully configured connection manager
 */
protected HttpClientConnectionManager buildConnectionManager(
        final MantaClientMetricConfiguration metricConfig) {
    final int maxConns = ObjectUtils.firstNonNull(config.getMaximumConnections(),
            DefaultsConfigContext.DEFAULT_MAX_CONNS);

    final ConnectionSocketFactory sslConnectionSocketFactory = new MantaSSLConnectionSocketFactory(this.config);

    final RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create();

    final Registry<ConnectionSocketFactory> socketFactoryRegistry = registryBuilder
            .register("http", PlainConnectionSocketFactory.getSocketFactory())
            .register("https", sslConnectionSocketFactory).build();

    final HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connFactory = buildHttpConnectionFactory();

    final PoolingHttpClientConnectionManager connManager;
    if (metricConfig != null) {
        connManager = new InstrumentedPoolingHttpClientConnectionManager(metricConfig.getRegistry(),
                socketFactoryRegistry, connFactory, null, DNS_RESOLVER, -1, TimeUnit.MILLISECONDS);
    } else {
        connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry, connFactory, DNS_RESOLVER);
    }

    connManager.setDefaultMaxPerRoute(maxConns);
    connManager.setMaxTotal(maxConns);
    connManager.setDefaultSocketConfig(buildSocketConfig());
    connManager.setDefaultConnectionConfig(buildConnectionConfig());

    return connManager;
}

---

From source file:com.helger.pd.client.jdk6.PDClient.java

@Nonnull
protected HttpClientBuilder createClientBuilder() {
    SSLConnectionSocketFactory aSSLSocketFactory = null;
    try {//ww w  .  j  a v  a  2  s. c  o m
        // Set SSL context
        final KeyStore aKeyStore = KeyStoreHelper.loadKeyStore(PDClientConfiguration.getKeyStorePath(),
                PDClientConfiguration.getKeyStorePassword());
        final SSLContext aSSLContext = SSLContexts.custom().loadKeyMaterial(aKeyStore,
                PDClientConfiguration.getKeyStoreKeyPassword(), new PrivateKeyStrategy() {
                    public String chooseAlias(final Map<String, PrivateKeyDetails> aAliases,
                            final Socket aSocket) {
                        final String sAlias = PDClientConfiguration.getKeyStoreKeyAlias();
                        return aAliases.containsKey(sAlias) ? sAlias : null;
                    }
                }).build();
        // Allow TLSv1 protocol only
        aSSLSocketFactory = new SSLConnectionSocketFactory(aSSLContext, new String[] { "TLSv1" }, null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
    } catch (final Throwable t) {
        s_aLogger.error("Failed to initialize keystore for service connection! Can only use http now!", t);
    }

    try {
        final RegistryBuilder<ConnectionSocketFactory> aRB = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory());
        if (aSSLSocketFactory != null)
            aRB.register("https", aSSLSocketFactory);
        final Registry<ConnectionSocketFactory> sfr = aRB.build();

        final PoolingHttpClientConnectionManager aConnMgr = new PoolingHttpClientConnectionManager(sfr);
        aConnMgr.setDefaultMaxPerRoute(100);
        aConnMgr.setMaxTotal(200);
        aConnMgr.setValidateAfterInactivity(1000);
        final ConnectionConfig aConnectionConfig = ConnectionConfig.custom()
                .setMalformedInputAction(CodingErrorAction.IGNORE)
                .setUnmappableInputAction(CodingErrorAction.IGNORE).setCharset(Consts.UTF_8).build();
        aConnMgr.setDefaultConnectionConfig(aConnectionConfig);

        return HttpClientBuilder.create().setConnectionManager(aConnMgr);
    } catch (final Exception ex) {
        throw new InitializationException("Failed to init HTTP client", ex);
    }
}

---

From source file:de.codecentric.boot.admin.zuul.filters.route.SimpleHostRoutingFilter.java

protected PoolingHttpClientConnectionManager newConnectionManager() {
    try {//from  ww w .  j  a va 2  s  . co  m
        final SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, new TrustManager[] { new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
                    throws CertificateException {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
                    throws CertificateException {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        } }, new SecureRandom());

        RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder
                .<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.INSTANCE);
        if (this.sslHostnameValidationEnabled) {
            registryBuilder.register("https", new SSLConnectionSocketFactory(sslContext));
        } else {
            registryBuilder.register("https",
                    new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE));
        }
        final Registry<ConnectionSocketFactory> registry = registryBuilder.build();

        this.connectionManager = new PoolingHttpClientConnectionManager(registry);
        this.connectionManager.setMaxTotal(this.hostProperties.getMaxTotalConnections());
        this.connectionManager.setDefaultMaxPerRoute(this.hostProperties.getMaxPerRouteConnections());
        return this.connectionManager;
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}

---

From source file:com.mirth.connect.connectors.http.DefaultHttpConfiguration.java

@Override
public void configureSocketFactoryRegistry(ConnectorPluginProperties properties,
        RegistryBuilder<ConnectionSocketFactory> registry) throws Exception {
    String[] enabledProtocols = MirthSSLUtil
            .getEnabledHttpsProtocols(configurationController.getHttpsClientProtocols());
    String[] enabledCipherSuites = MirthSSLUtil
            .getEnabledHttpsCipherSuites(configurationController.getHttpsCipherSuites());
    SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(
            SSLContexts.createSystemDefault(), enabledProtocols, enabledCipherSuites,
            NoopHostnameVerifier.INSTANCE);
    registry.register("https", sslConnectionSocketFactory);
}

---

From source file:org.codelibs.fess.crawler.extractor.impl.ApiExtractor.java

@PostConstruct
public void init() {
    if (logger.isDebugEnabled()) {
        logger.debug("Initializing " + ApiExtractor.class.getName());
    }//from   www  . j  a va  2  s  . c om

    // httpclient
    final org.apache.http.client.config.RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
    final HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

    final Integer connectionTimeoutParam = connectionTimeout;
    if (connectionTimeoutParam != null) {
        requestConfigBuilder.setConnectTimeout(connectionTimeoutParam);

    }
    final Integer soTimeoutParam = soTimeout;
    if (soTimeoutParam != null) {
        requestConfigBuilder.setSocketTimeout(soTimeoutParam);
    }

    // AuthSchemeFactory
    final RegistryBuilder<AuthSchemeProvider> authSchemeProviderBuilder = RegistryBuilder.create();
    // @SuppressWarnings("unchecked")
    final Map<String, AuthSchemeProvider> factoryMap = authSchemeProviderMap;
    if (factoryMap != null) {
        for (final Map.Entry<String, AuthSchemeProvider> entry : factoryMap.entrySet()) {
            authSchemeProviderBuilder.register(entry.getKey(), entry.getValue());
        }
    }

    // user agent
    if (StringUtil.isNotBlank(userAgent)) {
        httpClientBuilder.setUserAgent(userAgent);
    }

    // Authentication
    final Authentication[] siteCredentialList = new Authentication[0];
    for (final Authentication authentication : siteCredentialList) {
        final AuthScope authScope = authentication.getAuthScope();
        credentialsProvider.setCredentials(authScope, authentication.getCredentials());
        final AuthScheme authScheme = authentication.getAuthScheme();
        if (authScope.getHost() != null && authScheme != null) {
            final HttpHost targetHost = new HttpHost(authScope.getHost(), authScope.getPort());
            authCache.put(targetHost, authScheme);
        }
    }

    httpClientContext.setAuthCache(authCache);
    httpClientContext.setCredentialsProvider(credentialsProvider);

    // Request Header
    final RequestHeader[] requestHeaders = { new RequestHeader("enctype", "multipart/form-data") };
    for (final RequestHeader requestHeader : requestHeaders) {
        if (requestHeader.isValid()) {
            requestHeaderList.add(new BasicHeader(requestHeader.getName(), requestHeader.getValue()));
        }
    }

    final CloseableHttpClient closeableHttpClient = httpClientBuilder
            .setDefaultRequestConfig(requestConfigBuilder.build()).build();
    if (!httpClientPropertyMap.isEmpty()) {
        final BeanDesc beanDesc = BeanDescFactory.getBeanDesc(closeableHttpClient.getClass());
        for (final Map.Entry<String, Object> entry : httpClientPropertyMap.entrySet()) {
            final String propertyName = entry.getKey();
            if (beanDesc.hasPropertyDesc(propertyName)) {
                final PropertyDesc propertyDesc = beanDesc.getPropertyDesc(propertyName);
                propertyDesc.setValue(closeableHttpClient, entry.getValue());
            } else {
                logger.warn("DefaultHttpClient does not have " + propertyName + ".");
            }
        }
    }

    httpClient = closeableHttpClient;
}

---

From source file:com.liferay.sync.engine.session.Session.java

private HttpClientConnectionManager _getHttpClientConnectionManager(boolean trustSelfSigned) {

    HttpConnectionFactory<HttpRoute, ManagedHttpClientConnection> connectionFactory = new SyncManagedHttpClientConnectionFactory();

    try {//  w  ww .  ja va  2s . c om
        RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create();

        registryBuilder.register("http", new PlainConnectionSocketFactory());

        if (trustSelfSigned) {
            registryBuilder.register("https", _getTrustingSSLSocketFactory());
        } else {
            registryBuilder.register("https", _getDefaultSSLSocketFactory());
        }

        Registry<ConnectionSocketFactory> registry = registryBuilder.build();

        return new PoolingHttpClientConnectionManager(registry, connectionFactory);
    } catch (Exception e) {
        _logger.error(e.getMessage(), e);
    }

    return new PoolingHttpClientConnectionManager(connectionFactory);
}

---

From source file:eu.europa.ec.markt.dss.validation102853.https.CommonDataLoader.java

private RegistryBuilder<ConnectionSocketFactory> setConnectionManagerSchemeHttp(
        RegistryBuilder<ConnectionSocketFactory> socketFactoryRegistryBuilder) {
    return socketFactoryRegistryBuilder.register("http", PlainConnectionSocketFactory.getSocketFactory());
}

---

From source file:com.xebialabs.overthere.winrm.WinRmClient.java

private void configureHttpClient(final HttpClientBuilder httpclient) throws GeneralSecurityException {
    configureTrust(httpclient);/*from w  w  w .  ja va 2 s .c  o m*/
    BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    httpclient.setDefaultCredentialsProvider(credentialsProvider);

    configureAuthentication(credentialsProvider, BASIC, new BasicUserPrincipal(username));

    if (enableKerberos) {
        String spnServiceClass = kerberosUseHttpSpn ? "HTTP" : "WSMAN";
        RegistryBuilder<AuthSchemeProvider> authSchemeRegistryBuilder = RegistryBuilder.create();
        authSchemeRegistryBuilder.register(KERBEROS, new WsmanKerberosSchemeFactory(!kerberosAddPortToSpn,
                spnServiceClass, unmappedAddress, unmappedPort));
        authSchemeRegistryBuilder.register(SPNEGO, new WsmanSPNegoSchemeFactory(!kerberosAddPortToSpn,
                spnServiceClass, unmappedAddress, unmappedPort));
        httpclient.setDefaultAuthSchemeRegistry(authSchemeRegistryBuilder.build());
        configureAuthentication(credentialsProvider, KERBEROS, new KerberosPrincipal(username));
        configureAuthentication(credentialsProvider, SPNEGO, new KerberosPrincipal(username));
    }

    httpclient.setDefaultSocketConfig(SocketConfig.custom().setSoTimeout(soTimeout).build());
    httpclient.setDefaultRequestConfig(
            RequestConfig.custom().setAuthenticationEnabled(true).setConnectTimeout(connectionTimeout).build());
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »