org.opensaml.ws.soap.client.http.HttpClientBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of openws Show documentation
The OpenWS library provides a growing set of tools to work with web services at a low level. These tools include classes for creating and reading SOAP messages, transport-independent clients for connecting to web services, and various transports for use with those clients.
The newest version!
/*
 * Licensed to the University Corporation for Advanced Internet Development, 
 * Inc. (UCAID) under one or more contributor license agreements.  See the 
 * NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The UCAID licenses this file to You under the Apache 
 * License, Version 2.0 (the "License"); you may not use this file except in 
 * compliance with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.opensaml.ws.soap.client.http;

import net.jcip.annotations.NotThreadSafe;

import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.params.HttpClientParams;
import org.apache.commons.httpclient.params.HttpConnectionManagerParams;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;
import org.opensaml.xml.util.DatatypeHelper;

/**
 * A builder for {@link HttpClient}s.
 * 
 * This builder will produce clients that employ the {@link MultiThreadedHttpConnectionManager} and as such users of the
 * clients MUST be sure to invoke {@link org.apache.commons.httpclient.HttpMethod#releaseConnection()} after they have
 * finished with the method.
 */
@NotThreadSafe
public class HttpClientBuilder {

    /** Host name of the HTTP proxy server through which connections will be made. */
    private String proxyHost;

    /** Port number of the HTTP proxy server through which connections will be made. */
    private int proxyPort;

    /** Username used to connect to the HTTP proxy server. */
    private String proxyUsername;

    /** Password used to connect to the HTTP proxy server. */
    private String proxyPassword;

    /** Whether authentication should be performed preemptively, defaults to false. */
    private boolean preemptiveAuthentication;

    /** Character set used for HTTP content, defaults to UTF-8. */
    private String contentCharSet;

    /** Amount of time, in milliseconds, to wait for a connection to be established, default is 5,000. */
    private int connectionTimeout;

    /** Size of the buffer, in bytes, used to hold outbound information, defaults to 4,096. */
    private int sendBufferSize;

    /** Size of the buffer, in bytes, used to hold inbound information, defaults to 16,384. */
    private int receiveBufferSize;

    /** Whether to use TCP No Delay algorithm, defaults to true. */
    private boolean tcpNoDelay;

    /** Total number of connections allowed to a specific host, defaults to 5. */
    private int maxConnectionsPerHost;

    /** Total number of connections allowed to all hosts, defaults to 20. */
    private int maxTotalConnectons;

    /** Number of times a failed connection to a host should be retried. */
    private int connectionRetryAttempts;

    /** Socket factory used for the 'https' scheme. */
    private SecureProtocolSocketFactory httpsProtocolSocketFactory;

    /** Constructor. */
    public HttpClientBuilder() {
        resetDefaults();
    }

    /** Resets the builder to its default values. */
    public void resetDefaults() {
        proxyPort = -1;
        preemptiveAuthentication = false;
        contentCharSet = "UTF-8";
        connectionTimeout = 5000;
        sendBufferSize = 4096;
        receiveBufferSize = 16384;
        tcpNoDelay = true;
        maxConnectionsPerHost = 5;
        maxTotalConnectons = 20;
        connectionRetryAttempts = 0;
    }

