Refine search
/** * Since Jersey 1.19 depends on legacy apache http-client API, we have to as well. */ private ThreadSafeClientConnManager createConnectionManager() { try { ThreadSafeClientConnManager connectionManager; if (sslContext != null) { SchemeSocketFactory socketFactory = new SSLSocketFactory(sslContext, new AllowAllHostnameVerifier()); SchemeRegistry sslSchemeRegistry = new SchemeRegistry(); sslSchemeRegistry.register(new Scheme("https", 443, socketFactory)); connectionManager = new ThreadSafeClientConnManager(sslSchemeRegistry); } else { connectionManager = new ThreadSafeClientConnManager(); } return connectionManager; } catch (Exception e) { throw new IllegalStateException("Cannot initialize Apache connection manager", e); } }
public HttpStoreClientFactory(ClientConfig config) { super(config); ThreadSafeClientConnManager mgr = new ThreadSafeClientConnManager(SchemeRegistryFactory.createDefault(), config.getConnectionTimeout(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS); mgr.setMaxTotal(config.getMaxTotalConnections()); mgr.setDefaultMaxPerRoute(config.getMaxConnectionsPerNode()); this.httpClient = new DefaultHttpClient(mgr); HttpParams clientParams = this.httpClient.getParams(); HttpProtocolParams.setUserAgent(clientParams, VOLDEMORT_USER_AGENT); HttpProtocolParams.setVersion(clientParams, HttpVersion.HTTP_1_1); HttpConnectionParams.setConnectionTimeout(clientParams, config.getConnectionTimeout(TimeUnit.MILLISECONDS)); HttpConnectionParams.setSoTimeout(clientParams, config.getSocketTimeout(TimeUnit.MILLISECONDS)); HttpConnectionParams.setStaleCheckingEnabled(clientParams, false); this.httpClient.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler(0, false)); HttpClientParams.setCookiePolicy(clientParams, CookiePolicy.IGNORE_COOKIES); this.reroute = config.getRoutingTier().equals(RoutingTier.SERVER); this.requestFormatFactory = new RequestFormatFactory(); }
@Override protected void finalize() throws Throwable { shutdown(); super.finalize(); }
private JerseyEurekaHttpClientFactory buildExperimental(Map<String, String> additionalHeaders) { ThreadSafeClientConnManager cm = createConnectionManager(); ClientConfig clientConfig = new DefaultApacheHttpClient4Config(); if (proxyHost != null) { addProxyConfiguration(clientConfig); } DiscoveryJerseyProvider discoveryJerseyProvider = new DiscoveryJerseyProvider(encoderWrapper, decoderWrapper); clientConfig.getSingletons().add(discoveryJerseyProvider); // Common properties to all clients cm.setDefaultMaxPerRoute(maxConnectionsPerHost); cm.setMaxTotal(maxTotalConnections); clientConfig.getProperties().put(ApacheHttpClient4Config.PROPERTY_CONNECTION_MANAGER, cm); String fullUserAgentName = (userAgent == null ? clientName : userAgent) + "/v" + buildVersion(); clientConfig.getProperties().put(CoreProtocolPNames.USER_AGENT, fullUserAgentName); // To pin a client to specific server in case redirect happens, we handle redirects directly // (see DiscoveryClient.makeRemoteCall methods). clientConfig.getProperties().put(ClientConfig.PROPERTY_FOLLOW_REDIRECTS, Boolean.FALSE); clientConfig.getProperties().put(ClientPNames.HANDLE_REDIRECTS, Boolean.FALSE); ApacheHttpClient4 apacheClient = ApacheHttpClient4.create(clientConfig); addFilters(apacheClient); return new JerseyEurekaHttpClientFactory(apacheClient, connectionIdleTimeout, additionalHeaders); }
protected HttpClient createHttpClient(GoogleAnalyticsConfig config) { ThreadSafeClientConnManager connManager = new ThreadSafeClientConnManager(); connManager.setDefaultMaxPerRoute(getDefaultMaxPerRoute(config)); BasicHttpParams params = new BasicHttpParams(); if (isNotEmpty(config.getUserAgent())) { params.setParameter(CoreProtocolPNames.USER_AGENT, config.getUserAgent()); } if (isNotEmpty(config.getProxyHost())) { params.setParameter(ConnRoutePNames.DEFAULT_PROXY, new HttpHost(config.getProxyHost(), config.getProxyPort())); } DefaultHttpClient client = new DefaultHttpClient(connManager, params); if (isNotEmpty(config.getProxyUserName())) { BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider(); credentialsProvider.setCredentials(new AuthScope(config.getProxyHost(), config.getProxyPort()), new UsernamePasswordCredentials(config.getProxyUserName(), config.getProxyPassword())); client.setCredentialsProvider(credentialsProvider); } return client; }
@Override public void setUp() throws Exception { super.setUp(); Cluster cluster = ServerTestUtils.getLocalCluster(1); Node node = cluster.getNodes().iterator().next(); context = ServerTestUtils.getJettyServer(new ClusterMapper().writeCluster(cluster), VoldemortTestConstants.getSimpleStoreDefinitionsXml(), "users", RequestFormatType.VOLDEMORT_V1, node.getHttpPort()); server = context.getServer(); ThreadSafeClientConnManager connectionManager = new ThreadSafeClientConnManager(SchemeRegistryFactory.createDefault(), 5000, TimeUnit.MILLISECONDS); httpClient = new DefaultHttpClient(connectionManager); httpStore = ServerTestUtils.getHttpStore("users", RequestFormatType.VOLDEMORT_V1, node.getHttpPort(), httpClient); }
private DefaultHttpClient createAllTrustingClient() throws GeneralSecurityException { SchemeRegistry registry = new SchemeRegistry(); registry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory())); TrustStrategy trustStrategy = new TrustStrategy() { public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException { return true; } }; SSLSocketFactory factory = new SSLSocketFactory(trustStrategy, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER ); registry.register(new Scheme("https", 443, factory)); ThreadSafeClientConnManager mgr = new ThreadSafeClientConnManager(registry); mgr.setMaxTotal(1000); mgr.setDefaultMaxPerRoute(1000); DefaultHttpClient client = new DefaultHttpClient(mgr, new DefaultHttpClient().getParams()); return client; }
ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(1000)); final SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry .register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 5984)); schemeRegistry .register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); final ClientConnectionManager cm = new ShieldedClientConnManager( new ThreadSafeClientConnManager(params, schemeRegistry)); instance = new DefaultHttpClient(cm, params); instance.setCredentialsProvider(credsProvider); instance.addRequestInterceptor(new PreemptiveAuthenticationRequestInterceptor(), 0);
public HttpClientImpl(HttpClientConfiguration conf) { this.conf = conf; SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register( new Scheme("http", 80, PlainSocketFactory.getSocketFactory())); schemeRegistry.register( new Scheme("https", 443, SSLSocketFactory.getSocketFactory())); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(schemeRegistry); cm.setMaxTotal(conf.getHttpMaxTotalConnections()); cm.setDefaultMaxPerRoute(conf.getHttpDefaultMaxPerRoute()); DefaultHttpClient client = new DefaultHttpClient(cm); HttpParams params = client.getParams(); HttpConnectionParams.setConnectionTimeout(params, conf.getHttpConnectionTimeout()); HttpConnectionParams.setSoTimeout(params, conf.getHttpReadTimeout()); if (conf.getHttpProxyHost() != null && !conf.getHttpProxyHost().equals("")) { HttpHost proxy = new HttpHost(conf.getHttpProxyHost(), conf.getHttpProxyPort()); client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy); if (conf.getHttpProxyUser() != null && !conf.getHttpProxyUser().equals("")) { if (logger.isDebugEnabled()) { logger.debug("Proxy AuthUser: " + conf.getHttpProxyUser()); logger.debug("Proxy AuthPassword: " + z_T4JInternalStringUtil.maskString(conf.getHttpProxyPassword())); } client.getCredentialsProvider().setCredentials( new AuthScope(conf.getHttpProxyHost(), conf.getHttpProxyPort()), new UsernamePasswordCredentials(conf.getHttpProxyUser(), conf.getHttpProxyPassword())); } } this.client = client; }
public static DefaultHttpClient buildDefaultSearchHttpClient(boolean ignoreSslIssues) { SchemeRegistry registry = new SchemeRegistry(); registry.register(new Scheme("http", new PlainSocketFactory(), 80)); registry.register(new Scheme("https", ignoreSslIssues ? new IgnoreTlsSniSocketFactory() : new TlsSniSocketFactory(), 443)); HttpParams httpparams = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(httpparams, 8000); HttpConnectionParams.setSoTimeout(httpparams, 8000); DefaultHttpClient httpclient = new DefaultHttpClient(new ThreadSafeClientConnManager(httpparams, registry), httpparams); httpclient.addRequestInterceptor(HttpHelper.gzipRequestInterceptor); httpclient.addResponseInterceptor(HttpHelper.gzipResponseInterceptor); return httpclient; }
private static void createThreadSafeClient(boolean forceSecure) { httpClient = new DefaultHttpClient(); ClientConnectionManager mgr = httpClient.getConnectionManager(); HttpParams params = httpClient.getParams(); SchemeRegistry schemeRegistry = mgr.getSchemeRegistry(); if (forceSecure) { schemeRegistry.register(new Scheme("https", getSecureConnectionSetting(), 443)); } else { HostnameVerifier hostnameVerifier = SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER; SSLSocketFactory socketFactory = SSLSocketFactory .getSocketFactory(); socketFactory .setHostnameVerifier((X509HostnameVerifier) hostnameVerifier); schemeRegistry.register(new Scheme("https", socketFactory, 443)); } httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params); }
/********************** Member Functions **************************/ private static DefaultHttpClient getThreadSafeClient() { DefaultHttpClient client = new DefaultHttpClient(); ClientConnectionManager mgr = client.getConnectionManager(); HttpParams params = client.getParams(); client = new DefaultHttpClient(new ThreadSafeClientConnManager(params, mgr.getSchemeRegistry()), params); return client; }
@PostConstruct private void setupClient() { final ThreadSafeClientConnManager ccm = new ThreadSafeClientConnManager(); ccm.setMaxTotal( config.getMaxConnections() ); final DefaultHttpClient c = new DefaultHttpClient( ccm ); if ( config.getDatabaseUser() != null ) { final AuthScope scope = new AuthScope( config.getDatabaseHost(), config.getDatabasePort() ); final UsernamePasswordCredentials cred = new UsernamePasswordCredentials( config.getDatabaseUser(), config.getDatabasePassword() ); c.getCredentialsProvider() .setCredentials( scope, cred ); } client = c; }
@Override protected void before() throws Exception { final ThreadSafeClientConnManager ccm = new ThreadSafeClientConnManager(); ccm.setMaxTotal( 20 ); http = new DefaultHttpClient( ccm ); http.setCredentialsProvider( new CredentialsProvider() { @Override public void setCredentials( final AuthScope authscope, final Credentials credentials ) { } @Override public Credentials getCredentials( final AuthScope authscope ) { if ( user != null ) { return new UsernamePasswordCredentials( user, pass ); } return null; } @Override public void clear() { } } ); }
public void start(SolrDefinition solrDef) throws Exception { System.out.println("SolrProxy mode: " + mode); solrDef = solrDef != null ? solrDef : new SolrDefinition(); switch (mode) { case EMBED: initTestHome(); System.out.println("SolrProxy embedded mode temp dir: " + testHome.getAbsolutePath()); solrTestingUtility = new SolrTestingUtility(testHome, clearData, enableSolrCloud); solrTestingUtility.setSolrDefinition(solrDef); solrTestingUtility.start(); this.uri = solrTestingUtility.getBaseUri(); initSolrServers(solrDef); break; case CONNECT: this.uri = "http://localhost:8983/solr"; changeSolrDefinition(solrDef); break; default: throw new RuntimeException("Unexpected mode: " + mode); } connectionManager = new ThreadSafeClientConnManager(); connectionManager.setDefaultMaxPerRoute(5); connectionManager.setMaxTotal(50); httpClient = new DefaultHttpClient(connectionManager); }
@Override protected void before() throws Throwable { super.before(); final ThreadSafeClientConnManager ccm = new ThreadSafeClientConnManager(); ccm.setMaxTotal( 20 ); http = new DefaultHttpClient( ccm ); } }
public void configure( DirectMemoryClientConfiguration configuration ) { this.configuration = configuration; ThreadSafeClientConnManager threadSafeClientConnManager = new ThreadSafeClientConnManager(); threadSafeClientConnManager.setDefaultMaxPerRoute( configuration.getMaxConcurentConnections() ); this.httpClient = new DefaultHttpClient( threadSafeClientConnManager ); }
@Override public ClientConnectionManager configureConnectionManager( HttpParams params) { if (conman == null) { SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(configureScheme()); ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry); conman = cm; } if (cleanupIdleConnections) { IdleConnectionMonitor.monitor(conman); } return conman; }
class X { private static final HttpClient httpClient; static { SchemeRegistry defaultRegistery = new DefaultHttpClient().getConnectionManager() .getSchemeRegistry(); ThreadSafeClientConnManager connMgr = new ThreadSafeClientConnManager(defaultRegistery); connMgr.setMaxTotalConnections(10); connMgr.setDefaultMaxPerRoute(10); httpClient = new DefaultHttpClient(connMgr); httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 30000); } public static InputStream simpleGetRequest(URL url, List<NameValuePair> queryString) throws ClientProtocolException, IOException {...} public static InputStream simpleGetRequest(URL url, List<NameValuePair> queryString) throws ClientProtocolException, IOException {...} }
SchemeRegistry sc = new SchemeRegistry(); sc.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory())); sc.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory())); ThreadSafeClientConnManager connmgr = new ThreadSafeClientConnManager(sc); connmgr.setDefaultMaxPerRoute(5); /// Alternative approach to yours /// DefaultHttpClient g_client = new DefaultHttpClient(connmgr); g_client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 5000); g_client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 5000); g_client.getParams().setParameter(ConnManagerPNames.TIMEOUT, 2000); /// Alternative approach to yours ///