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 org.apache.axis2.transport.http.impl.httpclient3; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.zip.GZIPInputStream; import javax.xml.namespace.QName; import org.apache.axiom.om.OMAttribute; import org.apache.axiom.om.OMElement; import org.apache.axis2.AxisFault; import org.apache.axis2.Constants; import org.apache.axis2.context.ConfigurationContext; import org.apache.axis2.context.MessageContext; import org.apache.axis2.context.NamedValue; import org.apache.axis2.context.OperationContext; import org.apache.axis2.i18n.Messages; import org.apache.axis2.transport.MessageFormatter; import org.apache.axis2.transport.TransportUtils; import org.apache.axis2.transport.http.HTTPAuthenticator; import org.apache.axis2.transport.http.HTTPConstants; import org.apache.axis2.transport.http.HTTPSender; import org.apache.axis2.transport.http.HTTPTransportConstants; import org.apache.axis2.wsdl.WSDLConstants; import org.apache.commons.httpclient.Header; import org.apache.commons.httpclient.HttpClient; import org.apache.commons.httpclient.HttpMethod; import org.apache.commons.httpclient.HttpMethodBase; import org.apache.commons.httpclient.HttpStatus; import org.apache.commons.httpclient.methods.DeleteMethod; import org.apache.commons.httpclient.methods.GetMethod; import org.apache.commons.httpclient.methods.PostMethod; import org.apache.commons.httpclient.methods.PutMethod; import org.apache.commons.httpclient.Credentials; import org.apache.commons.httpclient.HeaderElement; import org.apache.commons.httpclient.HostConfiguration; import org.apache.commons.httpclient.HttpConnectionManager; import org.apache.commons.httpclient.HttpState; import org.apache.commons.httpclient.HttpVersion; import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager; import org.apache.commons.httpclient.NTCredentials; import org.apache.commons.httpclient.NameValuePair; import org.apache.commons.httpclient.UsernamePasswordCredentials; import org.apache.commons.httpclient.auth.AuthPolicy; import org.apache.commons.httpclient.auth.AuthScope; import org.apache.commons.httpclient.params.HttpMethodParams; import org.apache.commons.httpclient.protocol.Protocol; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.http.protocol.HTTP; public class HTTPSenderImpl extends HTTPSender { private static final Log log = LogFactory.getLog(HTTPSenderImpl.class); /** * Used to send a request via HTTP Get method * * @param msgContext * - The MessageContext of the message * @param url * - The target URL * @param soapActiionString * - The soapAction string of the request * @throws AxisFault * - Thrown in case an exception occurs */ protected void sendViaGet(MessageContext msgContext, URL url, String soapActiionString) throws AxisFault { GetMethod getMethod = new GetMethod(); HttpClient httpClient = getHttpClient(msgContext); MessageFormatter messageFormatter = populateCommonProperties(msgContext, url, getMethod, httpClient, soapActiionString); // Need to have this here because we can have soap action when using the // soap response MEP String soapAction = messageFormatter.formatSOAPAction(msgContext, format, soapActiionString); if (soapAction != null) { getMethod.setRequestHeader(HTTPConstants.HEADER_SOAP_ACTION, soapAction); } try { executeMethod(httpClient, msgContext, url, getMethod); handleResponse(msgContext, getMethod); } catch (IOException e) { log.info("Unable to sendViaGet to url[" + url + "]", e); throw AxisFault.makeFault(e); } finally { cleanup(msgContext, getMethod); } } protected void cleanup(MessageContext msgContext, Object httpMmethod) { if (httpMmethod instanceof HttpMethod) { if (msgContext.isPropertyTrue(HTTPConstants.AUTO_RELEASE_CONNECTION)) { log.trace("AutoReleasing " + httpMmethod); ((HttpMethod) httpMmethod).releaseConnection(); } } } /** * Used to send a request via HTTP Delete Method * * @param msgContext * - The MessageContext of the message * @param url * - The target URL * @param soapActiionString * - The soapAction string of the request * @throws AxisFault * - Thrown in case an exception occurs */ protected void sendViaDelete(MessageContext msgContext, URL url, String soapActiionString) throws AxisFault { DeleteMethod deleteMethod = new DeleteMethod(); HttpClient httpClient = getHttpClient(msgContext); populateCommonProperties(msgContext, url, deleteMethod, httpClient, soapActiionString); try { executeMethod(httpClient, msgContext, url, deleteMethod); handleResponse(msgContext, deleteMethod); } catch (IOException e) { log.info("Unable to sendViaDelete to url[" + url + "]", e); throw AxisFault.makeFault(e); } finally { cleanup(msgContext, deleteMethod); } } /** * Used to send a request via HTTP Post Method * * @param msgContext * - The MessageContext of the message * @param url * - The target URL * @param soapActionString * - The soapAction string of the request * @throws AxisFault * - Thrown in case an exception occurs */ protected void sendViaPost(MessageContext msgContext, URL url, String soapActionString) throws AxisFault { HttpClient httpClient = getHttpClient(msgContext); /* * What's up with this, it never gets used anywhere?? --Glen String * charEncoding = (String) * msgContext.getProperty(Constants.Configuration * .CHARACTER_SET_ENCODING); * * if (charEncoding == null) { charEncoding = * MessageContext.DEFAULT_CHAR_SET_ENCODING; } */ PostMethod postMethod = new PostMethod(); if (log.isTraceEnabled()) { log.trace(Thread.currentThread() + " PostMethod " + postMethod + " / " + httpClient); } MessageFormatter messageFormatter = populateCommonProperties(msgContext, url, postMethod, httpClient, soapActionString); postMethod.setRequestEntity(new AxisRequestEntityImpl(messageFormatter, msgContext, format, soapActionString, chunked, isAllowedRetry)); if (!httpVersion.equals(HTTPConstants.HEADER_PROTOCOL_10) && chunked) { postMethod.setContentChunked(true); } String soapAction = messageFormatter.formatSOAPAction(msgContext, format, soapActionString); if (soapAction != null) { postMethod.setRequestHeader(HTTPConstants.HEADER_SOAP_ACTION, soapAction); } /* * main excecution takes place.. */ try { executeMethod(httpClient, msgContext, url, postMethod); handleResponse(msgContext, postMethod); } catch (IOException e) { log.info("Unable to sendViaPost to url[" + url + "]", e); throw AxisFault.makeFault(e); } finally { cleanup(msgContext, postMethod); } } /** * Used to send a request via HTTP Put Method * * @param msgContext * - The MessageContext of the message * @param url * - The target URL * @param soapActionString * - The soapAction string of the request * @throws AxisFault * - Thrown in case an exception occurs */ protected void sendViaPut(MessageContext msgContext, URL url, String soapActionString) throws AxisFault { HttpClient httpClient = getHttpClient(msgContext); /* * Same deal - this value never gets used, why is it here? --Glen String * charEncoding = (String) * msgContext.getProperty(Constants.Configuration * .CHARACTER_SET_ENCODING); * * if (charEncoding == null) { charEncoding = * MessageContext.DEFAULT_CHAR_SET_ENCODING; } */ PutMethod putMethod = new PutMethod(); MessageFormatter messageFormatter = populateCommonProperties(msgContext, url, putMethod, httpClient, soapActionString); putMethod.setRequestEntity(new AxisRequestEntityImpl(messageFormatter, msgContext, format, soapActionString, chunked, isAllowedRetry)); if (!httpVersion.equals(HTTPConstants.HEADER_PROTOCOL_10) && chunked) { putMethod.setContentChunked(true); } String soapAction = messageFormatter.formatSOAPAction(msgContext, format, soapActionString); if (soapAction != null) { putMethod.setRequestHeader(HTTPConstants.HEADER_SOAP_ACTION, soapAction); } /* * main excecution takes place.. */ try { executeMethod(httpClient, msgContext, url, putMethod); handleResponse(msgContext, putMethod); } catch (IOException e) { log.info("Unable to sendViaPut to url[" + url + "]", e); throw AxisFault.makeFault(e); } finally { cleanup(msgContext, putMethod); } } /** * Used to handle the HTTP Response * * @param msgContext * - The MessageContext of the message * @param method * - The HTTP method used * @throws IOException * - Thrown in case an exception occurs */ protected void handleResponse(MessageContext msgContext, Object httpMethodBase) throws IOException { HttpMethodBase method; if (httpMethodBase instanceof HttpMethodBase) { method = (HttpMethodBase) httpMethodBase; } else { log.trace("HttpMethodBase expected, but found - " + httpMethodBase); return; } int statusCode = method.getStatusCode(); HTTPStatusCodeFamily family = getHTTPStatusCodeFamily(statusCode); log.trace("Handling response - " + statusCode); if (statusCode == HttpStatus.SC_ACCEPTED) { /* When an HTTP 202 Accepted code has been received, this will be the case of an execution * of an in-only operation. In such a scenario, the HTTP response headers should be returned, * i.e. session cookies. */ obtainHTTPHeaderInformation(method, msgContext); // Since we don't expect any content with a 202 response, we must release the connection method.releaseConnection(); } else if (HTTPStatusCodeFamily.SUCCESSFUL.equals(family)) { // Save the HttpMethod so that we can release the connection when cleaning up msgContext.setProperty(HTTPConstants.HTTP_METHOD, method); processResponse(method, msgContext); } else if (statusCode == HttpStatus.SC_INTERNAL_SERVER_ERROR || statusCode == HttpStatus.SC_BAD_REQUEST) { // Save the HttpMethod so that we can release the connection when // cleaning up msgContext.setProperty(HTTPConstants.HTTP_METHOD, method); Header contenttypeHeader = method.getResponseHeader(HTTPConstants.HEADER_CONTENT_TYPE); String value = null; if (contenttypeHeader != null) { value = contenttypeHeader.getValue(); } OperationContext opContext = msgContext.getOperationContext(); if (opContext != null) { MessageContext inMessageContext = opContext.getMessageContext(WSDLConstants.MESSAGE_LABEL_IN_VALUE); if (inMessageContext != null) { inMessageContext.setProcessingFault(true); } } if (value != null) { processResponse(method, msgContext); } if (org.apache.axis2.util.Utils.isClientThreadNonBlockingPropertySet(msgContext)) { throw new AxisFault( Messages.getMessage("transportError", String.valueOf(statusCode), method.getStatusText())); } } else { // Since we don't process the response, we must release the // connection immediately method.releaseConnection(); throw new AxisFault( Messages.getMessage("transportError", String.valueOf(statusCode), method.getStatusText())); } } /** * Collect the HTTP header information and set them in the message context * * @param method * HttpMethodBase from which to get information * @param msgContext * the MessageContext in which to place the information... OR * NOT! * @throws AxisFault * if problems occur */ protected void obtainHTTPHeaderInformation(Object httpMethodBase, MessageContext msgContext) throws AxisFault { HttpMethod method; if (httpMethodBase instanceof HttpMethodBase) { method = (HttpMethod) httpMethodBase; } else { return; } // Set RESPONSE properties onto the REQUEST message context. They will // need to be copied off the request context onto // the response context elsewhere, for example in the // OutInOperationClient. Map transportHeaders = new HTTPTransportHeaders(method.getResponseHeaders()); msgContext.setProperty(MessageContext.TRANSPORT_HEADERS, transportHeaders); msgContext.setProperty(HTTPConstants.MC_HTTP_STATUS_CODE, new Integer(method.getStatusCode())); Header header = method.getResponseHeader(HTTPConstants.HEADER_CONTENT_TYPE); if (header != null) { HeaderElement[] headers = header.getElements(); MessageContext inMessageContext = msgContext.getOperationContext() .getMessageContext(WSDLConstants.MESSAGE_LABEL_IN_VALUE); Object contentType = header.getValue(); Object charSetEnc = null; for (int i = 0; i < headers.length; i++) { NameValuePair charsetEnc = headers[i].getParameterByName(HTTPConstants.CHAR_SET_ENCODING); if (charsetEnc != null) { charSetEnc = charsetEnc.getValue(); } } if (inMessageContext != null) { inMessageContext.setProperty(Constants.Configuration.CONTENT_TYPE, contentType); inMessageContext.setProperty(Constants.Configuration.CHARACTER_SET_ENCODING, charSetEnc); } else { // Transport details will be stored in a HashMap so that anybody // interested can // retrieve them HashMap transportInfoMap = new HashMap(); transportInfoMap.put(Constants.Configuration.CONTENT_TYPE, contentType); transportInfoMap.put(Constants.Configuration.CHARACTER_SET_ENCODING, charSetEnc); // the HashMap is stored in the outgoing message. msgContext.setProperty(Constants.Configuration.TRANSPORT_INFO_MAP, transportInfoMap); } } String sessionCookie = null; // Process old style headers first Header[] cookieHeaders = method.getResponseHeaders(HTTPConstants.HEADER_SET_COOKIE); String customCoookiId = (String) msgContext.getProperty(Constants.CUSTOM_COOKIE_ID); for (int i = 0; i < cookieHeaders.length; i++) { HeaderElement[] elements = cookieHeaders[i].getElements(); for (int e = 0; e < elements.length; e++) { HeaderElement element = elements[e]; if (Constants.SESSION_COOKIE.equalsIgnoreCase(element.getName()) || Constants.SESSION_COOKIE_JSESSIONID.equalsIgnoreCase(element.getName())) { sessionCookie = processCookieHeader(element); } if (customCoookiId != null && customCoookiId.equalsIgnoreCase(element.getName())) { sessionCookie = processCookieHeader(element); } } } // Overwrite old style cookies with new style ones if present cookieHeaders = method.getResponseHeaders(HTTPConstants.HEADER_SET_COOKIE2); for (int i = 0; i < cookieHeaders.length; i++) { HeaderElement[] elements = cookieHeaders[i].getElements(); for (int e = 0; e < elements.length; e++) { HeaderElement element = elements[e]; if (Constants.SESSION_COOKIE.equalsIgnoreCase(element.getName()) || Constants.SESSION_COOKIE_JSESSIONID.equalsIgnoreCase(element.getName())) { sessionCookie = processCookieHeader(element); } if (customCoookiId != null && customCoookiId.equalsIgnoreCase(element.getName())) { sessionCookie = processCookieHeader(element); } } } if (sessionCookie != null) { msgContext.getServiceContext().setProperty(HTTPConstants.COOKIE_STRING, sessionCookie); } } private String processCookieHeader(HeaderElement element) { String cookie = element.getName() + "=" + element.getValue(); NameValuePair[] parameters = element.getParameters(); for (int j = 0; parameters != null && j < parameters.length; j++) { NameValuePair parameter = parameters[j]; cookie = cookie + "; " + parameter.getName() + "=" + parameter.getValue(); } return cookie; } protected void processResponse(HttpMethodBase httpMethod, MessageContext msgContext) throws IOException { obtainHTTPHeaderInformation(httpMethod, msgContext); InputStream in = httpMethod.getResponseBodyAsStream(); if (in == null) { throw new AxisFault(Messages.getMessage("canNotBeNull", "InputStream")); } Header contentEncoding = httpMethod.getResponseHeader(HTTPConstants.HEADER_CONTENT_ENCODING); if (contentEncoding != null) { if (contentEncoding.getValue().equalsIgnoreCase(HTTPConstants.COMPRESSION_GZIP)) { in = new GZIPInputStream(in); // If the content-encoding is identity we can basically ignore // it. } else if (!"identity".equalsIgnoreCase(contentEncoding.getValue())) { throw new AxisFault( "HTTP :" + "unsupported content-encoding of '" + contentEncoding.getValue() + "' found"); } } OperationContext opContext = msgContext.getOperationContext(); if (opContext != null) { opContext.setProperty(MessageContext.TRANSPORT_IN, in); } } /** * getting host configuration to support standard http/s, proxy and NTLM * support * * @param client * active HttpClient * @param msgCtx * active MessageContext * @param targetURL * the target URL * @return a HostConfiguration set up with proxy information * @throws AxisFault * if problems occur */ protected HostConfiguration getHostConfiguration(HttpClient client, MessageContext msgCtx, URL targetURL) throws AxisFault { boolean isAuthenticationEnabled = isAuthenticationEnabled(msgCtx); int port = targetURL.getPort(); String protocol = targetURL.getProtocol(); if (port == -1) { if (HTTPTransportConstants.PROTOCOL_HTTP.equals(protocol)) { port = 80; } else if (HTTPTransportConstants.PROTOCOL_HTTPS.equals(protocol)) { port = 443; } } // to see the host is a proxy and in the proxy list - available in // axis2.xml HostConfiguration config = client.getHostConfiguration(); if (config == null) { config = new HostConfiguration(); } // one might need to set his own socket factory. Let's allow that case // as well. Protocol protocolHandler = (Protocol) msgCtx.getOptions() .getProperty(HTTPConstants.CUSTOM_PROTOCOL_HANDLER); // setting the real host configuration // I assume the 90% case, or even 99% case will be no protocol handler // case. if (protocolHandler == null) { config.setHost(targetURL.getHost(), port, targetURL.getProtocol()); } else { config.setHost(targetURL.getHost(), port, protocolHandler); } if (isAuthenticationEnabled) { // Basic, Digest, NTLM and custom authentications. this.setAuthenticationInfo(client, msgCtx, config); } // proxy configuration if (HTTPProxyConfigurator.isProxyEnabled(msgCtx, targetURL)) { if (log.isDebugEnabled()) { log.debug("Configuring HTTP proxy."); } HTTPProxyConfigurator.configure(msgCtx, client, config); } return config; } protected boolean isAuthenticationEnabled(MessageContext msgCtx) { return (msgCtx.getProperty(HTTPConstants.AUTHENTICATE) != null); } /* * This will handle server Authentication, It could be either NTLM, Digest * or Basic Authentication. Apart from that user can change the priory or * add a custom authentication scheme. */ protected void setAuthenticationInfo(HttpClient agent, MessageContext msgCtx, HostConfiguration config) throws AxisFault { HTTPAuthenticator authenticator; Object obj = msgCtx.getProperty(HTTPConstants.AUTHENTICATE); if (obj != null) { if (obj instanceof HTTPAuthenticator) { authenticator = (HTTPAuthenticator) obj; String username = authenticator.getUsername(); String password = authenticator.getPassword(); String host = authenticator.getHost(); String domain = authenticator.getDomain(); int port = authenticator.getPort(); String realm = authenticator.getRealm(); /* If retrying is available set it first */ isAllowedRetry = authenticator.isAllowedRetry(); Credentials creds; HttpState tmpHttpState = null; HttpState httpState = (HttpState) msgCtx.getProperty(HTTPConstants.CACHED_HTTP_STATE); if (httpState != null) { tmpHttpState = httpState; } else { tmpHttpState = agent.getState(); } agent.getParams().setAuthenticationPreemptive(authenticator.getPreemptiveAuthentication()); if (host != null) { if (domain != null) { /* Credentials for NTLM Authentication */ creds = new NTCredentials(username, password, host, domain); } else { /* Credentials for Digest and Basic Authentication */ creds = new UsernamePasswordCredentials(username, password); } tmpHttpState.setCredentials(new AuthScope(host, port, realm), creds); } else { if (domain != null) { /* * Credentials for NTLM Authentication when host is * ANY_HOST */ creds = new NTCredentials(username, password, AuthScope.ANY_HOST, domain); tmpHttpState.setCredentials(new AuthScope(AuthScope.ANY_HOST, port, realm), creds); } else { /* Credentials only for Digest and Basic Authentication */ creds = new UsernamePasswordCredentials(username, password); tmpHttpState.setCredentials(new AuthScope(AuthScope.ANY), creds); } } /* Customizing the priority Order */ List schemes = authenticator.getAuthSchemes(); if (schemes != null && schemes.size() > 0) { List authPrefs = new ArrayList(3); for (int i = 0; i < schemes.size(); i++) { if (schemes.get(i) instanceof AuthPolicy) { authPrefs.add(schemes.get(i)); continue; } String scheme = (String) schemes.get(i); authPrefs.add(authenticator.getAuthPolicyPref(scheme)); } agent.getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs); } } else { throw new AxisFault("HttpTransportProperties.Authenticator class cast exception"); } } } /** * Method used to copy all the common properties * * @param msgContext * - The messageContext of the request message * @param url * - The target URL * @param httpMethod * - The http method used to send the request * @param httpClient * - The httpclient used to send the request * @param soapActionString * - The soap action atring of the request message * @return MessageFormatter - The messageFormatter for the relavent request * message * @throws AxisFault * - Thrown in case an exception occurs */ protected MessageFormatter populateCommonProperties(MessageContext msgContext, URL url, HttpMethodBase httpMethod, HttpClient httpClient, String soapActionString) throws AxisFault { if (isAuthenticationEnabled(msgContext)) { httpMethod.setDoAuthentication(true); } MessageFormatter messageFormatter = TransportUtils.getMessageFormatter(msgContext); url = messageFormatter.getTargetAddress(msgContext, format, url); httpMethod.setPath(url.getPath()); httpMethod.setQueryString(url.getQuery()); httpMethod.setRequestHeader(HTTPConstants.HEADER_CONTENT_TYPE, messageFormatter.getContentType(msgContext, format, soapActionString)); httpMethod.setRequestHeader(HTTPConstants.HEADER_HOST, url.getHost()); if (msgContext.getOptions() != null && msgContext.getOptions().isManageSession()) { // setting the cookie in the out path Object cookieString = msgContext.getProperty(HTTPConstants.COOKIE_STRING); if (cookieString != null) { StringBuffer buffer = new StringBuffer(); buffer.append(cookieString); httpMethod.setRequestHeader(HTTPConstants.HEADER_COOKIE, buffer.toString()); } } if (httpVersion.equals(HTTPConstants.HEADER_PROTOCOL_10)) { httpClient.getParams().setVersion(HttpVersion.HTTP_1_0); } return messageFormatter; } /** * This is used to get the dynamically set time out values from the message * context. If the values are not available or invalid then the default * values or the values set by the configuration will be used * * @param msgContext * the active MessageContext * @param httpClient */ protected void initializeTimeouts(MessageContext msgContext, HttpClient httpClient) { // If the SO_TIMEOUT of CONNECTION_TIMEOUT is set by dynamically the // override the static config Integer tempSoTimeoutProperty = (Integer) msgContext.getProperty(HTTPConstants.SO_TIMEOUT); Integer tempConnTimeoutProperty = (Integer) msgContext.getProperty(HTTPConstants.CONNECTION_TIMEOUT); long timeout = msgContext.getOptions().getTimeOutInMilliSeconds(); if (tempConnTimeoutProperty != null) { int connectionTimeout = tempConnTimeoutProperty.intValue(); // timeout for initial connection httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(connectionTimeout); } else { // set timeout in client if (timeout > 0) { httpClient.getHttpConnectionManager().getParams().setConnectionTimeout((int) timeout); } } if (tempSoTimeoutProperty != null) { int soTimeout = tempSoTimeoutProperty.intValue(); // SO_TIMEOUT -- timeout for blocking reads httpClient.getHttpConnectionManager().getParams().setSoTimeout(soTimeout); httpClient.getParams().setSoTimeout(soTimeout); } else { // set timeout in client if (timeout > 0) { httpClient.getHttpConnectionManager().getParams().setSoTimeout((int) timeout); httpClient.getParams().setSoTimeout((int) timeout); } } } /** * This is used to get the dynamically set time out values from the message * context. If the values are not available or invalid then the default * values or the values set by the configuration will be used * * @param msgContext * the active MessageContext * @param httpMethod * method */ protected void setTimeouts(MessageContext msgContext, HttpMethod httpMethod) { // If the SO_TIMEOUT of CONNECTION_TIMEOUT is set by dynamically the // override the static config Integer tempSoTimeoutProperty = (Integer) msgContext.getProperty(HTTPConstants.SO_TIMEOUT); Integer tempConnTimeoutProperty = (Integer) msgContext.getProperty(HTTPConstants.CONNECTION_TIMEOUT); long timeout = msgContext.getOptions().getTimeOutInMilliSeconds(); if (tempConnTimeoutProperty != null) { // timeout for initial connection httpMethod.getParams().setParameter("http.connection.timeout", tempConnTimeoutProperty); } if (tempSoTimeoutProperty != null) { // SO_TIMEOUT -- timeout for blocking reads httpMethod.getParams().setSoTimeout(tempSoTimeoutProperty); } else { // set timeout in client if (timeout > 0) { httpMethod.getParams().setSoTimeout((int) timeout); } } } protected HttpClient getHttpClient(MessageContext msgContext) { ConfigurationContext configContext = msgContext.getConfigurationContext(); HttpClient httpClient = (HttpClient) msgContext.getProperty(HTTPConstants.CACHED_HTTP_CLIENT); if (httpClient == null) { httpClient = (HttpClient) configContext.getProperty(HTTPConstants.CACHED_HTTP_CLIENT); } if (httpClient != null) { return httpClient; } synchronized (this) { httpClient = (HttpClient) msgContext.getProperty(HTTPConstants.CACHED_HTTP_CLIENT); if (httpClient == null) { httpClient = (HttpClient) configContext.getProperty(HTTPConstants.CACHED_HTTP_CLIENT); } if (httpClient != null) { return httpClient; } HttpConnectionManager connManager = (HttpConnectionManager) msgContext .getProperty(HTTPConstants.MULTITHREAD_HTTP_CONNECTION_MANAGER); if (connManager == null) { connManager = (HttpConnectionManager) msgContext .getProperty(HTTPConstants.MULTITHREAD_HTTP_CONNECTION_MANAGER); } if (connManager == null) { // reuse HttpConnectionManager synchronized (configContext) { connManager = (HttpConnectionManager) configContext .getProperty(HTTPConstants.MULTITHREAD_HTTP_CONNECTION_MANAGER); if (connManager == null) { log.trace("Making new ConnectionManager"); connManager = new MultiThreadedHttpConnectionManager(); configContext.setProperty(HTTPConstants.MULTITHREAD_HTTP_CONNECTION_MANAGER, connManager); } } } /* * Create a new instance of HttpClient since the way it is used here * it's not fully thread-safe. */ httpClient = new HttpClient(connManager); // Set the default timeout in case we have a connection pool // starvation to 30sec httpClient.getParams().setConnectionManagerTimeout(30000); // Get the timeout values set in the runtime initializeTimeouts(msgContext, httpClient); return httpClient; } } protected void executeMethod(HttpClient httpClient, MessageContext msgContext, URL url, HttpMethod method) throws IOException { HostConfiguration config = this.getHostConfiguration(httpClient, msgContext, url); // set the custom headers, if available addCustomHeaders(method, msgContext); // add compression headers if needed if (msgContext.isPropertyTrue(HTTPConstants.MC_ACCEPT_GZIP)) { method.addRequestHeader(HTTPConstants.HEADER_ACCEPT_ENCODING, HTTPConstants.COMPRESSION_GZIP); } if (msgContext.isPropertyTrue(HTTPConstants.MC_GZIP_REQUEST)) { method.addRequestHeader(HTTPConstants.HEADER_CONTENT_ENCODING, HTTPConstants.COMPRESSION_GZIP); } if (msgContext.getProperty(HTTPConstants.HTTP_METHOD_PARAMS) != null) { HttpMethodParams params = (HttpMethodParams) msgContext.getProperty(HTTPConstants.HTTP_METHOD_PARAMS); method.setParams(params); } String cookiePolicy = (String) msgContext.getProperty(HTTPConstants.COOKIE_POLICY); if (cookiePolicy != null) { method.getParams().setCookiePolicy(cookiePolicy); } HttpState httpState = (HttpState) msgContext.getProperty(HTTPConstants.CACHED_HTTP_STATE); setTimeouts(msgContext, method); httpClient.executeMethod(config, method, httpState); } public void addCustomHeaders(HttpMethod method, MessageContext msgContext) { boolean isCustomUserAgentSet = false; // set the custom headers, if available Object httpHeadersObj = msgContext.getProperty(HTTPConstants.HTTP_HEADERS); if (httpHeadersObj != null) { if (httpHeadersObj instanceof List) { List httpHeaders = (List) httpHeadersObj; for (int i = 0; i < httpHeaders.size(); i++) { NamedValue nv = (NamedValue) httpHeaders.get(i); if (nv != null) { Header header = new Header(nv.getName(), nv.getValue()); if (HTTPConstants.HEADER_USER_AGENT.equals(header.getName())) { isCustomUserAgentSet = true; } method.addRequestHeader(header); } } } if (httpHeadersObj instanceof Map) { Map httpHeaders = (Map) httpHeadersObj; for (Iterator iterator = httpHeaders.entrySet().iterator(); iterator.hasNext();) { Map.Entry entry = (Map.Entry) iterator.next(); String key = (String) entry.getKey(); String value = (String) entry.getValue(); if (HTTPConstants.HEADER_USER_AGENT.equals(key)) { isCustomUserAgentSet = true; } method.addRequestHeader(key, value); } } } // we have to consider the TRANSPORT_HEADERS map as well Map transportHeaders = (Map) msgContext.getProperty(MessageContext.TRANSPORT_HEADERS); if (transportHeaders != null) { removeUnwantedHeaders(msgContext); Set headerEntries = transportHeaders.entrySet(); for (Object headerEntry : headerEntries) { if (headerEntry instanceof Map.Entry) { Header[] headers = method.getRequestHeaders(); boolean headerAdded = false; for (Header header : headers) { if (header.getName() != null && header.getName().equals(((Map.Entry) headerEntry).getKey())) { headerAdded = true; break; } } if (!headerAdded) { method.addRequestHeader(((Map.Entry) headerEntry).getKey().toString(), ((Map.Entry) headerEntry).getValue().toString()); } } } } if (!isCustomUserAgentSet) { String userAgentString = getUserAgent(msgContext); method.setRequestHeader(HTTPConstants.HEADER_USER_AGENT, userAgentString); } } /** * Remove unwanted headers from the transport headers map of outgoing * request. These are headers which should be dictated by the transport and * not the user. We remove these as these may get copied from the request * messages * * @param msgContext * the Axis2 Message context from which these headers should be * removed */ private void removeUnwantedHeaders(MessageContext msgContext) { Map headers = (Map) msgContext.getProperty(MessageContext.TRANSPORT_HEADERS); if (headers == null || headers.isEmpty()) { return; } Iterator iter = headers.keySet().iterator(); while (iter.hasNext()) { String headerName = (String) iter.next(); if (HTTP.CONN_DIRECTIVE.equalsIgnoreCase(headerName) || HTTP.TRANSFER_ENCODING.equalsIgnoreCase(headerName) || HTTP.DATE_HEADER.equalsIgnoreCase(headerName) || HTTP.CONTENT_TYPE.equalsIgnoreCase(headerName) || HTTP.CONTENT_LEN.equalsIgnoreCase(headerName)) { iter.remove(); } } } private String getUserAgent(MessageContext messageContext) { String userAgentString = "Axis2"; boolean locked = false; if (messageContext.getParameter(HTTPConstants.USER_AGENT) != null) { OMElement userAgentElement = messageContext.getParameter(HTTPConstants.USER_AGENT) .getParameterElement(); userAgentString = userAgentElement.getText().trim(); OMAttribute lockedAttribute = userAgentElement.getAttribute(new QName("locked")); if (lockedAttribute != null) { if (lockedAttribute.getAttributeValue().equalsIgnoreCase("true")) { locked = true; } } } // Runtime overing part if (!locked) { if (messageContext.getProperty(HTTPConstants.USER_AGENT) != null) { userAgentString = (String) messageContext.getProperty(HTTPConstants.USER_AGENT); } } return userAgentString; } }