public static String fetchThroughHttp(String address, String encoding) { try { org.apache.http.client.HttpClient httpClient = new org.apache.http.impl.client.DefaultHttpClient(); org.apache.http.params.HttpParams params = httpClient.getParams(); org.apache.http.params.HttpConnectionParams.setConnectionTimeout(params, 10000); org.apache.http.params.HttpConnectionParams.setSoTimeout(params, 60000); org.apache.http.protocol.HttpContext localContext = new org.apache.http.protocol.BasicHttpContext(); org.apache.http.client.methods.HttpGet httpGet = new org.apache.http.client.methods.HttpGet(address); org.apache.http.HttpResponse response = httpClient.execute(httpGet, localContext); if (response.getStatusLine().getStatusCode() != 200) { return "FAILED"; } BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), Charset.forName(encoding))); StringBuilder stringBuilder = new StringBuilder(); String line = null; while ((line = reader.readLine()) != null) { stringBuilder.append(line); } return stringBuilder.toString(); } catch (Exception e) { return "FAILED with exception: " + e.getMessage(); } }
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(); }
protected void setupHttpClient() { BasicHttpParams httpParams = new BasicHttpParams(); ConnManagerParams.setTimeout(httpParams, DEFAULT_WAIT_FOR_CONNECTION_TIMEOUT); ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean( DEFAULT_MAX_CONNECTIONS)); ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS); HttpConnectionParams.setSoTimeout(httpParams, DEFAULT_SOCKET_TIMEOUT); HttpConnectionParams.setTcpNoDelay(httpParams, true); HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); HttpProtocolParams.setUserAgent(httpParams, DEFAULT_HTTP_USER_AGENT); SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); if (IgnitedDiagnostics.ANDROID_API_LEVEL >= 7) { schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443)); } else { // used to work around a bug in Android 1.6: // http://code.google.com/p/android/issues/detail?id=1946 // TODO: is there a less rigorous workaround for this? schemeRegistry.register(new Scheme("https", new EasySSLSocketFactory(), 443)); } ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(httpParams, schemeRegistry); httpClient = new DefaultHttpClient(cm, httpParams); }
public EurekaJerseyClientImpl(int connectionTimeout, int readTimeout, final int connectionIdleTimeout, ClientConfig clientConfig) { try { jerseyClientConfig = clientConfig; apacheHttpClient = ApacheHttpClient4.create(jerseyClientConfig); HttpParams params = apacheHttpClient.getClientHandler().getHttpClient().getParams(); HttpConnectionParams.setConnectionTimeout(params, connectionTimeout); HttpConnectionParams.setSoTimeout(params, readTimeout); this.apacheHttpClientConnectionCleaner = new ApacheHttpClientConnectionCleaner(apacheHttpClient, connectionIdleTimeout); } catch (Throwable e) { throw new RuntimeException("Cannot create Jersey client", e); } }
HttpParams httpParams = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(httpParams, NET_TIMEOUT); HttpConnectionParams.setSoTimeout(httpParams, NET_TIMEOUT); HttpConnectionParams.setSocketBufferSize(httpParams, 8192); client = new DefaultHttpClient(cm, httpParams);
@Override public Socket connectSocket(final Socket sock, final InetSocketAddress remoteAddress, final InetSocketAddress localAddress, final HttpParams params) throws IOException { checkArgument(remoteAddress != null, "Remote address may not be null"); checkArgument(params != null, "HTTP parameters may not be null"); Socket socket = sock != null ? sock : new Socket(); if (localAddress != null) { socket.setReuseAddress(HttpConnectionParams.getSoReuseaddr(params)); socket.bind(localAddress); } socket.setSoTimeout(HttpConnectionParams.getSoTimeout(params)); socket.connect(remoteAddress, HttpConnectionParams.getConnectionTimeout(params)); if (socket instanceof SSLSocket) { return socket; } return getSSLContext().getSocketFactory() .createSocket(socket, remoteAddress.getHostName(), remoteAddress.getPort(), true); }
final ClientConfiguration config) throws IOException { HttpParams httpClientParams = new BasicHttpParams(); HttpProtocolParams.setUserAgent( httpClientParams, getUserAgent(config, null)); HttpConnectionParams.setConnectionTimeout( httpClientParams, getConnectionTimeout(config)); HttpConnectionParams.setSoTimeout( httpClientParams, getSocketTimeout(config)); DefaultHttpClient httpclient = new DefaultHttpClient(httpClientParams); httpclient.getParams().setParameter( ConnRoutePNames.DEFAULT_PROXY, proxy); && config.getProxyPassword() != null) { httpclient.getCredentialsProvider().setCredentials( new AuthScope(proxyHost, proxyPort), new NTCredentials(config.getProxyUsername(), HttpResponse response = httpclient.execute(new HttpGet(uri)); response.getEntity().getContent());
private HttpResponse callService(URI uri) throws IOException { DefaultHttpClient httpClient = new DefaultHttpClient(); HttpGet httpGet = new HttpGet(uri); HttpParams params = httpClient.getParams(); final int timeout = 10000; HttpConnectionParams.setConnectionTimeout(params, timeout); HttpConnectionParams.setSoTimeout(params, timeout); return httpClient.execute(httpGet); }
public static int checkIfInSchool() { try { HttpParams httpParams = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(httpParams, 1000); HttpConnectionParams.setSoTimeout(httpParams, 2000); HttpClient httpClient = new DefaultHttpClient(httpParams); HttpGet httpGet = new HttpGet(Constants.domain + "/services/pkuhelper/isIPInPKU.php"); HttpResponse httpResponse = httpClient.execute(httpGet); InputStream inputStream = httpResponse.getEntity().getContent(); BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream)); String line = bufferedReader.readLine(); return Integer.parseInt(line); } catch (IOException e) { return -1; } }
HttpResponse response; try { DefaultHttpClient httpclient = new DefaultHttpClient(); HttpParams params = httpclient.getParams(); HttpConnectionParams.setConnectionTimeout(params, DEFAULT_TIMEOUT); HttpConnectionParams.setSoTimeout(params, DEFAULT_TIMEOUT); HttpPost httppost = new HttpPost(url); httppost.setHeader("Content-Type", "application/x-www-form-urlencoded"); response = httpclient.execute(httppost); entity = response.getEntity(); in = new BufferedReader(new InputStreamReader(entity.getContent(), "UTF-8")); String ln;
public static String runHttpGetCommand(String url) throws Exception DefaultHttpClient client = new DefaultHttpClient(); InputStream isStream = null; try { HttpParams httpParameters = new BasicHttpParams(); int timeoutConnection = 1000; int timeoutSocket = 1000; HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection); HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket); client.setParams(httpParameters); HttpGet getRequest = new HttpGet(url); getRequest.setHeader("Content-type", "application/json"); HttpResponse resp = client.execute(getRequest); if (resp == null || resp.getEntity() == null) { throw new ESHttpException("Unable to execute GET URL (" + url + ") Exception Message: < Null Response or Null HttpEntity >"); isStream = resp.getEntity().getContent(); if (resp.getStatusLine().getStatusCode() != 200) {
sock.bind(isa); int timeout = HttpConnectionParams.getConnectionTimeout(params); for (InetAddress address: addresses) { try { sock.connect(new InetSocketAddress(address, port), timeout); break; } catch (SocketTimeoutException ex) { } catch (IOException ex) { sock = new Socket();
JSONObject jsonObject = null; int timeOut = 30 * 1000; HttpParams param = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(param, timeOut); HttpConnectionParams.setSoTimeout(param, timeOut); HttpConnectionParams.setTcpNoDelay(param, true); registry.register(new Scheme("https", TrustAllSSLSocketFactory .getDefault(), 443)); ClientConnectionManager manager = new ThreadSafeClientConnManager( param, registry); DefaultHttpClient client = new DefaultHttpClient(manager, param); HttpGet request = new HttpGet(path); HttpResponse response = client.execute(request); HttpEntity entity = response.getEntity(); BufferedReader reader = new BufferedReader(new InputStreamReader( entity.getContent())); StringBuilder result = new StringBuilder();
: nexusBaseURI + "/service/local/status"; final HttpParams params = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(params, 2000); HttpConnectionParams.setSoTimeout(params, 2000); final DefaultHttpClient client = new DefaultHttpClient(params); client.getCredentialsProvider().setCredentials( AuthScope.ANY, new UsernamePasswordCredentials("admin", "admin123") ); final HttpGet request = new HttpGet(serviceStatusURI); try { final HttpResponse response = client.execute(request); final int statusCode = response.getStatusLine().getStatusCode(); if (statusCode != 200) { LOG.debug("Nexus Status Check: Returned status: " + statusCode);
private void makeRequest(HttpPost request) throws InterruptedException { HttpParams parameters = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(parameters, HTTP_TIMEOUT); HttpConnectionParams.setSoTimeout(parameters, HTTP_TIMEOUT); final HttpClient client = new DefaultHttpClient(parameters); try { HttpResponse response = client.execute(request); final int statusCode = response.getStatusLine().getStatusCode(); if(statusCode != HttpStatus.SC_CREATED) { Log.w(TAG, "Got unexpected status code: " + statusCode); } } catch(IOException e) { Log.w(TAG, "Problem uploading the record", e); try { Thread.sleep(5000); } catch(InterruptedException e2) { Log.w(TAG, "Uploader interrupted after an error", e2); throw e2; } } }
private HttpResponse callService(String userId, String sitePassword, URI uri) throws IOException { DefaultHttpClient httpClient = new DefaultHttpClient(); HttpGet httpGet = new HttpGet(uri); BasicCredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userId, sitePassword)); httpClient.setCredentialsProvider(credsProvider); BasicHttpContext httpContext = new BasicHttpContext(); // Generate BASIC scheme object and stick it to the local // execution context BasicScheme basicAuth = new BasicScheme(); httpContext.setAttribute("preemptive-auth", basicAuth); // Add as the first request interceptor httpClient.addRequestInterceptor(new PreemptiveAuth(), 0); HttpParams params = httpClient.getParams(); final int timeout = 10000; HttpConnectionParams.setConnectionTimeout(params, timeout); HttpConnectionParams.setSoTimeout(params, timeout); return httpClient.execute(httpGet, httpContext); }
private DefaultHttpClient prepareRequest(SharedPreferences prefs) throws Exception { String username = SettingsHelper.getSiteUser(prefs, TorrentSite.AsiaTorrents); String password = SettingsHelper.getSitePass(prefs, TorrentSite.AsiaTorrents); if (username == null || password == null) { throw new InvalidParameterException("No username or password was provided, while this is required for this private site."); } // Setup request using GET HttpParams httpparams = new BasicHttpParams(); HttpConnectionParams.setConnectionTimeout(httpparams, CONNECTION_TIMEOUT); HttpConnectionParams.setSoTimeout(httpparams, CONNECTION_TIMEOUT); DefaultHttpClient httpclient = new DefaultHttpClient(httpparams); // First log in HttpPost loginPost = new HttpPost(LOGINURL); loginPost.setEntity(new UrlEncodedFormEntity(Arrays.asList(new BasicNameValuePair[]{new BasicNameValuePair(LOGIN_USER, username), new BasicNameValuePair(LOGIN_PASS, password)}))); HttpResponse loginResult = httpclient.execute(loginPost); if (loginResult.getStatusLine().getStatusCode() != HttpStatus.SC_OK) { // Failed to sign in throw new LoginException("Login failure for AsiaTorrents with user " + username); } return httpclient; }
org.apache.http.params.HttpParams params = new org.apache.http.params.BasicHttpParams(); params.setParameter(org.apache.http.conn.params.ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30); params.setParameter(org.apache.http.conn.params.ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new org.apache.http.conn.params.ConnPerRouteBean(30)); params.setParameter(org.apache.http.params.CoreProtocolPNames.USE_EXPECT_CONTINUE, false); params.setParameter(org.apache.http.params.CoreProtocolPNames.USER_AGENT, "AnkiDroid-" + VersionUtils.getPkgVersionName()); org.apache.http.params.HttpProtocolParams.setVersion(params, org.apache.http.HttpVersion.HTTP_1_1); org.apache.http.params.HttpConnectionParams.setSoTimeout(params, Connection.CONN_TIMEOUT); org.apache.http.client.HttpClient httpClient = new org.apache.http.impl.client.DefaultHttpClient(cm, params); org.apache.http.HttpResponse httpResponse = httpClient.execute(httpPost);
/** * Handle http get request. Return String * * @param httpClient This should be httpClient which used to connect to rest endpoint * @param resourcePath This should be REST endpoint * @return The HttpResponse * @throws org.apache.http.client.ClientProtocolException and IOException * if any errors occur when executing the request */ public HttpResponse doGet(DefaultHttpClient httpClient, String resourcePath) throws IOException { HttpGet getRequest = new HttpGet(resourcePath); getRequest.addHeader("Content-Type", "application/json"); String userPass = username + ":" + password; String basicAuth = "Basic " + javax.xml.bind.DatatypeConverter.printBase64Binary(userPass.getBytes("UTF-8")); getRequest.addHeader("Authorization", basicAuth); httpClient = (DefaultHttpClient) WebClientWrapper.wrapClient(httpClient); HttpParams params = httpClient.getParams(); HttpConnectionParams.setConnectionTimeout(params, TIME_OUT_PARAM); HttpConnectionParams.setSoTimeout(params, TIME_OUT_PARAM); HttpResponse response = httpClient.execute(getRequest); return response; }
@Override public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders) throws IOException, AuthFailureError { HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders); addHeaders(httpRequest, additionalHeaders); addHeaders(httpRequest, request.getHeaders()); onPrepareRequest(httpRequest); HttpParams httpParams = httpRequest.getParams(); int timeoutMs = request.getTimeoutMs(); // TODO: Reevaluate this connection timeout based on more wide-scale // data collection and possibly different for wifi vs. 3G. HttpConnectionParams.setConnectionTimeout(httpParams, 5000); HttpConnectionParams.setSoTimeout(httpParams, timeoutMs); return mClient.execute(httpRequest); }