Example usage for org.apache.http.config ConnectionConfig custom

List of usage examples for org.apache.http.config ConnectionConfig custom

Introduction

In this page you can find the example usage for org.apache.http.config ConnectionConfig custom.

Prototype

public static Builder custom() 

Source Link

Usage

From source file:com.helger.httpclient.HttpClientFactory.java

/**
 * @return The connection builder used by the
 *         {@link PoolingHttpClientConnectionManager} to create the default
 *         connection configuration.//from ww w  .j  a  v a  2 s .co m
 */
@Nonnull
public ConnectionConfig.Builder createConnectionConfigBuilder() {
    return ConnectionConfig.custom().setMalformedInputAction(CodingErrorAction.IGNORE)
            .setUnmappableInputAction(CodingErrorAction.IGNORE).setCharset(StandardCharsets.UTF_8);
}

From source file:org.iipg.hurricane.jmx.client.JMXClientBuilder.java

private ConnectionConfig createConnectionConfig() {
    return ConnectionConfig.custom().setBufferSize(socketBufferSize).setCharset(contentCharset).build();
}

From source file:com.baidubce.http.BceHttpClient.java

/**
 * Create http client based on connection manager.
 *
 * @param connectionManager The connection manager setting http client.
 * @return Http client based on connection manager.
 *//*from  w w  w.  java  2  s.  co  m*/
private CloseableHttpClient createHttpClient(HttpClientConnectionManager connectionManager) {
    HttpClientBuilder builder = HttpClients.custom().setConnectionManager(connectionManager)
            .disableAutomaticRetries();

    int socketBufferSizeInBytes = this.config.getSocketBufferSizeInBytes();
    if (socketBufferSizeInBytes > 0) {
        builder.setDefaultConnectionConfig(
                ConnectionConfig.custom().setBufferSize(socketBufferSizeInBytes).build());
    }

    return builder.build();
}

From source file:com.baidubce.http.BceHttpClient.java

/**
 * Create asynchronous http client based on connection manager.
 *
 * @param connectionManager Asynchronous http client connection manager.
 * @return Asynchronous http client based on connection manager.
 *//*from   ww  w. j a  v  a 2 s. c  o  m*/
protected CloseableHttpAsyncClient createHttpAsyncClient(NHttpClientConnectionManager connectionManager) {
    HttpAsyncClientBuilder builder = HttpAsyncClients.custom().setConnectionManager(connectionManager);

    int socketBufferSizeInBytes = this.config.getSocketBufferSizeInBytes();
    if (socketBufferSizeInBytes > 0) {
        builder.setDefaultConnectionConfig(
                ConnectionConfig.custom().setBufferSize(socketBufferSizeInBytes).build());
    }
    return builder.build();
}

From source file:prodoc.DriverRemote.java

static synchronized private PoolingHttpClientConnectionManager GenPool() {
    if (cm == null) {
        cm = new PoolingHttpClientConnectionManager();
        cm.setMaxTotal(100);//from w ww.  ja v a  2s .  co m
        ConnectionConfig connectionConfig = ConnectionConfig.custom().setCharset(Consts.UTF_8).build();
        cm.setDefaultConnectionConfig(connectionConfig);
    }
    return (cm);
}

From source file:com.wudaosoft.net.httpclient.Request.java