    /**
     * Builds an HTTP client with the given settings. Settings are NOT reset to their default values after a client has
     * been created.
     * 
     * @return the created client.
     */
    public HttpClient buildClient() {
        if (httpsProtocolSocketFactory != null) {
            Protocol.registerProtocol("https", new Protocol("https", httpsProtocolSocketFactory, 443));
        }

        HttpClientParams clientParams = new HttpClientParams();
        clientParams.setAuthenticationPreemptive(isPreemptiveAuthentication());
        clientParams.setContentCharset(getContentCharSet());
        clientParams.setParameter(HttpClientParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(
                connectionRetryAttempts, false));

        HttpConnectionManagerParams connMgrParams = new HttpConnectionManagerParams();
        connMgrParams.setConnectionTimeout(getConnectionTimeout());
        connMgrParams.setDefaultMaxConnectionsPerHost(getMaxConnectionsPerHost());
        connMgrParams.setMaxTotalConnections(getMaxTotalConnections());
        connMgrParams.setReceiveBufferSize(getReceiveBufferSize());
        connMgrParams.setSendBufferSize(getSendBufferSize());
        connMgrParams.setTcpNoDelay(isTcpNoDelay());

        MultiThreadedHttpConnectionManager connMgr = new MultiThreadedHttpConnectionManager();
        connMgr.setParams(connMgrParams);

        HttpClient httpClient = new HttpClient(clientParams, connMgr);

        if (proxyHost != null) {
            HostConfiguration hostConfig = new HostConfiguration();
            hostConfig.setProxy(proxyHost, proxyPort);
            httpClient.setHostConfiguration(hostConfig);

            if (proxyUsername != null) {
                AuthScope proxyAuthScope = new AuthScope(proxyHost, proxyPort);
                UsernamePasswordCredentials proxyCredentials = new UsernamePasswordCredentials(proxyUsername,
                        proxyPassword);
                httpClient.getState().setProxyCredentials(proxyAuthScope, proxyCredentials);
            }
        }

        return httpClient;
    }

    /**
     * Gets the host name of the HTTP proxy server through which connections will be made.
     * 
     * @return host name of the HTTP proxy server through which connections will be made
     */
    public String getProxyHost() {
        return proxyHost;
    }

    /**
     * Sets the host name of the HTTP proxy server through which connections will be made.
     * 
     * @param host host name of the HTTP proxy server through which connections will be made
     */
    public void setProxyHost(String host) {
        proxyHost = DatatypeHelper.safeTrimOrNullString(host);
    }

    /**
     * Gets the port of the HTTP proxy server through which connections will be made.
     * 
     * @return port of the HTTP proxy server through which connections will be made
     */
    public int getProxyPort() {
        return proxyPort;
    }

    /**
     * Sets the port of the HTTP proxy server through which connections will be made.
     * 
     * @param port port of the HTTP proxy server through which connections will be made
     */
    public void setProxyPort(int port) {
        proxyPort = port;
    }

    /**
     * Gets the username used to connect to the HTTP proxy server.
     * 
     * @return username used to connect to the HTTP proxy server
     */
    public String getProxyUsername() {
        return proxyUsername;
    }

    /**
     * Sets the username used to connect to the HTTP proxy server.
     * 
     * @param username username used to connect to the HTTP proxy server
     */
    public void setProxyUsername(String username) {
        proxyUsername = DatatypeHelper.safeTrimOrNullString(username);
    }

    /**
     * Gets the password used to connect to the HTTP proxy server.
     * 
     * @return password used to connect to the HTTP proxy server
     */
    public String getProxyPassword() {
        return proxyPassword;
    }

    /**
     * Sets the password used to connect to the HTTP proxy server.
     * 
     * @param password password used to connect to the HTTP proxy server
     */
    public void setProxyPassword(String password) {
        proxyPassword = DatatypeHelper.safeTrimOrNullString(password);
    }

    /**
     * Gets whether authentication is performed preemptively. Default value is false.
     * 
     * @return whether authentication is performed preemptively
     */
    public boolean isPreemptiveAuthentication() {
        return preemptiveAuthentication;
    }

    /**
     * Sets whether authentication is performed preemptively.
     * 
     * @param preemptive whether authentication is performed preemptively
     */
    public void setPreemptiveAuthentication(boolean preemptive) {
        preemptiveAuthentication = preemptive;
    }

    /**
     * Gets the character set used for HTTP content. Default value is UTF-8.
     * 
     * @return character set used for HTTP content
     */
    public String getContentCharSet() {
        return contentCharSet;
    }

    /**
     * Sets the character set used for HTTP content.
     * 
     * @param charSet character set used for HTTP content
     */
    public void setContentCharSet(String charSet) {
        contentCharSet = charSet;
    }

    /**
     * Gets the time, in milliseconds, to wait for connection establishments. Default value is 5,000. A value of 0
     * indicates there is no timeout.
     * 
     * @return time, in milliseconds, to wait for connection establishments
     */
    public int getConnectionTimeout() {
        return connectionTimeout;
    }

