Java tutorial
/** * Copyright (c) 2009, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.synapse.transport.passthru; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.http.*; import org.apache.http.message.BasicHttpResponse; import org.apache.http.nio.ContentDecoder; import org.apache.http.nio.ContentEncoder; import org.apache.http.nio.NHttpServerConnection; import org.apache.http.nio.NHttpServerEventHandler; import org.apache.http.nio.entity.ContentOutputStream; import org.apache.http.nio.util.ContentOutputBuffer; import org.apache.http.nio.util.HeapByteBufferAllocator; import org.apache.http.nio.util.SimpleOutputBuffer; import org.apache.http.params.DefaultedHttpParams; import org.apache.http.protocol.ExecutionContext; import org.apache.http.protocol.HTTP; import org.apache.http.protocol.HttpContext; import org.apache.synapse.commons.jmx.ThreadingView; import org.apache.synapse.commons.transaction.TranscationManger; import org.apache.synapse.transport.http.conn.Scheme; import org.apache.synapse.transport.passthru.config.SourceConfiguration; import org.apache.synapse.transport.passthru.jmx.LatencyCollector; import org.apache.synapse.transport.passthru.jmx.LatencyView; import org.apache.synapse.transport.passthru.jmx.PassThroughTransportMetricsCollector; import javax.ws.rs.HttpMethod; import java.io.IOException; import java.io.OutputStream; /** * This is the class where transport interacts with the client. This class * receives events for a particular connection. These events give information * about the message and its various states. */ public class SourceHandler implements NHttpServerEventHandler { private static Log log = LogFactory.getLog(SourceHandler.class); private final SourceConfiguration sourceConfiguration; private PassThroughTransportMetricsCollector metrics = null; private LatencyView latencyView = null; private LatencyView s2sLatencyView = null; private ThreadingView threadingView; public SourceHandler(SourceConfiguration sourceConfiguration) { this.sourceConfiguration = sourceConfiguration; this.metrics = sourceConfiguration.getMetrics(); String strNamePostfix = ""; if (sourceConfiguration.getInDescription() != null && sourceConfiguration.getInDescription().getName() != null) { strNamePostfix = "-" + sourceConfiguration.getInDescription().getName(); Scheme scheme = sourceConfiguration.getScheme(); boolean enableAdvancedForLatencyView = sourceConfiguration .getBooleanValue(PassThroughConstants.SYNAPSE_PASSTHROUGH_LATENCY_ADVANCE_VIEW, false); boolean enableAdvancedForS2SView = sourceConfiguration .getBooleanValue(PassThroughConstants.SYNAPSE_PASSTHROUGH_S2SLATENCY_ADVANCE_VIEW, false); this.latencyView = new LatencyView(PassThroughConstants.PASSTHROUGH_LATENCY_VIEW, scheme.isSSL(), strNamePostfix, enableAdvancedForLatencyView); this.s2sLatencyView = new LatencyView(PassThroughConstants.PASSTHROUGH_S2SLATENCY_VIEW, scheme.isSSL(), strNamePostfix, enableAdvancedForS2SView); this.threadingView = new ThreadingView(PassThroughConstants.PASSTHOUGH_HTTP_SERVER_WORKER, true, 50); } } public void connected(NHttpServerConnection conn) { // we have to have these two operations in order sourceConfiguration.getSourceConnections().addConnection(conn); SourceContext.create(conn, ProtocolState.REQUEST_READY, sourceConfiguration); metrics.connected(); } public void requestReceived(NHttpServerConnection conn) { try { HttpContext httpContext = conn.getContext(); httpContext.setAttribute(PassThroughConstants.REQ_ARRIVAL_TIME, System.currentTimeMillis()); httpContext.setAttribute(PassThroughConstants.REQ_FROM_CLIENT_READ_START_TIME, System.currentTimeMillis()); SourceRequest request = getSourceRequest(conn); if (request == null) { return; } String method = request.getRequest() != null ? request.getRequest().getRequestLine().getMethod().toUpperCase() : ""; if (!request.isEntityEnclosing()) { conn.getContext().setAttribute(PassThroughConstants.REQ_FROM_CLIENT_READ_END_TIME, System.currentTimeMillis()); } OutputStream os = getOutputStream(method, request); sourceConfiguration.getWorkerPool().execute(new ServerWorker(request, sourceConfiguration, os)); } catch (HttpException e) { log.error("HttpException occurred when request is processing probably when creating SourceRequest", e); informReaderError(conn); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } catch (IOException e) { logIOException(conn, e); informReaderError(conn); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } } public void inputReady(NHttpServerConnection conn, ContentDecoder decoder) { try { ProtocolState protocolState = SourceContext.getState(conn); if (protocolState != ProtocolState.REQUEST_HEAD && protocolState != ProtocolState.REQUEST_BODY) { handleInvalidState(conn, "Request message body data received"); return; } SourceContext.updateState(conn, ProtocolState.REQUEST_BODY); SourceRequest request = SourceContext.getRequest(conn); int readBytes = request.read(conn, decoder); if (readBytes > 0) { metrics.incrementBytesReceived(readBytes); } } catch (IOException e) { logIOException(conn, e); informReaderError(conn); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } } public void responseReady(NHttpServerConnection conn) { try { ProtocolState protocolState = SourceContext.getState(conn); if (protocolState.compareTo(ProtocolState.REQUEST_DONE) < 0) { return; } if (protocolState.compareTo(ProtocolState.CLOSING) >= 0) { return; } if (protocolState != ProtocolState.REQUEST_DONE) { handleInvalidState(conn, "Writing a response"); return; } // because the duplex nature of http core we can reach hear without a actual response SourceResponse response = SourceContext.getResponse(conn); if (response != null) { // Handle Http ETag String ifNoneMatchHeader = SourceContext.getRequest(conn).getHeaders() .get(HttpHeaders.IF_NONE_MATCH); if (ifNoneMatchHeader != null) { String eTagHeader = response.getHeader(HttpHeaders.ETAG); if (eTagHeader != null) { for (String hashValue : ifNoneMatchHeader.split(",")) { if (hashValue.trim().equals(eTagHeader)) { response.setStatus(HttpStatus.SC_NOT_MODIFIED); break; } } } } response.start(conn); conn.getContext().setAttribute(PassThroughConstants.RES_TO_CLIENT_WRITE_START_TIME, System.currentTimeMillis()); metrics.incrementMessagesSent(); if (!response.hasEntity()) { // Update stats as outputReady will not be triggered for no entity responses HttpContext context = conn.getContext(); updateLatencyView(context); } } } catch (IOException e) { logIOException(conn, e); informWriterError(conn); SourceContext.updateState(conn, ProtocolState.CLOSING); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } catch (HttpException e) { log.error(e.getMessage(), e); informWriterError(conn); SourceContext.updateState(conn, ProtocolState.CLOSING); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } } public void outputReady(NHttpServerConnection conn, ContentEncoder encoder) { try { ProtocolState protocolState = SourceContext.getState(conn); //special case to handle WSDLs if (protocolState == ProtocolState.WSDL_RESPONSE_DONE) { // we need to shut down if the shutdown flag is set HttpContext context = conn.getContext(); ContentOutputBuffer outBuf = (ContentOutputBuffer) context .getAttribute("synapse.response-source-buffer"); int bytesWritten = outBuf.produceContent(encoder); if (metrics != null && bytesWritten > 0) { metrics.incrementBytesSent(bytesWritten); } conn.requestInput(); if (outBuf instanceof SimpleOutputBuffer && !((SimpleOutputBuffer) outBuf).hasData()) { sourceConfiguration.getSourceConnections().releaseConnection(conn); } endTransaction(conn); return; } if (protocolState != ProtocolState.RESPONSE_HEAD && protocolState != ProtocolState.RESPONSE_BODY) { log.warn("Illegal incoming connection state: " + protocolState + " . Possibly two send backs " + "are happening for the same request"); handleInvalidState(conn, "Trying to write response body"); endTransaction(conn); return; } SourceContext.updateState(conn, ProtocolState.RESPONSE_BODY); SourceResponse response = SourceContext.getResponse(conn); int bytesSent = response.write(conn, encoder); if (encoder.isCompleted()) { HttpContext context = conn.getContext(); long departure = System.currentTimeMillis(); context.setAttribute(PassThroughConstants.RES_TO_CLIENT_WRITE_END_TIME, departure); context.setAttribute(PassThroughConstants.RES_DEPARTURE_TIME, departure); updateLatencyView(context); } endTransaction(conn); metrics.incrementBytesSent(bytesSent); } catch (IOException e) { logIOException(conn, e); informWriterError(conn); SourceContext.updateState(conn, ProtocolState.CLOSING); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } } public void logIOException(NHttpServerConnection conn, IOException e) { // this check feels like crazy! But weird things happened, when load testing. if (e == null) { return; } if (e instanceof ConnectionClosedException || (e.getMessage() != null && (e.getMessage().toLowerCase().contains("connection reset by peer") || e.getMessage().toLowerCase().contains("forcibly closed")))) { if (log.isDebugEnabled()) { log.debug( conn + ": I/O error (Probably the keepalive connection " + "was closed):" + e.getMessage()); } } else if (e.getMessage() != null) { String msg = e.getMessage().toLowerCase(); if (msg.indexOf("broken") != -1) { log.warn("I/O error (Probably the connection " + "was closed by the remote party):" + e.getMessage()); } else { log.error("I/O error: " + e.getMessage(), e); } metrics.incrementFaultsReceiving(); } else { log.error("Unexpected I/O error: " + e.getClass().getName(), e); metrics.incrementFaultsReceiving(); } } public void timeout(NHttpServerConnection conn) { boolean isTimeoutOccurred = false; ProtocolState state = SourceContext.getState(conn); if (state == ProtocolState.REQUEST_READY || state == ProtocolState.RESPONSE_DONE) { if (log.isDebugEnabled()) { log.debug(conn + ": Keep-Alive connection was time out: " + conn); } } else if (state == ProtocolState.REQUEST_BODY || state == ProtocolState.REQUEST_HEAD) { metrics.incrementTimeoutsReceiving(); informReaderError(conn); isTimeoutOccurred = true; log.warn("Connection time out while reading the request: " + conn); } else if (state == ProtocolState.RESPONSE_BODY || state == ProtocolState.RESPONSE_HEAD) { informWriterError(conn); isTimeoutOccurred = true; log.warn("Connection time out while writing the response: " + conn); } else if (state == ProtocolState.REQUEST_DONE) { isTimeoutOccurred = true; log.warn("Connection time out after request is read: " + conn); } SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); if (isTimeoutOccurred) { rollbackTransaction(conn); } } public void closed(NHttpServerConnection conn) { ProtocolState state = SourceContext.getState(conn); boolean isFault = false; if (state == ProtocolState.REQUEST_READY || state == ProtocolState.RESPONSE_DONE) { if (log.isDebugEnabled()) { log.debug(conn + ": Keep-Alive connection was closed: " + conn); } } else if (state == ProtocolState.REQUEST_BODY || state == ProtocolState.REQUEST_HEAD) { isFault = true; informReaderError(conn); log.warn("Connection closed while reading the request: " + conn); } else if (state == ProtocolState.RESPONSE_BODY || state == ProtocolState.RESPONSE_HEAD) { isFault = true; informWriterError(conn); log.warn("Connection closed while writing the response: " + conn); } else if (state == ProtocolState.REQUEST_DONE) { isFault = true; log.warn("Connection closed by the client after request is read: " + conn); } metrics.disconnected(); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, isFault); if (isFault) { rollbackTransaction(conn); } } public void endOfInput(NHttpServerConnection conn) throws IOException { conn.close(); } public void exception(NHttpServerConnection conn, Exception ex) { boolean isFault = false; if (ex instanceof IOException) { logIOException(conn, (IOException) ex); metrics.incrementFaultsReceiving(); ProtocolState state = SourceContext.getState(conn); if (state == ProtocolState.REQUEST_BODY || state == ProtocolState.REQUEST_HEAD) { informReaderError(conn); } else if (state == ProtocolState.RESPONSE_BODY || state == ProtocolState.RESPONSE_HEAD) { informWriterError(conn); } else if (state == ProtocolState.REQUEST_DONE) { informWriterError(conn); } else if (state == ProtocolState.RESPONSE_DONE) { informWriterError(conn); } isFault = true; SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } else if (ex instanceof HttpException) { try { if (conn.isResponseSubmitted()) { sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); return; } HttpContext httpContext = conn.getContext(); HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_BAD_REQUEST, "Bad request"); response.setParams( new DefaultedHttpParams(sourceConfiguration.getHttpParams(), response.getParams())); response.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE); // Pre-process HTTP request httpContext.setAttribute(ExecutionContext.HTTP_CONNECTION, conn); httpContext.setAttribute(ExecutionContext.HTTP_REQUEST, null); httpContext.setAttribute(ExecutionContext.HTTP_RESPONSE, response); sourceConfiguration.getHttpProcessor().process(response, httpContext); conn.submitResponse(response); SourceContext.updateState(conn, ProtocolState.CLOSED); conn.close(); } catch (Exception ex1) { log.error(ex.getMessage(), ex); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); isFault = true; } } else { log.error("Unexpected error: " + ex.getMessage(), ex); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); isFault = true; } if (isFault) { rollbackTransaction(conn); } } private void handleInvalidState(NHttpServerConnection conn, String action) { log.warn(action + " while the handler is in an inconsistent state " + SourceContext.getState(conn)); SourceContext.updateState(conn, ProtocolState.CLOSED); sourceConfiguration.getSourceConnections().shutDownConnection(conn, true); } public void informReaderError(NHttpServerConnection conn) { Pipe reader = SourceContext.get(conn).getReader(); metrics.incrementFaultsReceiving(); if (reader != null) { reader.producerError(); } } public void informWriterError(NHttpServerConnection conn) { Pipe writer = SourceContext.get(conn).getWriter(); metrics.incrementFaultsSending(); if (writer != null) { writer.consumerError(); } } /** * Commit the response to the connection. Processes the response through the configured * HttpProcessor and submits it to be sent out. This method hides any exceptions and is targetted * for non critical (i.e. browser requests etc) requests, which are not core messages * @param conn the connection being processed * @param response the response to commit over the connection */ public void commitResponseHideExceptions(final NHttpServerConnection conn, final HttpResponse response) { try { conn.suspendInput(); sourceConfiguration.getHttpProcessor().process(response, conn.getContext()); conn.submitResponse(response); } catch (HttpException e) { handleException("Unexpected HTTP protocol error : " + e.getMessage(), e, conn); } catch (IOException e) { handleException("IO error submiting response : " + e.getMessage(), e, conn); } } // ----------- utility methods ----------- private void handleException(String msg, Exception e, NHttpServerConnection conn) { log.error(msg, e); if (conn != null) { //shutdownConnection(conn); } } private void updateLatencyView(HttpContext context) { if (context == null) { return; } latencyView.notifyTimes(new LatencyCollector(context, false)); s2sLatencyView.notifyTimes(new LatencyCollector(context, true)); LatencyCollector.clearTimestamps(context); } /** * Create synapse.response-source-buffer for GET and HEAD Http methods * @param method Http Method * @param request Source Request * @return OutputStream */ public OutputStream getOutputStream(String method, SourceRequest request) { OutputStream os = null; if (HttpMethod.GET.equals(method) || HttpMethod.HEAD.equals(method)) { HttpContext context = request.getConnection().getContext(); ContentOutputBuffer outputBuffer = new SimpleOutputBuffer(sourceConfiguration.getIOBufferSize(), new HeapByteBufferAllocator()); context.setAttribute("synapse.response-source-buffer", outputBuffer); os = new ContentOutputStream(outputBuffer); } return os; } /** * Create SourceRequest from NHttpServerConnection conn * @param conn the connection being processed * @return SourceRequest * @throws IOException * @throws HttpException */ public SourceRequest getSourceRequest(NHttpServerConnection conn) throws IOException, HttpException { HttpContext context = conn.getContext(); context.setAttribute(PassThroughConstants.REQ_ARRIVAL_TIME, System.currentTimeMillis()); if (!SourceContext.assertState(conn, ProtocolState.REQUEST_READY) && !SourceContext.assertState(conn, ProtocolState.WSDL_RESPONSE_DONE)) { handleInvalidState(conn, "Request received"); return null; } // we have received a message over this connection. So we must inform the pool sourceConfiguration.getSourceConnections().useConnection(conn); // at this point we have read the HTTP Headers SourceContext.updateState(conn, ProtocolState.REQUEST_HEAD); SourceRequest request = new SourceRequest(sourceConfiguration, conn.getHttpRequest(), conn); SourceContext.setRequest(conn, request); request.start(conn); metrics.incrementMessagesReceived(); return request; } private void rollbackTransaction(NHttpServerConnection conn) { try { Long serverWorkerThreadId = (Long) conn.getContext() .getAttribute(PassThroughConstants.SERVER_WORKER_THREAD_ID); if (serverWorkerThreadId != null) { TranscationManger.rollbackTransaction(false, serverWorkerThreadId); } } catch (Exception ex) { log.warn("Transaction rollback error after Connection closed " + ex.getMessage() + conn); } } private void endTransaction(NHttpServerConnection conn) { try { Long serverWorkerThreadId = (Long) conn.getContext() .getAttribute(PassThroughConstants.SERVER_WORKER_THREAD_ID); if (serverWorkerThreadId != null) { TranscationManger.endTransaction(false, serverWorkerThreadId); } } catch (Exception ex) { log.warn("Transaction rollback error after Connection closed " + ex.getMessage() + conn); } } }