protected void init() throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException,
        CertificateException, IOException {

    Args.notNull(hostConfig, "Host config");

    SSLConnectionSocketFactory sslConnectionSocketFactory = null;

    if (sslcontext == null) {

        if (hostConfig.getCA() != null) {
            // Trust root CA and all self-signed certs
            SSLContext sslcontext1 = SSLContexts.custom().loadTrustMaterial(hostConfig.getCA(),
                    hostConfig.getCAPassword(), TrustSelfSignedStrategy.INSTANCE).build();

            // Allow TLSv1 protocol only
            sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslcontext1, new String[] { "TLSv1" },
                    null, SSLConnectionSocketFactory.getDefaultHostnameVerifier());
        } else {//from  w  ww .  j  a v  a 2s  .  c o  m

            if (isTrustAll) {

                SSLContext sslcontext1 = SSLContext.getInstance("TLS");

                TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
                    public X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }

                    @Override
                    public void checkClientTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
                            throws CertificateException {

                    }

                    @Override
                    public void checkServerTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
                            throws CertificateException {
                    }

                } };

                sslcontext1.init(null, trustAllCerts, null);

                sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslcontext1,
                        NoopHostnameVerifier.INSTANCE);
            } else {
                sslConnectionSocketFactory = SSLConnectionSocketFactory.getSocketFactory();
            }
        }
    } else {

        sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
    }

    if (keepAliveStrategy == null) {
        keepAliveStrategy = new ConnectionKeepAliveStrategy() {

            public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
                // Honor 'keep-alive' header
                HeaderElementIterator it = new BasicHeaderElementIterator(
                        response.headerIterator(HTTP.CONN_KEEP_ALIVE));
                while (it.hasNext()) {
                    HeaderElement he = it.nextElement();
                    String param = he.getName();
                    String value = he.getValue();
                    if (value != null && param.equalsIgnoreCase("timeout")) {
                        try {
                            return Long.parseLong(value) * 1000;
                        } catch (NumberFormatException ignore) {
                        }
                    }
                }
                // HttpHost target = (HttpHost)
                // context.getAttribute(HttpClientContext.HTTP_TARGET_HOST);
                // if
                // ("xxxxx".equalsIgnoreCase(target.getHostName()))
                // {
                // // Keep alive for 5 seconds only
                // return 3 * 1000;
                // } else {
                // // otherwise keep alive for 30 seconds
                // return 30 * 1000;
                // }

                return 30 * 1000;
            }

        };
    }

    if (retryHandler == null) {
        retryHandler = new HttpRequestRetryHandler() {

            public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
                if (executionCount >= 3) {
                    // Do not retry if over max retry count
                    return false;
                }
                if (exception instanceof InterruptedIOException) {
                    // Timeout
                    return false;
                }
                if (exception instanceof UnknownHostException) {
                    // Unknown host
                    return false;
                }
                if (exception instanceof ConnectTimeoutException) {
                    // Connection refused
                    return false;
                }
                if (exception instanceof SSLException) {
                    // SSL handshake exception
                    return false;
                }
                HttpClientContext clientContext = HttpClientContext.adapt(context);
                HttpRequest request = clientContext.getRequest();
                boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
                if (idempotent) {
                    // Retry if the request is considered idempotent
                    return true;
                }
                return false;
            }
        };
    }

    connManager = new PoolingHttpClientConnectionManager(RegistryBuilder.<ConnectionSocketFactory>create()
            .register("http", PlainConnectionSocketFactory.getSocketFactory())
            .register("https", sslConnectionSocketFactory).build());

    if (hostConfig.getHost() != null) {

        connManager.setMaxTotal(hostConfig.getPoolSize() + 60);

        connManager.setMaxPerRoute(
                new HttpRoute(hostConfig.getHost(), null,
                        !HttpHost.DEFAULT_SCHEME_NAME.equals(hostConfig.getHost().getSchemeName())),
                hostConfig.getPoolSize());

        connManager.setDefaultMaxPerRoute(20);
    } else {
        connManager.setMaxTotal(hostConfig.getPoolSize());
        int hostCount = hostConfig.getHostCount() == 0 ? 10 : hostConfig.getHostCount();
        connManager.setDefaultMaxPerRoute(hostConfig.getPoolSize() / hostCount);
    }

    // connManager.setValidateAfterInactivity(2000);

    // Create socket configuration
    SocketConfig socketConfig = SocketConfig.custom().setTcpNoDelay(true).setSoKeepAlive(isKeepAlive).build();
    connManager.setDefaultSocketConfig(socketConfig);

    // Create connection configuration
    ConnectionConfig connectionConfig = ConnectionConfig.custom()
            .setMalformedInputAction(CodingErrorAction.IGNORE)
            .setUnmappableInputAction(CodingErrorAction.IGNORE)
            .setCharset(hostConfig.getCharset() == null ? Consts.UTF_8 : hostConfig.getCharset()).build();
    connManager.setDefaultConnectionConfig(connectionConfig);

    new IdleConnectionMonitorThread(connManager).start();

    if (requestInterceptor == null) {
        requestInterceptor = new SortHeadersInterceptor(hostConfig);
    }

    if (!hostConfig.isMulticlient()) {
        defaultHttpContext = HttpClientContext.create();
        httpClient = create();
    }
}

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test
public void testProxyConnectAndUpgrade() throws Exception {
    final HttpHost target = new HttpHost("somehost", -1, "https");
    final HttpHost proxy = new HttpHost("someproxy", 8080);
    final InetAddress remote = InetAddress.getByAddress(new byte[] { 10, 0, 0, 1 });
    final InetAddress local = InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 });
    final HttpRoute route = new HttpRoute(target, local, proxy, true);

    final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1,
            TimeUnit.MILLISECONDS);
    entry.markRouteComplete();//  w w w . ja  va 2s.  c o m
    Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE);
    Mockito.when(conn.isOpen()).thenReturn(true);
    Mockito.when(future.isCancelled()).thenReturn(false);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS);
    Assert.assertNotNull(conn1);

    final ConnectionSocketFactory plainsf = Mockito.mock(ConnectionSocketFactory.class);
    final LayeredConnectionSocketFactory sslsf = Mockito.mock(LayeredConnectionSocketFactory.class);
    final Socket socket = Mockito.mock(Socket.class);
    final HttpClientContext context = HttpClientContext.create();
    final SocketConfig sconfig = SocketConfig.custom().build();
    final ConnectionConfig cconfig = ConnectionConfig.custom().build();

    mgr.setDefaultSocketConfig(sconfig);
    mgr.setDefaultConnectionConfig(cconfig);

    Mockito.when(dnsResolver.resolve("someproxy")).thenReturn(new InetAddress[] { remote });
    Mockito.when(schemePortResolver.resolve(proxy)).thenReturn(8080);
    Mockito.when(schemePortResolver.resolve(target)).thenReturn(8443);
    Mockito.when(socketFactoryRegistry.lookup("http")).thenReturn(plainsf);
    Mockito.when(socketFactoryRegistry.lookup("https")).thenReturn(sslsf);
    Mockito.when(plainsf.createSocket(Mockito.<HttpContext>any())).thenReturn(socket);
    Mockito.when(plainsf.connectSocket(Mockito.anyInt(), Mockito.eq(socket), Mockito.<HttpHost>any(),
            Mockito.<InetSocketAddress>any(), Mockito.<InetSocketAddress>any(), Mockito.<HttpContext>any()))
            .thenReturn(socket);

    mgr.connect(conn1, route, 123, context);

    Mockito.verify(dnsResolver, Mockito.times(1)).resolve("someproxy");
    Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(proxy);
    Mockito.verify(plainsf, Mockito.times(1)).createSocket(context);
    Mockito.verify(plainsf, Mockito.times(1)).connectSocket(123, socket, proxy,
            new InetSocketAddress(remote, 8080), new InetSocketAddress(local, 0), context);

    Mockito.when(conn.getSocket()).thenReturn(socket);

    mgr.upgrade(conn1, route, context);

    Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(target);
    Mockito.verify(sslsf, Mockito.times(1)).createLayeredSocket(socket, "somehost", 8443, context);

    mgr.routeComplete(conn1, route, context);
}