    /**
     * Sets the time, in milliseconds, to wait for connection establishments. A value of 0 indicates there is no
     * timeout.
     * 
     * @param timeout time, in milliseconds, to wait for connection establishments
     */
    public void setConnectionTimeout(int timeout) {
        connectionTimeout = timeout;
    }

    /**
     * Gets the size of buffer, in bytes, used when sending content. Default value is 4,096.
     * 
     * @return size of buffer, in bytes, used when sending content
     */
    public int getSendBufferSize() {
        return sendBufferSize;
    }

    /**
     * Sets the size of buffer, in bytes, used when sending content.
     * 
     * @param size size of buffer, in bytes, used when sending content
     */
    public void setSendBufferSize(int size) {
        sendBufferSize = size;
    }

    /**
     * Gets the size of buffer, in bytes, used when receiving content. Default value is 16,384.
     * 
     * @return size of buffer, in bytes, used when sending content
     */
    public int getReceiveBufferSize() {
        return receiveBufferSize;
    }

    /**
     * Sets the size of buffer, in bytes, used when sending content.
     * 
     * @param size size of buffer, in bytes, used when sending content
     */
    public void setReceiveBufferSize(int size) {
        receiveBufferSize = size;
    }

    /**
     * Gets whether to use TCP No Delay when sending data. Default value is true.
     * 
     * @return whether to use TCP No Delay when sending data
     */
    public boolean isTcpNoDelay() {
        return tcpNoDelay;
    }

    /**
     * Sets whether to use TCP No Delay when sending data.
     * 
     * @param noDelay whether to use TCP No Delay when sending data
     */
    public void setTcpNoDelay(boolean noDelay) {
        tcpNoDelay = noDelay;
    }

    /**
     * Gets the maximum number of connections, per host, that the client will create. Default value is 5. A value of 0
     * indicates there is no maximum.
     * 
     * @return maximum number of connections, per host, that the client will create
     */
    public int getMaxConnectionsPerHost() {
        return maxConnectionsPerHost;
    }

    /**
     * Sets the maximum number of connections, per host, that the client will create. A value of 0 indicates there is no
     * maximum.
     * 
     * @param max maximum number of connections, per host, that the client will create
     */
    public void setMaxConnectionsPerHost(int max) {
        maxConnectionsPerHost = max;
    }

    /**
     * Gets the maximum number of total connections the client will create. Default value is 20.
     * 
     * @return maximum number of total connections the client will create
     */
    public int getMaxTotalConnections() {
        return maxTotalConnectons;
    }

    /**
     * Sets the maximum number of total connections the client will create.
     * 
     * @param max maximum number of total connections the client will create, must be greater than zero
     */
    public void setMaxTotalConnections(int max) {
        if (max < 1) {
            throw new IllegalArgumentException("Maximum total number of connections must be greater than zero.");
        }
        maxTotalConnectons = max;
    }

    /**
     * Gets the number of times a connection will be tried if a host is unreachable.
     * 
     * @return number of times a connection will be tried if a host is unreachable
     */
    public int getConnectionRetryAttempts() {
        return connectionRetryAttempts;
    }

    /**
     * Sets the number of times a connection will be tried if a host is unreachable.
     * 
     * @param attempts number of times a connection will be tried if a host is unreachable
     */
    public void setConnectionRetryAttempts(int attempts) {
        connectionRetryAttempts = attempts;
    }

    /**
     * Gets the protocol socket factory used for the https scheme.
     * 
     * @return protocol socket factory used for the https scheme
     */
    public SecureProtocolSocketFactory getHttpsProtocolSocketFactory() {
        return httpsProtocolSocketFactory;
    }

    /**
     * Sets the protocol socket factory used for the https scheme.
     * 
     * @param factory the httpsProtocolSocketFactory to set
     */
    public void setHttpsProtocolSocketFactory(SecureProtocolSocketFactory factory) {
        httpsProtocolSocketFactory = factory;
    }
}