Example usage for org.apache.commons.httpclient MultiThreadedHttpConnectionManager DEFAULT_MAX_HOST

Introduction

In this page you can find the example usage for org.apache.commons.httpclient MultiThreadedHttpConnectionManager DEFAULT_MAX_HOST_CONNECTIONS.

Prototype

int DEFAULT_MAX_HOST_CONNECTIONS

To view the source code for org.apache.commons.httpclient MultiThreadedHttpConnectionManager DEFAULT_MAX_HOST_CONNECTIONS.

Click Source Link

Usage

From source file:flex.messaging.services.http.HTTPProxyAdapter.java

/**
 * Initializes the <code>HTTPProxyAdapter</code> with the properties.
 *
 * <pre>/*from  w  ww  .  j a va 2 s .  c o m*/
 * &lt;connection-manager&gt;
 *     &lt;cookie-policy&gt;rfc2109&lt;/cookie-policy&gt;
 *     &lt;max-total-connections&gt;100&lt;/max-total-connections&gt;
 *     &lt;default-max-connections-per-host&gt;2&lt;/default-max-connections-per-host&gt;
 *     &lt;connection-timeout&gt;0&lt;/connection-timeout&gt;
 *     &lt;socket-timeout&gt;&lt;/socket-timeout&gt;
 *     &lt;stale-checking-enabled&gt;&lt;/stale-checking-enabled&gt;
 *     &lt;send-buffer-size&gt;&lt;/send-buffer-size&gt;
 *     &lt;receive-buffer-size&gt;&lt;/receive-buffer-size&gt;
 *     &lt;tcp-no-delay&gt;true&lt;/tcp-no-delay&gt;
 *     &lt;linger&gt;-1&lt;/linger&gt;
 *     &lt;max-per-host&gt;
 *           &lt;host&gt;...&lt;/host&gt;
 *           &lt;port&gt;80&lt;/port&gt;
 *           &lt;protocol&gt;http&lt;/protocol&gt;
 *           &lt;protocol-factory class="flex.messaging.services.http.ProtocolFactory"&gt;
 *               &lt;properties&gt;...&lt;/properties&gt;
 *           &lt;/protocol-factory&gt;
 *           &lt;max-connections&gt;2&lt;/max-connections&gt;
 *           &lt;proxy&gt;
 *               &lt;host&gt;...&lt;/host&gt;
 *               &lt;port&gt;80&lt;/port&gt;
 *           &lt;/proxy&gt;
 *           &lt;local-address&gt;...&lt;/local-address&gt;
 *           &lt;virtual-host&gt;...&lt;/virtual-host&gt;
 *     &lt;/max-per-host&gt;
 *  &lt;/connection-manager&gt;
 *  &lt;cookie-limit&gt;200&lt;/cookie-limit&gt;
 *  &lt;allow-lax-ssl&gt;false&lt;/allow-lax-ssl&gt;
 *  &lt;content-chunked&gt;false&lt;/content-chunked&gt;
 *  &lt;external-proxy&gt;
 *      &lt;server&gt;...&lt;/server&gt;
 *      &lt;port&gt;80&lt;/port&gt;
 *      &lt;nt-domain&gt;...&lt;/nt-domain&gt;
 *      &lt;username&gt;...&lt;/username&gt;
 *      &lt;password&gt;...&lt;/password&gt;
 *  &lt;/external-proxy&gt;
 *  </pre>
 *
 * @param id         The id of the destination.
 * @param properties Properties for the <code>Destination</code>.
 */