From source file:org.apache.http.impl.nio.conn.TestPoolingHttpClientAsyncConnectionManager.java

@Test
public void testInternalConnFactoryCreateViaProxy() throws Exception {
    final ConfigData configData = new ConfigData();
    final InternalConnectionFactory internalConnFactory = new InternalConnectionFactory(configData,
            connFactory);//w  w  w  .  j a  v  a  2 s  .  c o m

    final HttpHost target = new HttpHost("somehost", 80);
    final HttpHost proxy = new HttpHost("someproxy", 8888);
    final HttpRoute route = new HttpRoute(target, null, proxy, false);

    final ConnectionConfig config = ConnectionConfig.custom().build();
    configData.setConnectionConfig(proxy, config);

    internalConnFactory.create(route, iosession);

    Mockito.verify(connFactory).create(iosession, config);
}

From source file:org.apache.http.impl.nio.conn.TestPoolingHttpClientAsyncConnectionManager.java

@Test
public void testInternalConnFactoryCreateDirect() throws Exception {
    final ConfigData configData = new ConfigData();
    final InternalConnectionFactory internalConnFactory = new InternalConnectionFactory(configData,
            connFactory);/*from  w ww  .  j  a  v  a  2  s .c  o m*/

    final HttpHost target = new HttpHost("somehost", 80);
    final HttpRoute route = new HttpRoute(target);

    final ConnectionConfig config = ConnectionConfig.custom().build();
    configData.setConnectionConfig(target, config);

    internalConnFactory.create(route, iosession);

    Mockito.verify(connFactory).create(iosession, config);
}

From source file:org.apache.http.impl.nio.conn.TestPoolingHttpClientAsyncConnectionManager.java

@Test
public void testInternalConnFactoryCreateDefaultConfig() throws Exception {
    final ConfigData configData = new ConfigData();
    final InternalConnectionFactory internalConnFactory = new InternalConnectionFactory(configData,
            connFactory);//w  w w  . j  a  v  a 2s.  c o  m

    final HttpHost target = new HttpHost("somehost", 80);
    final HttpRoute route = new HttpRoute(target);

    final ConnectionConfig config = ConnectionConfig.custom().build();
    configData.setDefaultConnectionConfig(config);

    internalConnFactory.create(route, iosession);

    Mockito.verify(connFactory).create(iosession, config);
}