Example usage for org.apache.commons.httpclient.params HttpMethodParams PROTOCOL_VERSION

List of usage examples for org.apache.commons.httpclient.params HttpMethodParams PROTOCOL_VERSION

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.httpclient.params.*
  5. HttpMethodParams
  6. PROTOCOL_VERSION

Introduction

In this page you can find the example usage for org.apache.commons.httpclient.params HttpMethodParams PROTOCOL_VERSION.

Prototype

String PROTOCOL_VERSION

To view the source code for org.apache.commons.httpclient.params HttpMethodParams PROTOCOL_VERSION.

Click Source Link

Usage

From source file:colt.nicity.performance.agent.LatentHttpPump.java

private org.apache.commons.httpclient.HttpClient createApacheClient(String host, int port, int maxConnections,
        int socketTimeoutInMillis) {

    HttpConnectionManager connectionManager = createConnectionManager(maxConnections);

    org.apache.commons.httpclient.HttpClient client = new org.apache.commons.httpclient.HttpClient(
            connectionManager);// ww  w . j a  v  a  2 s . c o  m
    client.getParams().setParameter(HttpMethodParams.COOKIE_POLICY, CookiePolicy.RFC_2109);
    client.getParams().setParameter(HttpMethodParams.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
    client.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
    client.getParams().setBooleanParameter(HttpMethodParams.USE_EXPECT_CONTINUE, false);
    client.getParams().setBooleanParameter(HttpConnectionParams.STALE_CONNECTION_CHECK, true);
    client.getParams().setParameter(HttpConnectionParams.CONNECTION_TIMEOUT,
            socketTimeoutInMillis > 0 ? socketTimeoutInMillis : 0);
    client.getParams().setParameter(HttpConnectionParams.SO_TIMEOUT,
            socketTimeoutInMillis > 0 ? socketTimeoutInMillis : 0);

    HostConfiguration hostConfiguration = new HostConfiguration();
    configureSsl(hostConfiguration, host, port);
    configureProxy(hostConfiguration);

    client.setHostConfiguration(hostConfiguration);
    return client;

}

From source file:com.orange.mmp.net.http.HttpConnectionManager.java

public Connection getConnection() throws MMPNetException {
    SimpleHttpConnectionManager shcm = new SimpleHttpConnectionManager();

    HttpClientParams defaultHttpParams = new HttpClientParams();
    defaultHttpParams.setParameter(HttpMethodParams.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
    defaultHttpParams.setParameter(HttpConnectionParams.TCP_NODELAY, true);
    defaultHttpParams.setParameter(HttpConnectionParams.STALE_CONNECTION_CHECK, false);
    defaultHttpParams.setParameter(HttpConnectionParams.SO_LINGER, 0);
    defaultHttpParams.setParameter(HttpClientParams.MAX_REDIRECTS, 3);
    defaultHttpParams.setParameter(HttpClientParams.ALLOW_CIRCULAR_REDIRECTS, false);

    HttpClient httpClient2 = new HttpClient(defaultHttpParams, shcm);

    if (HttpConnectionManager.proxyHost != null) {
        defaultHttpParams.setParameter("http.route.default-proxy",
                new HttpHost(HttpConnectionManager.proxyHost, HttpConnectionManager.proxyPort)); // TODO Host configuration !
        if (HttpConnectionManager.proxyHost != null/* && this.useProxy*/) {
            HostConfiguration config = new HostConfiguration();
            config.setProxy(HttpConnectionManager.proxyHost, HttpConnectionManager.proxyPort);
            httpClient2.setHostConfiguration(config);
        } else {//w ww .  j  a v  a 2s. co m
            HostConfiguration config = new HostConfiguration();
            config.setProxyHost(null);
            httpClient2.setHostConfiguration(config);
        }
    }

    return new HttpConnection(httpClient2);
}

From source file:com.jivesoftware.os.jive.utils.http.client.HttpClientFactoryProvider.java

public HttpClientFactory createHttpClientFactory(final Collection<HttpClientConfiguration> configurations) {
    return new HttpClientFactory() {
        @Override//w  w w .j a  v  a  2  s. c o  m
        public HttpClient createClient(String host, int port) {

            ApacheHttpClient31BackedHttpClient httpClient = createApacheClient();

            HostConfiguration hostConfiguration = new HostConfiguration();
            configureSsl(hostConfiguration, host, port, httpClient);
            configureProxy(hostConfiguration, httpClient);

            httpClient.setHostConfiguration(hostConfiguration);
            configureOAuth(httpClient);
            return httpClient;
        }

        private ApacheHttpClient31BackedHttpClient createApacheClient() {
            HttpClientConfig httpClientConfig = locateConfig(HttpClientConfig.class,
                    HttpClientConfig.newBuilder().build());

            HttpConnectionManager connectionManager = createConnectionManager(httpClientConfig);

            org.apache.commons.httpclient.HttpClient client = new org.apache.commons.httpclient.HttpClient(
                    connectionManager);
            client.getParams().setParameter(HttpMethodParams.COOKIE_POLICY, CookiePolicy.RFC_2109);
            client.getParams().setParameter(HttpMethodParams.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
            client.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
            client.getParams().setBooleanParameter(HttpMethodParams.USE_EXPECT_CONTINUE, false);
            client.getParams().setBooleanParameter(HttpConnectionParams.STALE_CONNECTION_CHECK, true);
            client.getParams().setParameter(HttpConnectionParams.CONNECTION_TIMEOUT,
                    httpClientConfig.getSocketTimeoutInMillis() > 0
                            ? httpClientConfig.getSocketTimeoutInMillis()
                            : 0);
            client.getParams().setParameter(HttpConnectionParams.SO_TIMEOUT,
                    httpClientConfig.getSocketTimeoutInMillis() > 0
                            ? httpClientConfig.getSocketTimeoutInMillis()
                            : 0);

            return new ApacheHttpClient31BackedHttpClient(client,
                    httpClientConfig.getCopyOfHeadersForEveryRequest());

        }

        @SuppressWarnings("unchecked")
        private <T> T locateConfig(Class<? extends T> _class, T defaultConfiguration) {
            for (HttpClientConfiguration configuration : configurations) {
                if (_class.isInstance(configuration)) {
                    return (T) configuration;
                }
            }
            return defaultConfiguration;
        }

        private boolean hasValidProxyUsernameAndPasswordSettings(HttpClientProxyConfig httpClientProxyConfig) {
            return StringUtils.isNotBlank(httpClientProxyConfig.getProxyUsername())
                    && StringUtils.isNotBlank(httpClientProxyConfig.getProxyPassword());
        }

        private HttpConnectionManager createConnectionManager(HttpClientConfig config) {
            MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
            if (config.getMaxConnectionsPerHost() > 0) {
                connectionManager.getParams()
                        .setDefaultMaxConnectionsPerHost(config.getMaxConnectionsPerHost());
            } else {
                connectionManager.getParams().setDefaultMaxConnectionsPerHost(Integer.MAX_VALUE);
            }
            if (config.getMaxConnections() > 0) {
                connectionManager.getParams().setMaxTotalConnections(config.getMaxConnections());
            }
            return connectionManager;
        }

        private void configureOAuth(ApacheHttpClient31BackedHttpClient httpClient) {
            HttpClientOAuthConfig httpClientOAuthConfig = locateConfig(HttpClientOAuthConfig.class, null);
            if (httpClientOAuthConfig != null) {
                String serviceName = httpClientOAuthConfig.getServiceName();
                HttpClientConsumerKeyAndSecretProvider consumerKeyAndSecretProvider = httpClientOAuthConfig
                        .getConsumerKeyAndSecretProvider();
                String consumerKey = consumerKeyAndSecretProvider.getConsumerKey(serviceName);
                if (StringUtils.isEmpty(consumerKey)) {
                    throw new RuntimeException(
                            "could create oauth client because consumerKey is null or empty for service:"
                                    + serviceName);
                }
                String consumerSecret = consumerKeyAndSecretProvider.getConsumerSecret(serviceName);
                if (StringUtils.isEmpty(consumerSecret)) {
                    throw new RuntimeException(
                            "could create oauth client because consumerSecret is null or empty for service:"
                                    + serviceName);
                }

                httpClient.setConsumerTokens(consumerKey, consumerSecret);
            }
        }

        private void configureProxy(HostConfiguration hostConfiguration,
                ApacheHttpClient31BackedHttpClient httpClient) {
            HttpClientProxyConfig httpClientProxyConfig = locateConfig(HttpClientProxyConfig.class, null);
            if (httpClientProxyConfig != null) {
                hostConfiguration.setProxy(httpClientProxyConfig.getProxyHost(),
                        httpClientProxyConfig.getProxyPort());
                if (hasValidProxyUsernameAndPasswordSettings(httpClientProxyConfig)) {
                    HttpState state = new HttpState();
                    state.setProxyCredentials(AuthScope.ANY,
                            new UsernamePasswordCredentials(httpClientProxyConfig.getProxyUsername(),
                                    httpClientProxyConfig.getProxyPassword()));
                    httpClient.setState(state);
                }
            }
        }

        private void configureSsl(HostConfiguration hostConfiguration, String host, int port,
                ApacheHttpClient31BackedHttpClient httpClient) throws IllegalStateException {
            HttpClientSSLConfig httpClientSSLConfig = locateConfig(HttpClientSSLConfig.class, null);
            if (httpClientSSLConfig != null) {
                Protocol sslProtocol;
                if (httpClientSSLConfig.getCustomSSLSocketFactory() != null) {
                    sslProtocol = new Protocol(HTTPS_PROTOCOL, new CustomSecureProtocolSocketFactory(
                            httpClientSSLConfig.getCustomSSLSocketFactory()), SSL_PORT);
                } else {
                    sslProtocol = Protocol.getProtocol(HTTPS_PROTOCOL);
                }
                hostConfiguration.setHost(host, port, sslProtocol);
                httpClient.setUsingSSL();
            } else {
                hostConfiguration.setHost(host, port);
            }
        }
    };
}

From source file:ch.cyberduck.core.http.HTTP3Session.java

protected HostConfiguration getHostConfiguration(Host host) {
    int port = host.getPort();
    final HostConfiguration configuration = new StickyHostConfiguration();
    if ("https".equals(host.getProtocol().getScheme())) {
        if (-1 == port) {
            port = 443;/*from   www .  j  av  a  2 s .c o m*/
        }
        // Configuration with custom socket factory using the trust manager
        configuration.setHost(host.getHostname(), port,
                new org.apache.commons.httpclient.protocol.Protocol(host.getProtocol().getScheme(),
                        new SSLSocketFactory(this.getTrustManager(host.getHostname())), port));
        if (Preferences.instance().getBoolean("connection.proxy.enable")) {
            final Proxy proxy = ProxyFactory.instance();
            if (proxy.isHTTPSProxyEnabled(host)) {
                configuration.setProxy(proxy.getHTTPSProxyHost(host), proxy.getHTTPSProxyPort(host));
            }
        }
    } else if ("http".equals(host.getProtocol().getScheme())) {
        if (-1 == port) {
            port = 80;
        }
        configuration.setHost(host.getHostname(), port, new org.apache.commons.httpclient.protocol.Protocol(
                host.getProtocol().getScheme(), new DefaultProtocolSocketFactory(), port));
        if (Preferences.instance().getBoolean("connection.proxy.enable")) {
            final Proxy proxy = ProxyFactory.instance();
            if (proxy.isHTTPProxyEnabled(host)) {
                configuration.setProxy(proxy.getHTTPProxyHost(host), proxy.getHTTPProxyPort(host));
            }
        }
    }
    final HostParams parameters = configuration.getParams();
    parameters.setParameter(HttpMethodParams.USER_AGENT, this.getUserAgent());
    parameters.setParameter(HttpMethodParams.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
    parameters.setParameter(HttpMethodParams.SO_TIMEOUT, this.timeout());
    parameters.setParameter(HttpMethodParams.CREDENTIAL_CHARSET, "ISO-8859-1");
    parameters.setParameter(HttpClientParams.MAX_REDIRECTS, 10);
    return configuration;
}

From source file:edu.mit.csail.sls.wami.portal.xmlrpc.XmlRpcPortalRecognizer.java

public void setParameters(ServletContext sc, Map<String, String> map) throws RecognizerException {
    this.sc = sc;
    String recDomain = (String) sc.getAttribute("recDomain");
    String developerEmail = map.get("developerEmail");
    String developerKey = map.get("developerKey");
    String recordFormat = map.get("recordFormat");
    int recordSampleRate = Integer.parseInt(map.get("recordSampleRate"));
    boolean recordIsLittleEndian = Boolean.parseBoolean(map.get("recordIsLittleEndian"));
    String incrementalResultsStr = map.get("incrementalResults");
    incrementalResults = (incrementalResultsStr == null || Boolean.parseBoolean(incrementalResultsStr));

    serverAddress = null;/*  w  ww  .  j a  v  a2s. c  o m*/
    try {
        serverAddress = new URL(map.get("url"));
    } catch (MalformedURLException e) {
        throw new RecognizerException("Invalid recognizer url", e);
    }

    XmlRpcClientConfig config = createClientConfig(serverAddress, 10 * 1000, 10 * 1000);
    client = new XmlRpcClient();

    XmlRpcCommonsTransportFactory factory = new XmlRpcCommonsTransportFactory(client);

    // Use HTTP 1.1
    HttpClient httpClient = new HttpClient();
    httpClient.getParams().setParameter(HttpMethodParams.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
    factory.setHttpClient(httpClient);

    client.setTransportFactory(factory);
    client.setConfig(config);

    Object[] createParams = { developerEmail, developerKey, recordFormat, recordSampleRate,
            recordIsLittleEndian, recDomain };

    try {
        sessionId = (String) client.execute("Portal.createRecognizerSession", createParams);
    } catch (XmlRpcException e) {
        if (e.code == ErrorCodes.SERVER_ERROR_CODE) {
            throw new RecognizerException(e);
        } else {
            throw new RecognizerUnreachableException(e);
        }
    }

    String jsgfGrammarPath = map.get("jsgfGrammarPath");
    String jsgfGrammarLanguage = map.get("jsgfGrammarLanguage");
    if (jsgfGrammarPath != null) {
        InputStream in = sc.getResourceAsStream(jsgfGrammarPath);
        if (in == null) {
            throw new RecognizerException("Couldn't find grammar: " + jsgfGrammarPath);
        }

        String language = (jsgfGrammarLanguage != null) ? jsgfGrammarLanguage : "en-us";

        try {
            JsgfGrammar grammar = new JsgfGrammar(in, language);
            setLanguageModel(grammar);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}