public void initialize(String id, ConfigMap properties) {
    super.initialize(id, properties);

    if (properties == null || properties.size() == 0)
        return;

    // Connection Manager
    ConfigMap conn = properties.getPropertyAsMap(HTTPConnectionManagerSettings.CONNECTION_MANAGER, null);
    if (conn != null) {
        // Cookie policy.
        if (conn.getProperty(HTTPConnectionManagerSettings.COOKIE_POLICY) != null) {
            connectionManagerSettings.setCookiePolicy(conn
                    .getPropertyAsString(HTTPConnectionManagerSettings.COOKIE_POLICY, CookiePolicy.DEFAULT));
        }

        // Max Connections Total
        if (conn.getProperty(HTTPConnectionManagerSettings.MAX_TOTAL_CONNECTIONS) != null) {
            int maxTotal = conn.getPropertyAsInt(HTTPConnectionManagerSettings.MAX_TOTAL_CONNECTIONS,
                    MultiThreadedHttpConnectionManager.DEFAULT_MAX_TOTAL_CONNECTIONS);
            connectionManagerSettings.setMaxTotalConnections(maxTotal);
        }

        // Default Max Connections Per Host
        int defaultMaxConnsPerHost = MultiThreadedHttpConnectionManager.DEFAULT_MAX_HOST_CONNECTIONS;
        if (conn.getProperty(HTTPConnectionManagerSettings.DEFAULT_MAX_CONNECTIONS_PER_HOST) != null) {
            defaultMaxConnsPerHost = conn.getPropertyAsInt(
                    HTTPConnectionManagerSettings.DEFAULT_MAX_CONNECTIONS_PER_HOST,
                    MultiThreadedHttpConnectionManager.DEFAULT_MAX_HOST_CONNECTIONS);
            connectionManagerSettings.setDefaultMaxConnectionsPerHost(defaultMaxConnsPerHost);
        }

        // Connection Timeout
        if (conn.getProperty(HTTPConnectionManagerSettings.CONNECTION_TIMEOUT) != null) {
            int timeout = conn.getPropertyAsInt(HTTPConnectionManagerSettings.CONNECTION_TIMEOUT, 0);
            if (timeout >= 0)
                connectionManagerSettings.setConnectionTimeout(timeout);
        }

        // Socket Timeout
        if (conn.getProperty(HTTPConnectionManagerSettings.SOCKET_TIMEOUT) != null) {
            int timeout = conn.getPropertyAsInt(HTTPConnectionManagerSettings.SOCKET_TIMEOUT, 0);
            if (timeout >= 0)
                connectionManagerSettings.setSocketTimeout(timeout);
        }

        // Stale Checking
        if (conn.getProperty(HTTPConnectionManagerSettings.STALE_CHECKING_ENABLED) != null) {
            boolean staleCheck = conn.getPropertyAsBoolean(HTTPConnectionManagerSettings.STALE_CHECKING_ENABLED,
                    true);
            connectionManagerSettings.setStaleCheckingEnabled(staleCheck);
        }

        // Send Buffer Size
        if (conn.getProperty(HTTPConnectionManagerSettings.SEND_BUFFER_SIZE) != null) {
            int bufferSize = conn.getPropertyAsInt(HTTPConnectionManagerSettings.SEND_BUFFER_SIZE, 0);
            if (bufferSize > 0)
                connectionManagerSettings.setSendBufferSize(bufferSize);
        }

        // Send Receive Size
        if (conn.getProperty(HTTPConnectionManagerSettings.RECEIVE_BUFFER_SIZE) != null) {
            int bufferSize = conn.getPropertyAsInt(HTTPConnectionManagerSettings.RECEIVE_BUFFER_SIZE, 0);
            if (bufferSize > 0)
                connectionManagerSettings.setReceiveBufferSize(bufferSize);
        }

        // TCP No Delay (Nagel's Algorithm)
        if (conn.getProperty(HTTPConnectionManagerSettings.TCP_NO_DELAY) != null) {
            boolean noNagel = conn.getPropertyAsBoolean(HTTPConnectionManagerSettings.TCP_NO_DELAY, true);
            connectionManagerSettings.setTcpNoDelay(noNagel);
        }

        // Linger
        if (conn.getProperty(HTTPConnectionManagerSettings.LINGER) != null) {
            int linger = conn.getPropertyAsInt(HTTPConnectionManagerSettings.LINGER, -1);
            connectionManagerSettings.setLinger(linger);
        }

        // Max Connections Per Host
        List hosts = conn.getPropertyAsList(HTTPConnectionManagerSettings.MAX_PER_HOST, null);
        if (hosts != null) {
            List hostSettings = new ArrayList();
            Iterator it = hosts.iterator();
            while (it.hasNext()) {
                ConfigMap maxPerHost = (ConfigMap) it.next();
                HostConfigurationSettings hostConfig = new HostConfigurationSettings();

                // max-connections
                if (maxPerHost.getProperty(HostConfigurationSettings.MAX_CONNECTIONS) != null) {
                    int maxConn = maxPerHost.getPropertyAsInt(HostConfigurationSettings.MAX_CONNECTIONS,
                            defaultMaxConnsPerHost);
                    hostConfig.setMaximumConnections(maxConn);
                }

                // host
                if (maxPerHost.getProperty(HostConfigurationSettings.HOST) != null) {
                    String host = maxPerHost.getPropertyAsString(HostConfigurationSettings.HOST, null);
                    hostConfig.setHost(host);
                    if (host != null) {
                        // port
                        int port = maxPerHost.getPropertyAsInt(HostConfigurationSettings.PORT, 0);
                        hostConfig.setPort(port);

                        // protocol-factory
                        ConfigMap factoryMap = maxPerHost
                                .getPropertyAsMap(HostConfigurationSettings.PROTOCOL_FACFORY, null);
                        if (factoryMap != null) {
                            String className = factoryMap.getPropertyAsString(CLASS, null);
                            if (className != null) {
                                Class factoryClass = ClassUtil.createClass(className);
                                ProtocolFactory protocolFactory = (ProtocolFactory) ClassUtil
                                        .createDefaultInstance(factoryClass, ProtocolFactory.class);
                                String factoryId = factoryMap.getPropertyAsString(ID,
                                        host + "_protocol_factory");
                                ConfigMap protocolProperties = factoryMap.getPropertyAsMap(PROPERTIES, null);
                                protocolFactory.initialize(factoryId, protocolProperties);
                            }
                        }
                        // protocol
                        else {
                            String protocol = maxPerHost.getPropertyAsString(HostConfigurationSettings.PROTOCOL,
                                    null);
                            hostConfig.setProtocol(protocol);
                        }
                    }
                }

                // proxy
                ConfigMap proxy = maxPerHost.getPropertyAsMap(HostConfigurationSettings.PROXY, null);
                if (proxy != null) {
                    // host
                    String proxyHost = proxy.getPropertyAsString(HostConfigurationSettings.HOST, null);
                    hostConfig.setProxyHost(proxyHost);
                    if (proxyHost != null) {
                        // port
                        int port = proxy.getPropertyAsInt(HostConfigurationSettings.PORT, 0);
                        hostConfig.setProxyPort(port);
                    }
                }

                // local-address
                if (maxPerHost.getProperty(HostConfigurationSettings.LOCAL_ADDRESS) != null) {
                    String localAddress = maxPerHost
                            .getPropertyAsString(HostConfigurationSettings.LOCAL_ADDRESS, null);
                    hostConfig.setLocalAddress(localAddress);
                }

                // virtual-host
                if (maxPerHost.getProperty(HostConfigurationSettings.VIRTUAL_HOST) != null) {
                    String virtualHost = maxPerHost.getPropertyAsString(HostConfigurationSettings.VIRTUAL_HOST,
                            null);
                    hostConfig.setVirtualHost(virtualHost);
                }
                hostSettings.add(hostConfig);
            }

            if (hostSettings.size() > 0)
                connectionManagerSettings.setMaxConnectionsPerHost(hostSettings);
        }
        setConnectionManagerSettings(connectionManagerSettings);
    }

    // Cookie Limit
    if (properties.getProperty(COOKIE_LIMIT) != null) {
        int cl = properties.getPropertyAsInt(COOKIE_LIMIT, DEFAULT_COOKIE_LIMIT);
        setCookieLimit(cl);
    }

    // Allow Lax SSL
    if (properties.getProperty(ALLOW_LAX_SSL) != null) {
        boolean lax = properties.getPropertyAsBoolean(ALLOW_LAX_SSL, false);
        setAllowLaxSSL(lax);
    }

    // Content Chunked
    if (properties.getProperty(CONTENT_CHUNKED) != null) {
        boolean ch = properties.getPropertyAsBoolean(CONTENT_CHUNKED, false);
        setContentChunked(ch);
    }

    // External Proxy
    ConfigMap extern = properties.getPropertyAsMap(ExternalProxySettings.EXTERNAL_PROXY, null);
    if (extern != null) {
        ExternalProxySettings proxy = new ExternalProxySettings();

        String proxyServer = extern.getPropertyAsString(ExternalProxySettings.SERVER, null);
        proxy.setProxyServer(proxyServer);
        int proxyPort = extern.getPropertyAsInt(ExternalProxySettings.PORT,
                ExternalProxySettings.DEFAULT_PROXY_PORT);
        proxy.setProxyPort(proxyPort);
        String ntdomain = extern.getPropertyAsString(ExternalProxySettings.NT_DOMAIN, null);
        proxy.setNTDomain(ntdomain);
        String username = extern.getPropertyAsString(ExternalProxySettings.USERNAME, null);
        proxy.setUsername(username);
        String password = extern.getPropertyAsString(ExternalProxySettings.PASSWORD, null);
        proxy.setPassword(password);

        setExternalProxySettings(proxy);
    }
}

From source file:org.apache.abdera.protocol.client.AbderaClient.java

/**
 * Return the maximum number of connections allowed for a single host
 *///from   ww  w . j a  v a 2  s  .  c  o m
public int getMaxConnectionsPerHost() {
    Map<HostConfiguration, Integer> m = (Map<HostConfiguration, Integer>) client.getHttpConnectionManager()
            .getParams().getParameter(HttpConnectionManagerParams.MAX_HOST_CONNECTIONS);
    if (m == null)
        return MultiThreadedHttpConnectionManager.DEFAULT_MAX_HOST_CONNECTIONS;
    Integer i = m.get(HostConfiguration.ANY_HOST_CONFIGURATION);
    return i != null ? i.intValue() : MultiThreadedHttpConnectionManager.DEFAULT_MAX_HOST_CONNECTIONS;
}

Example usage for org.apache.commons.httpclient MultiThreadedHttpConnectionManager DEFAULT_MAX_HOST_CONNECTIONS

Introduction

Prototype

Usage