/* | |
* Licensed to the Apache Software Foundation (ASF) under one or more | |
* contributor license agreements. See the NOTICE file distributed with | |
* this work for additional information regarding copyright ownership. | |
* The ASF 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 flex.messaging.services.http; | |
import flex.management.runtime.messaging.services.http.HTTPProxyAdapterControl; | |
import flex.messaging.Destination; | |
import flex.messaging.FlexContext; | |
import flex.messaging.MessageException; | |
import flex.messaging.config.ConfigMap; | |
import flex.messaging.messages.AcknowledgeMessage; | |
import flex.messaging.messages.HTTPMessage; | |
import flex.messaging.messages.Message; | |
import flex.messaging.messages.SOAPMessage; | |
import flex.messaging.services.ServiceAdapter; | |
import flex.messaging.services.http.proxy.AccessFilter; | |
import flex.messaging.services.http.proxy.ErrorFilter; | |
import flex.messaging.services.http.proxy.ProxyContext; | |
import flex.messaging.services.http.proxy.ProxyContextFilter; | |
import flex.messaging.services.http.proxy.ProxyFilter; | |
import flex.messaging.services.http.proxy.RequestFilter; | |
import flex.messaging.services.http.proxy.ResponseFilter; | |
import flex.messaging.services.http.proxy.SecurityFilter; | |
import flex.messaging.services.http.proxy.Target; | |
import flex.messaging.util.ClassUtil; | |
import org.apache.commons.httpclient.HostConfiguration; | |
import org.apache.commons.httpclient.HttpConnectionManager; | |
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager; | |
import org.apache.commons.httpclient.NTCredentials; | |
import org.apache.commons.httpclient.UsernamePasswordCredentials; | |
import org.apache.commons.httpclient.cookie.CookiePolicy; | |
import org.apache.commons.httpclient.params.HostParams; | |
import org.apache.commons.httpclient.params.HttpClientParams; | |
import org.apache.commons.httpclient.params.HttpConnectionManagerParams; | |
import org.apache.commons.httpclient.protocol.Protocol; | |
import java.net.InetAddress; | |
import java.net.UnknownHostException; | |
import java.util.ArrayList; | |
import java.util.Iterator; | |
import java.util.List; | |
import java.util.Map; | |
/** | |
* Adapter class for proxy services. | |
*/ | |
public class HTTPProxyAdapter extends ServiceAdapter | |
{ | |
// NOTE: any changes to this class should also be made to the corresponding version in the .NET. | |
// The corresponding class is at src/dotNet/libs/FlexASPlib/Aspx/Proxy/ServiceProxyModule.cs | |
/** @exclude **/ | |
public static final String CONTENT_TYPE_XML = "application/xml"; | |
/** @exclude **/ | |
public static final String CONTENT_TYPE_FORM = "application/x-www-form-urlencoded"; | |
/** @exclude **/ | |
public static final int DEFAULT_COOKIE_LIMIT = 200; | |
private static final String COOKIE_LIMIT = "cookie-limit"; | |
private static final String ALLOW_LAX_SSL = "allow-lax-ssl"; | |
private static final String CONTENT_CHUNKED = "content-chunked"; | |
private static final String ID = "id"; | |
private static final String CLASS = "class"; | |
private static final String PROPERTIES = "properties"; | |
private static final String REQUEST_HEADERS = "requestHeaders"; | |
private static final String RESPONSE_HEADERS = "responseHeaders"; | |
// HTTPProxyAdapter's properties | |
protected boolean allowLaxSSL = false; | |
protected boolean contentChunked = false; | |
protected int cookieLimit = DEFAULT_COOKIE_LIMIT; | |
protected ExternalProxySettings externalProxy; | |
protected HTTPConnectionManagerSettings connectionManagerSettings; | |
// HTTPProxyAdapter internal | |
protected HttpConnectionManager connectionManager; | |
protected HttpConnectionManagerParams connectionParams; | |
protected ProxyFilter filterChain; | |
protected UsernamePasswordCredentials proxyCredentials; | |
private HTTPProxyAdapterControl controller; | |
//-------------------------------------------------------------------------- | |
// | |
// Constructor | |
// | |
//-------------------------------------------------------------------------- | |
/** | |
* Constructs an unmanaged <code>HTTPProxyAdapter</code> instance. | |
*/ | |
public HTTPProxyAdapter() | |
{ | |
this(false); | |
} | |
/** | |
* Constructs a <code>HTTPProxyAdapter</code> instance. | |
* | |
* @param enableManagement <code>true</code> if the <code>HTTPProxyAdapter</code> has a | |
* corresponding MBean control for management; otherwise <code>false</code>. | |
*/ | |
public HTTPProxyAdapter(boolean enableManagement) | |
{ | |
super(enableManagement); | |
createFilterChain(); | |
externalProxy = new ExternalProxySettings(); | |
connectionManagerSettings = new HTTPConnectionManagerSettings(); | |
} | |
//-------------------------------------------------------------------------- | |
// | |
// Initialize, validate, start, and stop methods. | |
// | |
//-------------------------------------------------------------------------- | |
/** | |
* Initializes the <code>HTTPProxyAdapter</code> with the properties. | |
* | |
* <pre> | |
* <connection-manager> | |
* <cookie-policy>rfc2109</cookie-policy> | |
* <max-total-connections>100</max-total-connections> | |
* <default-max-connections-per-host>2</default-max-connections-per-host> | |
* <connection-timeout>0</connection-timeout> | |
* <socket-timeout></socket-timeout> | |
* <stale-checking-enabled></stale-checking-enabled> | |
* <send-buffer-size></send-buffer-size> | |
* <receive-buffer-size></receive-buffer-size> | |
* <tcp-no-delay>true</tcp-no-delay> | |
* <linger>-1</linger> | |
* <max-per-host> | |
* <host>...</host> | |
* <port>80</port> | |
* <protocol>http</protocol> | |
* <protocol-factory class="flex.messaging.services.http.ProtocolFactory"> | |
* <properties>...</properties> | |
* </protocol-factory> | |
* <max-connections>2</max-connections> | |
* <proxy> | |
* <host>...</host> | |
* <port>80</port> | |
* </proxy> | |
* <local-address>...</local-address> | |
* <virtual-host>...</virtual-host> | |
* </max-per-host> | |
* </connection-manager> | |
* <cookie-limit>200</cookie-limit> | |
* <allow-lax-ssl>false</allow-lax-ssl> | |
* <content-chunked>false</content-chunked> | |
* <external-proxy> | |
* <server>...</server> | |
* <port>80</port> | |
* <nt-domain>...</nt-domain> | |
* <username>...</username> | |
* <password>...</password> | |
* </external-proxy> | |
* </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); | |
} | |
} | |
//-------------------------------------------------------------------------- | |
// | |
// Public Getters and Setters for Destination properties | |
// | |
//-------------------------------------------------------------------------- | |
/** | |
* Returns <code>allow-lax-ssl</code> property. | |
* | |
* @return <code>true</code> if <code>allow-lax-ssl</code> property is | |
* <code>true</code>; otherwise <code>false</code>. | |
*/ | |
public boolean isAllowLaxSSL() | |
{ | |
return allowLaxSSL; | |
} | |
/** | |
* Sets <code>allow-lax-ssl</code> property which determines if self-signed | |
* certificates are allowed; should not be used in production. | |
* Default <code>false</code>. | |
* | |
* @param allowLaxSSL Whether lax SSL should be allowed. | |
*/ | |
public void setAllowLaxSSL(boolean allowLaxSSL) | |
{ | |
this.allowLaxSSL = allowLaxSSL; | |
} | |
/** | |
* Returns the <code>content-chunked</code> property. | |
* | |
* @return <code>true</code> if <code>content-chunked</code> property is | |
* <code>true</code>; otherwise <code>false</code>. | |
*/ | |
public boolean isContentChunked() | |
{ | |
return contentChunked; | |
} | |
/** | |
* Sets the <code>content-chunked</code> property. Default <code>false</code>. | |
* | |
* @param contentChunked The <code>content-chunked</code> property. | |
*/ | |
public void setContentChunked(boolean contentChunked) | |
{ | |
this.contentChunked = contentChunked; | |
} | |
/** | |
* Returns the <code>cookie-limit</code> property. | |
* | |
* @return The <code>cookie-limit</code> property. | |
*/ | |
public int getCookieLimit() | |
{ | |
return cookieLimit; | |
} | |
/** | |
* Sets the <code>cookie-limit</code> property. Default 200. | |
* | |
* @param cookieLimit The cookie limit for the proxy. | |
*/ | |
public void setCookieLimit(int cookieLimit) | |
{ | |
this.cookieLimit = cookieLimit; | |
} | |
/** | |
* Casts the <code>Destination</code> into <code>HTTPProxyDestination</code> | |
* and calls super.setDestination. | |
* @param destination The HTTP proxy destination. | |
*/ | |
public void setDestination(Destination destination) | |
{ | |
Destination dest = (HTTPProxyDestination) destination; | |
super.setDestination(dest); | |
} | |
/** | |
* Returns <code>ExternalProxySettings</code>. | |
* | |
* @return the <code>ExternalProxySettings</code> | |
*/ | |
public ExternalProxySettings getExternalProxySettings() | |
{ | |
return externalProxy; | |
} | |
/** | |
* Sets <code>ExternalProxySettings</code>. | |
* | |
* @param externalProxy The external proxy settings. | |
*/ | |
public void setExternalProxySettings(ExternalProxySettings externalProxy) | |
{ | |
this.externalProxy = externalProxy; | |
initExternalProxy(externalProxy); | |
} | |
/** | |
* Returns <code>HTTPConnectionManagerSettings</code>. | |
* | |
* @return the <code>HTTPConnectionManagerSettings</code> | |
*/ | |
public HTTPConnectionManagerSettings getConnectionManagerSettings() | |
{ | |
return connectionManagerSettings; | |
} | |
/** | |
* Sets <code>HTTPConnectionManagerSettings</code>. | |
* | |
* @param connectionManagerSettings The connection manager settings. | |
*/ | |
public void setConnectionManagerSettings(HTTPConnectionManagerSettings connectionManagerSettings) | |
{ | |
this.connectionManagerSettings = connectionManagerSettings; | |
initHttpConnectionManagerParams(connectionManagerSettings); | |
connectionManager = new MultiThreadedHttpConnectionManager(); | |
connectionManager.setParams(connectionParams); | |
} | |
//-------------------------------------------------------------------------- | |
// | |
// Other public APIs | |
// | |
//-------------------------------------------------------------------------- | |
/** {@inheritDoc} */ | |
public Object invoke(Message msg) | |
{ | |
HTTPMessage message = (HTTPMessage) msg; | |
ProxyContext context = new ProxyContext(); | |
// SOAPMessages should be sent through the SOAPProxyAdapter, but | |
// the default destination may be just to the HTTPProxyAdapter. | |
// We'll update the context just in case.... | |
if (message instanceof SOAPMessage) | |
context.setSoapRequest(true); | |
else | |
context.setSoapRequest(false); | |
setupContext(context, message); | |
try | |
{ | |
filterChain.invoke(context); | |
//TODO: Do we want a return type that encapsulates the response data? | |
// OUTPUT | |
AcknowledgeMessage ack = new AcknowledgeMessage(); | |
ack.setBody(context.getResponse()); | |
ack.setHeader(Message.STATUS_CODE_HEADER, context.getStatusCode()); | |
if (context.getRecordHeaders()) | |
{ | |
ack.setHeader(REQUEST_HEADERS, context.getRequestHeaders()); | |
ack.setHeader(RESPONSE_HEADERS, context.getResponseHeaders()); | |
} | |
return ack; | |
} | |
catch (MessageException ex) | |
{ | |
throw ex; | |
} | |
catch (Throwable t) | |
{ | |
// this should never happen- ErrorFilter should catch everything | |
t.printStackTrace(); | |
throw new MessageException(t.toString()); | |
} | |
} | |
//-------------------------------------------------------------------------- | |
// | |
// Protected/private APIs | |
// | |
//-------------------------------------------------------------------------- | |
protected void setupContext(ProxyContext context, HTTPMessage message) | |
{ | |
Target target = new Target(); | |
context.setTarget(target); | |
context.setExternalProxySettings(externalProxy); | |
context.setProxyCredentials(proxyCredentials); | |
context.setConnectionManager(connectionManager); | |
context.setAllowLaxSSL(allowLaxSSL); | |
context.setContentChunked(contentChunked); | |
context.setRecordHeaders(message.getRecordHeaders()); | |
context.setCookieLimit(cookieLimit); | |
context.setHttpRequest(FlexContext.getHttpRequest() != null); | |
//TODO: QUESTION: Pete, Send HTTPHeaders as real headers | |
// INPUT | |
String url = message.getUrl(); | |
context.setUrl(url); | |
Map httpHeaders = message.getHttpHeaders(); | |
context.setHeaders(httpHeaders); | |
String method = message.getMethod(); | |
context.setMethod(method); | |
String contentType = message.getContentType(); | |
context.setContentType(contentType); | |
Object body = message.getBody(); | |
context.setBody(body); | |
target.setRemoteUsername(message.getRemoteUsername()); | |
target.setRemotePassword(message.getRemotePassword()); | |
HTTPProxyDestination destination = (HTTPProxyDestination)getDestination(); | |
target.setUseCustomAuthentication(destination.isUseCustomAuthentication()); | |
if (destination.getProtocolFactory() != null) | |
{ | |
ProtocolFactory protocolFactory = destination.getProtocolFactory(); | |
context.setProtocol(protocolFactory.getProtocol()); | |
} | |
} | |
/** | |
* Invoked automatically to allow the <code>HTTPProxyAdapter</code> to setup its corresponding | |
* MBean control. | |
* | |
* @param destination The <code>Destination</code> that manages this <code>HTTPProxyAdapter</code>. | |
*/ | |
protected void setupAdapterControl(Destination destination) | |
{ | |
controller = new HTTPProxyAdapterControl(this, destination.getControl()); | |
controller.register(); | |
setControl(controller); | |
} | |
/** | |
* Create default filter chain or return current one if already present. | |
*/ | |
private ProxyFilter createFilterChain() | |
{ | |
if (filterChain == null) | |
{ | |
// catch-all error filter | |
ErrorFilter errorFilter = new ErrorFilter(); | |
// check proxy access | |
AccessFilter accessFilter = new AccessFilter(); | |
// set up ProxyContext | |
ProxyContextFilter contextFilter = new ProxyContextFilter(); | |
// sends out response after further filters | |
ResponseFilter responseFilter = new ResponseFilter(); | |
// deals with credentials | |
SecurityFilter securityFilter = new SecurityFilter(); | |
// sends out the request | |
RequestFilter requestFilter = new RequestFilter(); | |
errorFilter.setNext(accessFilter); | |
accessFilter.setNext(contextFilter); | |
contextFilter.setNext(responseFilter); | |
responseFilter.setNext(securityFilter); | |
securityFilter.setNext(requestFilter); | |
filterChain = errorFilter; | |
} | |
return filterChain; | |
} | |
private void initExternalProxy(ExternalProxySettings ep) | |
{ | |
if (externalProxy != null) | |
{ | |
String proxyServer = externalProxy.getProxyServer(); | |
String proxyUsername = externalProxy.getUsername(); | |
if (proxyUsername != null) | |
{ | |
String proxyPassword = externalProxy.getPassword(); | |
String proxyDomain = externalProxy.getNTDomain(); | |
if (proxyDomain != null) | |
{ | |
proxyCredentials = new NTCredentials(proxyUsername, proxyPassword, proxyServer, proxyDomain); | |
} | |
else | |
{ | |
proxyCredentials = new UsernamePasswordCredentials(proxyUsername, proxyPassword); | |
} | |
} | |
} | |
} | |
private void initHttpConnectionManagerParams(HTTPConnectionManagerSettings settings) | |
{ | |
connectionParams = new HttpConnectionManagerParams(); | |
connectionParams.setMaxTotalConnections(settings.getMaxTotalConnections()); | |
connectionParams.setDefaultMaxConnectionsPerHost(settings.getDefaultMaxConnectionsPerHost()); | |
if (!settings.getCookiePolicy().equals(CookiePolicy.DEFAULT)) | |
{ | |
HttpClientParams httpClientParams = (HttpClientParams) connectionParams.getDefaults(); | |
httpClientParams.setCookiePolicy(settings.getCookiePolicy()); | |
} | |
if (settings.getConnectionTimeout() >= 0) | |
connectionParams.setConnectionTimeout(settings.getConnectionTimeout()); | |
if (settings.getSocketTimeout() >= 0) | |
connectionParams.setSoTimeout(settings.getSocketTimeout()); | |
connectionParams.setStaleCheckingEnabled(settings.isStaleCheckingEnabled()); | |
if (settings.getSendBufferSize() > 0) | |
connectionParams.setSendBufferSize(settings.getSendBufferSize()); | |
if (settings.getReceiveBufferSize() > 0) | |
connectionParams.setReceiveBufferSize(settings.getReceiveBufferSize()); | |
connectionParams.setTcpNoDelay(settings.isTcpNoDelay()); | |
connectionParams.setLinger(settings.getLinger()); | |
if (settings.getMaxConnectionsPerHost() != null) | |
{ | |
Iterator it = settings.getMaxConnectionsPerHost().iterator(); | |
while (it.hasNext()) | |
{ | |
HostConfigurationSettings hcs = (HostConfigurationSettings)it.next(); | |
HostConfiguration hostConfig = new HostConfiguration(); | |
if (hcs.getProtocol() != null) | |
{ | |
Protocol protocol = Protocol.getProtocol(hcs.getProtocol()); | |
hostConfig.setHost(hcs.getHost(), hcs.getPort(), protocol); | |
} | |
else if (hcs.getProtocolFactory() != null) | |
{ | |
Protocol protocol = hcs.getProtocolFactory().getProtocol(); | |
if (hcs.getPort() > 0) | |
hostConfig.setHost(hcs.getHost(), hcs.getPort(), protocol); | |
else | |
hostConfig.setHost(hcs.getHost(), protocol.getDefaultPort(), protocol); | |
} | |
else | |
{ | |
if (hcs.getPort() > 0) | |
hostConfig.setHost(hcs.getHost(), hcs.getPort()); | |
else | |
hostConfig.setHost(hcs.getHost()); | |
} | |
if (hcs.getVirtualHost() != null) | |
{ | |
HostParams params = hostConfig.getParams(); | |
if (params != null) | |
params.setVirtualHost(hcs.getVirtualHost()); | |
} | |
if (hcs.getProxyHost() != null) | |
{ | |
hostConfig.setProxy(hcs.getProxyHost(), hcs.getProxyPort()); | |
} | |
try | |
{ | |
InetAddress addr = InetAddress.getByName(hcs.getLocalAddress()); | |
hostConfig.setLocalAddress(addr); | |
} | |
catch (UnknownHostException ex) | |
{ | |
} | |
connectionParams.setMaxConnectionsPerHost(hostConfig, hcs.getMaximumConnections()); | |
} | |
} | |
} | |
} |