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.synapse.transport.nhttp; import org.apache.axiom.om.OMOutputFormat; import org.apache.axiom.util.blob.OverflowBlob; import org.apache.axis2.AxisFault; import org.apache.axis2.Constants; import org.apache.axis2.addressing.EndpointReference; import org.apache.axis2.context.MessageContext; import org.apache.axis2.transport.MessageFormatter; import org.apache.axis2.transport.http.HTTPConstants; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.http.Header; import org.apache.http.HttpException; import org.apache.http.HttpRequest; import org.apache.http.HttpVersion; import org.apache.http.client.utils.URIUtils; import org.apache.http.conn.routing.HttpRoute; import org.apache.http.entity.BasicHttpEntity; import org.apache.http.message.BasicHttpEntityEnclosingRequest; import org.apache.http.message.BasicHttpRequest; import org.apache.http.nio.entity.ContentOutputStream; import org.apache.http.nio.util.ContentOutputBuffer; import org.apache.http.protocol.HTTP; import org.apache.synapse.transport.nhttp.util.MessageFormatterDecoratorFactory; import org.apache.synapse.transport.nhttp.util.NhttpUtil; import java.io.IOException; import java.io.OutputStream; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; import java.nio.channels.ClosedChannelException; import java.util.Collection; import java.util.Iterator; import java.util.Map; /** * Represents an outgoing Axis2 HTTP/s request. It holds the EPR of the destination, the * Axis2 MessageContext to be sent, an HttpHost object which captures information about the * destination, and a Pipe used to write the message stream to the destination */ public class Axis2HttpRequest { private static final Log log = LogFactory.getLog(Axis2HttpRequest.class); /** * the EPR of the destination */ private EndpointReference epr = null; /** * The [socket | connect] timeout */ private int timeout = -1; /** * the message context being sent */ private MessageContext msgContext = null; /** * The Axis2 MessageFormatter that will ensure proper serialization as per Axis2 semantics */ MessageFormatter messageFormatter = null; /** * The OM Output format holder */ OMOutputFormat format = null; private ContentOutputBuffer outputBuffer = null; /** * ready to begin streaming? */ private volatile boolean readyToStream = false; /** * The sending of this request has fully completed */ private volatile boolean sendingCompleted = false; /** * for request complete checking - request complete means the request has been fully sent * and the response it fully received */ private volatile boolean completed = false; /** * The URL prefix of the endpoint (to be used for Location header re-writing in the response) */ private String endpointURLPrefix = null; /** * the HttpHost that contains the HTTP connection information */ private HttpRoute route; /** * weather chunking is enabled or not */ private boolean chunked = true; public Axis2HttpRequest(EndpointReference epr, HttpRoute route, MessageContext msgContext) { this.epr = epr; this.route = route; this.msgContext = msgContext; this.format = NhttpUtil.getOMOutputFormat(msgContext); this.messageFormatter = MessageFormatterDecoratorFactory.createMessageFormatterDecorator(msgContext); this.chunked = !msgContext.isPropertyTrue(NhttpConstants.DISABLE_CHUNKING); } public void setReadyToStream(boolean readyToStream) { this.readyToStream = readyToStream; } public void setOutputBuffer(ContentOutputBuffer outputBuffer) { this.outputBuffer = outputBuffer; } public void clear() { this.epr = null; this.route = null; this.msgContext = null; this.format = null; this.messageFormatter = null; this.outputBuffer = null; } public EndpointReference getEpr() { return epr; } public HttpRoute getRoute() { return route; } public MessageContext getMsgContext() { return msgContext; } public int getTimeout() { return timeout; } public void setTimeout(int timeout) { this.timeout = timeout; } public String getEndpointURLPrefix() { return endpointURLPrefix; } public void setEndpointURLPrefix(String endpointURLPrefix) { this.endpointURLPrefix = endpointURLPrefix; } /** * Create and return a new HttpPost request to the destination EPR * * @return the HttpRequest to be sent out * @throws IOException in error retrieving the <code>HttpRequest</code> */ public HttpRequest getRequest() throws IOException, HttpException { String httpMethod = (String) msgContext.getProperty(Constants.Configuration.HTTP_METHOD); if (httpMethod == null) { httpMethod = "POST"; } endpointURLPrefix = (String) msgContext.getProperty(NhttpConstants.ENDPOINT_PREFIX); boolean forceHTTP10 = msgContext.isPropertyTrue(NhttpConstants.FORCE_HTTP_1_0); HttpVersion httpver = forceHTTP10 ? HttpVersion.HTTP_1_0 : HttpVersion.HTTP_1_1; HttpRequest httpRequest; try { if ("POST".equals(httpMethod) || "PUT".equals(httpMethod) || "PATCH".equals(httpMethod)) { URI uri = rewriteRequestURI(new URI(epr.getAddress())); BasicHttpEntityEnclosingRequest requestWithEntity = new BasicHttpEntityEnclosingRequest(httpMethod, uri.toASCIIString(), httpver); BasicHttpEntity entity = new BasicHttpEntity(); if (forceHTTP10) { setStreamAsTempData(entity); } else { entity.setChunked(chunked); if (!chunked) { setStreamAsTempData(entity); } } requestWithEntity.setEntity(entity); requestWithEntity.setHeader(HTTP.CONTENT_TYPE, messageFormatter.getContentType(msgContext, format, msgContext.getSoapAction())); httpRequest = requestWithEntity; } else if ("GET".equals(httpMethod) || "DELETE".equals(httpMethod)) { URL url = messageFormatter.getTargetAddress(msgContext, format, new URL(epr.getAddress())); URI uri = rewriteRequestURI(url.toURI()); httpRequest = new BasicHttpRequest(httpMethod, uri.toASCIIString(), httpver); /*GETs and DELETEs do not need Content-Type headers because they do not have payloads*/ //httpRequest.setHeader(HTTP.CONTENT_TYPE, messageFormatter.getContentType( // msgContext, format, msgContext.getSoapAction())); } else { URI uri = rewriteRequestURI(new URI(epr.getAddress())); httpRequest = new BasicHttpRequest(httpMethod, uri.toASCIIString(), httpver); } } catch (URISyntaxException ex) { throw new HttpException(ex.getMessage(), ex); } // set any transport headers Object o = msgContext.getProperty(MessageContext.TRANSPORT_HEADERS); if (o != null && o instanceof Map) { Map headers = (Map) o; for (Object header : headers.keySet()) { Object value = headers.get(header); if (header instanceof String && value != null && value instanceof String) { if (!HTTPConstants.HEADER_HOST.equalsIgnoreCase((String) header)) { httpRequest.setHeader((String) header, (String) value); String excessProp = NhttpConstants.EXCESS_TRANSPORT_HEADERS; Map map = (Map) msgContext.getProperty(excessProp); if (map != null && map.get(header) != null) { log.debug("Number of excess values for " + header + " header is : " + ((Collection) (map.get(header))).size()); for (Iterator iterator = map.keySet().iterator(); iterator.hasNext();) { String key = (String) iterator.next(); for (String excessVal : (Collection<String>) map.get(key)) { httpRequest.addHeader((String) header, (String) excessVal); } } } } else { if (msgContext.getProperty(NhttpConstants.REQUEST_HOST_HEADER) != null) { httpRequest.setHeader((String) header, (String) msgContext.getProperty(NhttpConstants.REQUEST_HOST_HEADER)); } } } } } // if the message is SOAP 11 (for which a SOAPAction is *required*), and // the msg context has a SOAPAction or a WSA-Action (give pref to SOAPAction) // use that over any transport header that may be available String soapAction = msgContext.getSoapAction(); if (soapAction == null) { soapAction = msgContext.getWSAAction(); } if (soapAction == null) { msgContext.getAxisOperation().getInputAction(); } if (msgContext.isSOAP11() && soapAction != null && soapAction.length() >= 0) { Header existingHeader = httpRequest.getFirstHeader(HTTPConstants.HEADER_SOAP_ACTION); if (existingHeader != null) { httpRequest.removeHeader(existingHeader); } httpRequest.setHeader(HTTPConstants.HEADER_SOAP_ACTION, messageFormatter.formatSOAPAction(msgContext, null, soapAction)); } if (NHttpConfiguration.getInstance().isKeepAliveDisabled() || msgContext.isPropertyTrue(NhttpConstants.NO_KEEPALIVE)) { httpRequest.setHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE); } return httpRequest; } private URI rewriteRequestURI(final URI uri) throws URISyntaxException { if (msgContext.isPropertyTrue(NhttpConstants.POST_TO_URI) || (route.getProxyHost() != null && !route.isTunnelled())) { // Must be absolute return uri; } else { // Make relative return URIUtils.rewriteURI(uri, null, true); } } /** * Start streaming the message into the Pipe, so that the contents could be read off the source * channel returned by getSourceChannel() * * @throws AxisFault on error */ public void streamMessageContents() throws AxisFault { if (log.isDebugEnabled()) { log.debug("Start streaming outgoing http request : [Message ID : " + msgContext.getMessageID() + "]"); if (log.isTraceEnabled()) { log.trace("Message [Request Message ID : " + msgContext.getMessageID() + "] " + "[Request Message Payload : [ " + msgContext.getEnvelope() + "]"); } } NHttpConfiguration cfg = NHttpConfiguration.getInstance(); int senderTimeout = cfg.getProperty(NhttpConstants.SO_TIMEOUT_SENDER, 60000); long startTime = System.currentTimeMillis(); synchronized (this) { while (!readyToStream && !completed) { try { this.wait(senderTimeout + 10000); if ((startTime + senderTimeout + 5000) < System.currentTimeMillis()) { handleException("Thread " + Thread.currentThread().getName() + " is blocked longer than the send timeout when trying to send the message :" + msgContext.getMessageID() + ". Releasing thread", new AxisFault("Sender thread was not notified within send timeout")); } } catch (InterruptedException ignore) { } } } if (!completed) { OutputStream out = new ContentOutputStream(outputBuffer); try { if (msgContext.isPropertyTrue(NhttpConstants.FORCE_HTTP_1_0)) { writeMessageFromTempData(out); } else { if (chunked) { messageFormatter.writeTo(msgContext, format, out, false); } else { writeMessageFromTempData(out); } } } catch (Exception e) { Throwable t = e.getCause(); if (t != null && t.getCause() != null && t.getCause() instanceof ClosedChannelException) { if (log.isDebugEnabled()) { log.debug("Ignore closed channel exception, as the " + "SessionRequestCallback handles this exception"); } } else { Integer errorCode = msgContext == null ? null : (Integer) msgContext.getProperty(NhttpConstants.ERROR_CODE); if (errorCode == null || errorCode == NhttpConstants.SEND_ABORT) { if (log.isDebugEnabled()) { log.debug("Remote server aborted request being sent, and responded"); } } else { if (e instanceof AxisFault) { throw (AxisFault) e; } else { handleException("Error streaming message context", e); } } } } finally { try { out.flush(); out.close(); } catch (IOException e) { handleException("Error closing outgoing message stream", e); } setSendingCompleted(true); } } } /** * Write the stream to a temporary storage and calculate the content length * * @param entity HTTPEntity * @throws IOException if an exception occurred while writing data */ private void setStreamAsTempData(BasicHttpEntity entity) throws IOException { OverflowBlob serialized = new OverflowBlob(256, 4096, "http-nio_", ".dat"); OutputStream out = serialized.getOutputStream(); try { messageFormatter.writeTo(msgContext, format, out, true); } finally { out.close(); } msgContext.setProperty(NhttpConstants.SERIALIZED_BYTES, serialized); entity.setContentLength(serialized.getLength()); } /** * Take the data from temporary storage and write it to the output stream * * @param out output stream * @throws IOException if an exception occurred while writing data */ private void writeMessageFromTempData(OutputStream out) throws IOException { OverflowBlob serialized = (OverflowBlob) msgContext.getProperty(NhttpConstants.SERIALIZED_BYTES); try { serialized.writeTo(out); } finally { serialized.release(); } } // -------------- utility methods ------------- private void handleException(String msg, Exception e) throws AxisFault { log.error(msg, e); throw new AxisFault(msg, e); } public boolean isCompleted() { return completed; } public void setCompleted(boolean completed) { this.completed = completed; synchronized (this) { this.notifyAll(); } } public boolean isSendingCompleted() { return sendingCompleted; } public void setSendingCompleted(boolean sendingCompleted) { this.sendingCompleted = sendingCompleted; } @Override public String toString() { StringBuffer sb = new StringBuffer(); sb.append("Axis2Request [Message ID : ").append(msgContext.getMessageID()).append("] "); sb.append("[Status Completed : ").append(isCompleted() ? "true" : "false").append("] "); sb.append("[Status SendingCompleted : ").append(isSendingCompleted() ? "true" : "false").append("]"); return sb.toString(); } }