Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create() .register("https", sslsf) .register("http", new PlainConnectionSocketFactory()).build();
private static HttpClient createDefaultHttpClient() { Registry<ConnectionSocketFactory> schemeRegistry = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", SSLConnectionSocketFactory.getSocketFactory()) .build(); PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(schemeRegistry); connectionManager.setMaxTotal(DEFAULT_MAX_TOTAL_CONNECTIONS); connectionManager.setDefaultMaxPerRoute(DEFAULT_MAX_CONNECTIONS_PER_ROUTE); return HttpClientBuilder.create().setConnectionManager(connectionManager).build(); }
@Override public Socket connectSocket( int connectTimeout, Socket socket, HttpHost host, InetSocketAddress remoteAddress, InetSocketAddress localAddress, HttpContext context) throws IOException { String hostName = host.getHostName(); int port = remoteAddress.getPort(); InetSocketAddress unresolvedRemote = InetSocketAddress.createUnresolved(hostName, port); return super.connectSocket(connectTimeout, socket, host, unresolvedRemote, localAddress, context); } }
@Override public Socket createSocket(HttpContext ctx) throws IOException { if (HttpContextUtils.disableSocketProxy(ctx)) { return new Socket(Proxy.NO_PROXY); } return super.createSocket(ctx); } }
private static HttpClient createDefaultHttpClient() { Registry<ConnectionSocketFactory> schemeRegistry = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", SSLConnectionSocketFactory.getSocketFactory()) .build(); PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(schemeRegistry); connectionManager.setMaxTotal(DEFAULT_MAX_TOTAL_CONNECTIONS); connectionManager.setDefaultMaxPerRoute(DEFAULT_MAX_CONNECTIONS_PER_ROUTE); return HttpClientBuilder.create().setConnectionManager(connectionManager).build(); }
.register("http", new PlainConnectionSocketFactory()) .register("https", sslsf) .build();
@Override public Socket createSocket(HttpContext ctx) throws IOException { if (HttpContextUtils.disableSocketProxy(ctx)) { return new Socket(Proxy.NO_PROXY); } return super.createSocket(ctx); } }
@Override public Socket connectSocket( int connectTimeout, Socket socket, HttpHost host, InetSocketAddress remoteAddress, InetSocketAddress localAddress, HttpContext context) throws IOException { String hostName = host.getHostName(); int port = remoteAddress.getPort(); InetSocketAddress unresolvedRemote = InetSocketAddress.createUnresolved(hostName, port); return super.connectSocket(connectTimeout, socket, host, unresolvedRemote, localAddress, context); } }
private org.apache.http.config.Registry<ConnectionSocketFactory> getSchemeRegistry(final URI originalUri, SSLContext sslContext) { RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create(); registryBuilder.register("http", PlainConnectionSocketFactory.getSocketFactory()); if (sslContext != null) { registryBuilder.register("https", new SSLConnectionSocketFactory(sslContext)); } registryBuilder.register("unix", new UnixConnectionSocketFactory(originalUri)); return registryBuilder.build(); }
socketFactoryRegistry = RegistryBuilder .<ConnectionSocketFactory> create() .register("http", new PlainConnectionSocketFactory()) .register("https", trustSelfSignedSocketFactory) .build();
Registry<ConnectionSocketFactory> createConfiguredRegistry() { if (registry != null) { return registry; } TlsConfiguration tlsConfiguration = configuration.getTlsConfiguration(); if (tlsConfiguration == null && verifier != null) { tlsConfiguration = new TlsConfiguration(); } final SSLConnectionSocketFactory sslConnectionSocketFactory; if (tlsConfiguration == null) { sslConnectionSocketFactory = SSLConnectionSocketFactory.getSocketFactory(); } else { sslConnectionSocketFactory = new DropwizardSSLConnectionSocketFactory(tlsConfiguration, verifier).getSocketFactory(); } return RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", sslConnectionSocketFactory) .build(); }
/** * Create registry with configured {@link ConnectionSocketFactory} instances. * Override this method to change how to work with different schemas. * * @return registry object */ protected Registry<ConnectionSocketFactory> createConnectionSocketFactoryRegistry() { try { return RegistryBuilder.<ConnectionSocketFactory>create() .register(EWSConstants.HTTP_SCHEME, new PlainConnectionSocketFactory()) .register(EWSConstants.HTTPS_SCHEME, EwsSSLProtocolSocketFactory.build(null)) .build(); } catch (GeneralSecurityException e) { throw new RuntimeException( "Could not initialize ConnectionSocketFactory instances for HttpClientConnectionManager", e ); } }
/** configure HttpClient to ignore self-signed certs as described here: http://literatejava.com/networks/ignore-ssl-certificate-errors-apache-httpclient-4-4/ */ protected CloseableHttpClient createTrustingHttpClient() throws IOException { try { HttpClientBuilder builder = HttpClientBuilder.create(); SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustAllStrategy()).build(); builder.setSSLContext(sslContext); HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE; SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier); Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", sslSocketFactory) .build(); PoolingHttpClientConnectionManager connMgr = new PoolingHttpClientConnectionManager(socketFactoryRegistry); builder.setConnectionManager(connMgr); return builder.build(); } catch (Exception e) { throw new IOException(e); } }
private Registry<ConnectionSocketFactory> getSchemeRegistry(final Builder builder) { final SSLConnectionSocketFactory https; if (builder.dockerCertificatesStore == null) { https = SSLConnectionSocketFactory.getSocketFactory(); } else { https = new SSLConnectionSocketFactory(builder.dockerCertificatesStore.sslContext(), builder.dockerCertificatesStore.hostnameVerifier()); } final RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder .<ConnectionSocketFactory>create() .register("https", https) .register("http", PlainConnectionSocketFactory.getSocketFactory()); if (builder.uri.getScheme().equals(UNIX_SCHEME)) { registryBuilder.register(UNIX_SCHEME, new UnixConnectionSocketFactory(builder.uri)); } if (builder.uri.getScheme().equals(NPIPE_SCHEME)) { registryBuilder.register(NPIPE_SCHEME, new NpipeConnectionSocketFactory(builder.uri)); } return registryBuilder.build(); }
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext); socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", sslsf) .build(); } catch(Exception ex) { socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", SSLConnectionSocketFactory.getSocketFactory()) .build();
public MocoTestHelper() { // make fluent HC accept any certificates so we can test HTTPS calls as well Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", new SSLConnectionSocketFactory(createClientContext())) .build(); HttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry); CloseableHttpClient client = HttpClients.custom() .setConnectionManager(cm) .setDefaultRequestConfig(RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).build()) .build(); executor = Executor.newInstance(client); }
.register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", sslSocketFactory) .build();
public HttpClientConfig build() { // Lazily initialize if necessary, as the call can be expensive when done eagerly. if (this.sslSocketFactory == null) { this.sslSocketFactory = SSLConnectionSocketFactory.getSocketFactory(); } if(this.plainSocketFactory == null) { this.plainSocketFactory = PlainConnectionSocketFactory.getSocketFactory(); } if(this.httpRoutePlanner == null) { this.httpRoutePlanner = new SystemDefaultRoutePlanner(ProxySelector.getDefault()); } if(this.httpIOSessionStrategy == null) { this.httpIOSessionStrategy = NoopIOSessionStrategy.INSTANCE; } if(this.httpsIOSessionStrategy == null) { this.httpsIOSessionStrategy = SSLIOSessionStrategy.getSystemDefaultStrategy(); } if (preemptiveAuthSetWithoutCredentials()) { throw new IllegalArgumentException("Preemptive authentication set without credentials provider"); } return new HttpClientConfig(this); }
private HttpClientConnectionManager newConnectionManager() { Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", sslsf) .build(); PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(r); connManager.setMaxTotal(100); connManager.setDefaultMaxPerRoute(100); return connManager; }
RegistryBuilder.<ConnectionSocketFactory>create() .register("https", sslsf) .register("http", PlainConnectionSocketFactory.getSocketFactory()) .build();