/*
* HttpFactory.java
*
* ====================================================================
*
* Copyright 2006 The Apache Software Foundation
*
* Licensed 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.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
* Created on May 25, 2006, 10:11 AM
*
*/
package org.apache.axis2.transport.http.server;
import edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue;
import edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue;
import edu.emory.mathcs.backport.java.util.concurrent.ExecutorService;
import edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor;
import edu.emory.mathcs.backport.java.util.concurrent.TimeUnit;
import java.io.IOException;
import javax.xml.namespace.QName;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.description.TransportInDescription;
import org.apache.axis2.engine.ListenerManager;
import org.apache.axis2.transport.http.HTTPWorkerFactory;
import org.apache.http.HttpServerConnection;
import org.apache.http.impl.DefaultHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
/**
* Factory used to configure and create the various instances required in http transports.
* Either configure this class in axis2.xml, or in code via the setters, or subclass it and specialize some factory methods to gain more control.
*
* @author Chuck Williams
*/
public class HttpFactory {
/** Name of axis2.xml port parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_PORT = "port";
/** Name of axis2.xml hostname parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_HOST_ADDRESS = "hostname";
/** Name of axis2.xml originServer parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_ORIGIN_SERVER = "originServer";
/** Name of axis2.xml requestTimeout parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_REQUEST_SOCKET_TIMEOUT = "requestTimeout";
/** Name of axis2.xml requestTcpNoDelay parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_REQUEST_TCP_NO_DELAY = "requestTcpNoDelay";
/** Name of axis2.xml requestCoreThreadPoolSize parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_REQUEST_CORE_THREAD_POOL_SIZE = "requestCoreThreadPoolSize";
/** Name of axis2.xml requestMaxThreadPoolSize parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_REQUEST_MAX_THREAD_POOL_SIZE = "requestMaxThreadPoolSize";
/** Name of axis2.xml threadKeepAliveTime parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_THREAD_KEEP_ALIVE_TIME = "threadKeepAliveTime";
/** Name of axis2.xml threadKeepAliveTimeUnit parameter for SimpleHTTPServer configuration */
public static final String PARAMETER_THREAD_KEEP_ALIVE_TIME_UNIT = "threadKeepAliveTimeUnit";
private ConfigurationContext configurationContext;
private TransportInDescription httpConfiguration;
private int port;
private String hostAddress;
private String originServer;
private int requestSocketTimeout;
private boolean requestTcpNoDelay;
private int requestCoreThreadPoolSize;
private int requestMaxThreadPoolSize;
private long threadKeepAliveTime;
private TimeUnit threadKeepAliveTimeUnit;
private WorkerFactory requestWorkerFactory = null;
private static final QName HTTP_NAME = new QName(Constants.TRANSPORT_HTTP);
/** Create and configure a new HttpFactory */
public HttpFactory(ConfigurationContext configurationContext) throws AxisFault {
this.configurationContext = configurationContext;
httpConfiguration = configurationContext.getAxisConfiguration().getTransportIn(HTTP_NAME);
port = getIntParam(PARAMETER_PORT, 6060);
hostAddress = getStringParam(PARAMETER_HOST_ADDRESS, null);
originServer = getStringParam(PARAMETER_ORIGIN_SERVER, "Simple-Server/1.1");
requestSocketTimeout = getIntParam(PARAMETER_REQUEST_SOCKET_TIMEOUT, 20000);
requestTcpNoDelay = getBooleanParam(PARAMETER_REQUEST_TCP_NO_DELAY, true);
requestCoreThreadPoolSize = getIntParam(PARAMETER_REQUEST_CORE_THREAD_POOL_SIZE, 25);
requestMaxThreadPoolSize = getIntParam(PARAMETER_REQUEST_MAX_THREAD_POOL_SIZE, 150);
threadKeepAliveTime = getLongParam(PARAMETER_THREAD_KEEP_ALIVE_TIME, 180L);
threadKeepAliveTimeUnit = getTimeUnitParam(PARAMETER_THREAD_KEEP_ALIVE_TIME_UNIT, TimeUnit.SECONDS);
}
/** Create and configure a new HttpFactory */
public HttpFactory(ConfigurationContext configurationContext, int port) throws AxisFault {
this(configurationContext);
this.port = port;
}
/** Create and configure a new HttpFactory */
public HttpFactory(ConfigurationContext configurationContext, int port, WorkerFactory requestWorkerFactory) throws AxisFault {
this(configurationContext, port);
this.requestWorkerFactory = requestWorkerFactory;
}
private int getIntParam(String name, int def) {
String config = getStringParam(name, null);
if (config!=null)
return Integer.parseInt(config);
else
return def;
}
private long getLongParam(String name, long def) {
String config = getStringParam(name, null);
if (config!=null)
return Long.parseLong(config);
else
return def;
}
private boolean getBooleanParam(String name, boolean def) throws AxisFault {
String config = getStringParam(name, null);
if (config!=null) {
if (config.equals("yes") || config.equals("true"))
return true;
else if (config.equals("no") || config.equals("false"))
return false;
else throw new AxisFault("Boolean value must be yes, true, no or false for parameter " + name + ": " + config);
}
return def;
}
private TimeUnit getTimeUnitParam(String name, TimeUnit def) throws AxisFault {
String config = getStringParam(name, null);
if (config!=null)
try {
return (TimeUnit) TimeUnit.class.getField(config).get(null);
} catch (Exception e) {
throw new AxisFault(e);
}
return def;
}
private String getStringParam(String name, String def) {
Parameter param = httpConfiguration.getParameter(name);
if (param!=null) {
// assert param.getParameterType() == Parameter.TEXT_PARAMETER;
String config = (String) param.getValue();
if (config!=null)
return config;
}
return def;
}
/** Return the configured listener manager or create and configure one with configurationContext */
public ListenerManager getListenerManager() {
ListenerManager lm = configurationContext.getListenerManager();
if (lm==null) {
lm = new ListenerManager();
lm.init(configurationContext);
}
return lm;
}
/** Create the executor used to launch the single requestConnectionListener */
public ExecutorService newListenerExecutor(int port) {
return new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue(),
new DefaultThreadFactory(new ThreadGroup("Listener thread group"), "HttpListener-" + this.port));
}
/** Create the listener for request connections */
public IOProcessor newRequestConnectionListener(HttpConnectionFactory factory, HttpConnectionManager manager, int port) throws IOException {
return new DefaultConnectionListener(port, factory, manager);
}
/** Create a request connection */
public HttpConnectionFactory newRequestConnectionFactory(HttpParams params) {
return new DefaultHttpConnectionFactory(params);
}
/** Create and set the parameters applied to incoming request connections */
public HttpParams newRequestConnectionParams() {
HttpParams params = new DefaultHttpParams();
params
.setIntParameter(HttpConnectionParams.SO_TIMEOUT, requestSocketTimeout)
.setBooleanParameter(HttpConnectionParams.TCP_NODELAY, requestTcpNoDelay)
.setIntParameter(HttpConnectionParams.MAX_LINE_LENGTH, 4000)
.setIntParameter(HttpConnectionParams.MAX_HEADER_COUNT, 500)
.setParameter(HttpProtocolParams.ORIGIN_SERVER, originServer);
return params;
}
/** Create the connection manager used to launch request threads */
public HttpConnectionManager newRequestConnectionManager(ExecutorService requestExecutor, WorkerFactory workerFactory, HttpParams params) {
return new DefaultHttpConnectionManager(configurationContext, requestExecutor, workerFactory, params);
}
/** Create the executor use the manage request processing threads */
public ExecutorService newRequestExecutor(int port) {
return new ThreadPoolExecutor(requestCoreThreadPoolSize, requestMaxThreadPoolSize, threadKeepAliveTime, threadKeepAliveTimeUnit,
newRequestBlockingQueue(),
new DefaultThreadFactory(new ThreadGroup("Connection thread group"), "HttpConnection-" + port));
}
/** Create the queue used to hold incoming requests when requestCoreThreadPoolSize threads are busy.
* Default is an unbounded queue.
*/
public BlockingQueue newRequestBlockingQueue() {
return new LinkedBlockingQueue();
}
/** Create the factory for request workers */
public WorkerFactory newRequestWorkerFactory() {
if (requestWorkerFactory!=null)
return requestWorkerFactory;
else
return new HTTPWorkerFactory();
}
/** Create a request service processor to populate the response */
public HttpServiceProcessor newRequestServiceProcessor(
final HttpServerConnection connection,
final SessionManager sessionManager,
final Worker worker,
final IOProcessorCallback callback) {
return new DefaultHttpServiceProcessor(connection, configurationContext, sessionManager, worker, callback);
}
// *****
// Getters and Setters
// *****
/** Getter for configurationContext */
public ConfigurationContext getConfigurationContext() {
return configurationContext;
}
/** Getter for httpConfiguration */
public TransportInDescription getHttpConfiguration() {
return httpConfiguration;
}
/** Getter for port
* return the port on which to listen for http connections (default = 6060)
*/
public int getPort() {
return port;
}
/** Setter for port */
public void setPort(int port) {
this.port = port;
}
/** Getter for hostAddress
* @return the host address (or name) to be use in reply-to endpoint references, or null if not specified (default = null)
*/
public String getHostAddress() {
return hostAddress;
}
/** Setter for hostAddress */
public void setHostAddress(String hostAddress) {
this.hostAddress = hostAddress;
}
/** Getter for originServer
* @return the Server header string for outgoing messages (default "Simple-Server/1.1")
*/
public String getOriginServer() {
return originServer;
}
/** Setter for originServer */
public void setOriginServer(String originServer) {
this.originServer = originServer;
}
/** Getter for requestSocketTimeout
* @return the maximum time in millis to wait for data on a request socket (default 20000)
*/
public int getRequestSocketTimeout() {
return requestSocketTimeout;
}
/** Setter for requestSocketTimeout */
public void setRequestSocketTimeout(int requestSocketTimeout) {
this.requestSocketTimeout = requestSocketTimeout;
}
/** Getter for requestTcpNoDelay
* return false iff Nagle's algorithm should be used to conserve bandwidth by minimizing segments
* at the cost of latency and performance (default true, i.e. maximize performance at
* the cost of bandwidth)
*/
public boolean getRequestTcpNoDelay() {
return requestTcpNoDelay;
}
/** Setter for requestTcpNoDelay */
public void setRequestTcpNoDelay(boolean requestTcpNoDelay) {
this.requestTcpNoDelay = requestTcpNoDelay;
}
/** Getter for RequestCoreThreadPoolSize
* @return the size of the thread pool use to process requests assuming there is adequate queue space (default 25)
*/
public int getRequestCoreThreadPoolSize() {
return requestCoreThreadPoolSize;
}
/** Setter for RequestCoreThreadPoolSize */
public void setRequestCoreThreadPoolSize(int requestCoreThreadPoolSize) {
this.requestCoreThreadPoolSize = requestCoreThreadPoolSize;
}
/** Getter for requestMaxThreadPoolSize
* @return the maximum size of the thread pool used to process requests if the queue fills up (default 150).
* Since the default queue is unbounded this parameter is meaningless unless you override newRequestBlockingQueue()
*/
public int getRequestMaxThreadPoolSize() {
return requestMaxThreadPoolSize;
}
/** Setter for requestMaxThreadPoolSize */
public void setRequestMaxThreadPoolSize(int requestMaxThreadPoolSize) {
this.requestMaxThreadPoolSize = requestMaxThreadPoolSize;
}
/** Getter for threadKeepAliveTime
* @return how long a request processing thread in excess of the core pool size will be kept alive it if is inactive
* (default with threadKeepAliveTimeUnit to 180 seconds)
*/
public long getThreadKeepAliveTime() {
return threadKeepAliveTime;
}
/** Setter for threadKeepAliveTime */
public void setThreadKeepAliveTime(long threadKeepAliveTime) {
this.threadKeepAliveTime = threadKeepAliveTime;
}
/** Getter for threadKeepAliveTimeUnit
* return the time unit for threadKeepAliveTime (default SECONDS)
*/
public TimeUnit getThreadKeepAliveTimeUnit() {
return threadKeepAliveTimeUnit;
}
/** Setter for threadKeepAliveTimeUnit */
public void setThreadKeepAliveTimeUnit(TimeUnit threadKeepAliveTimeUnit) {
this.threadKeepAliveTimeUnit = threadKeepAliveTimeUnit;
}
}