Java tutorial
/* * 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 public static final String CONTENT_TYPE_XML = "application/xml"; public static final String CONTENT_TYPE_FORM = "application/x-www-form-urlencoded"; 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()); } } } }