| /* |
| * 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.cocoon.reading; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.util.Map; |
| |
| import javax.servlet.ServletContext; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import javax.servlet.http.HttpUtils; |
| import javax.xml.soap.SOAPException; |
| |
| import org.apache.avalon.framework.activity.Disposable; |
| import org.apache.avalon.framework.configuration.Configurable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.parameters.Parameters; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| |
| import org.apache.axis.AxisFault; |
| import org.apache.axis.Constants; |
| import org.apache.axis.Message; |
| import org.apache.axis.MessageContext; |
| import org.apache.axis.soap.SOAPConstants; |
| import org.apache.axis.transport.http.AxisHttpSession; |
| import org.apache.axis.transport.http.HTTPConstants; |
| |
| import org.apache.cocoon.ProcessingException; |
| import org.apache.cocoon.components.axis.SoapServer; |
| import org.apache.cocoon.environment.ObjectModelHelper; |
| import org.apache.cocoon.environment.SourceResolver; |
| import org.apache.cocoon.environment.http.HttpEnvironment; |
| |
| import org.w3c.dom.Element; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * SOAP Reader |
| * |
| * <p> |
| * This reader accepts a SOAP Request, and generates the resultant |
| * response as output. Essentially, this reader allows you to serve SOAP |
| * requests from your Cocoon application. |
| * </p> |
| * |
| * <p> |
| * Code originates from the Apache |
| * <a href="http://xml.apache.org/axis">AXIS</a> project, |
| * <code>org.apache.axis.http.transport.AxisServlet</code>. |
| * </p> |
| * |
| * Ported to Cocoon by: |
| * |
| * @author <a href="mailto:crafterm@apache.org">Marcus Crafter</a> |
| * |
| * Original <code>AxisServlet</code> authors: |
| * |
| * @author <a href="mailto:">Steve Loughran</a> |
| * @author <a href="mailto:dug@us.ibm.com">Doug Davis</a> |
| * |
| * @version CVS $Id$ |
| */ |
| public class AxisRPCReader extends ServiceableReader |
| implements Configurable, Disposable { |
| |
| // soap server reference |
| private SoapServer m_server; |
| |
| /** Are we in development stage ? */ |
| private boolean m_isDevelompent = false; |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.framework.configuration.Configurable#configure(org.apache.avalon.framework.configuration.Configuration) |
| */ |
| public void configure(Configuration config) throws ConfigurationException { |
| m_isDevelompent = config.getChild("development-stage").getValueAsBoolean(m_isDevelompent ); |
| } |
| |
| public void service(final ServiceManager manager) throws ServiceException { |
| super.service(manager); |
| // set soap server reference |
| m_server = (SoapServer) manager.lookup(SoapServer.ROLE); |
| } |
| |
| /** |
| * Axis RPC Router <code>setup</code> method. |
| * |
| * <p> |
| * This method sets the reader up for use. Essentially it checks that |
| * its been invoked in a HTTP-POST environment, reads some optional |
| * configuration variables, and obtains several component references to |
| * be used later. |
| * </p> |
| * |
| * @param resolver <code>SourceResolver</code> instance |
| * @param objectModel request/response/context data |
| * @param src source <code>String</code> instance |
| * @param parameters sitemap invocation time customization parameters |
| * @exception ProcessingException if an error occurs |
| * @exception IOException if an error occurs |
| * @exception SAXException if an error occurs |
| */ |
| public void setup( |
| final SourceResolver resolver, |
| final Map objectModel, |
| final String src, |
| final Parameters parameters) |
| throws ProcessingException, IOException, SAXException { |
| super.setup(resolver, objectModel, src, parameters); |
| |
| checkHTTPPost(objectModel); |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("AxisRPCReader.setup() complete"); |
| } |
| } |
| |
| /** |
| * Helper method to ensure that given a HTTP-POST. |
| * |
| * @param objectModel Request/Response/Context map. |
| * @exception ProcessingException if a non HTTP-POST request has been made. |
| */ |
| private void checkHTTPPost(final Map objectModel) |
| throws ProcessingException { |
| String method = ObjectModelHelper.getRequest(objectModel).getMethod(); |
| |
| if (!"POST".equalsIgnoreCase(method)) |
| throw new ProcessingException( |
| "Reader only supports HTTP-POST (supplied was " + method + ")" |
| ); |
| } |
| |
| /** |
| * Axis RPC Router <code>generate</code> method. |
| * |
| * <p> |
| * This method reads the SOAP request in from the input stream, invokes |
| * the requested method and sends the result back to the requestor |
| * </p> |
| * |
| * @exception IOException if an IO error occurs |
| * @exception SAXException if a SAX error occurs |
| * @exception ProcessingException if a processing error occurs |
| */ |
| public void generate() |
| throws IOException, SAXException, ProcessingException { |
| HttpServletRequest req = |
| (HttpServletRequest) objectModel.get(HttpEnvironment.HTTP_REQUEST_OBJECT); |
| HttpServletResponse res = |
| (HttpServletResponse) objectModel.get(HttpEnvironment.HTTP_RESPONSE_OBJECT); |
| ServletContext con = |
| (ServletContext) objectModel.get(HttpEnvironment.HTTP_SERVLET_CONTEXT); |
| |
| String soapAction = null; |
| MessageContext msgContext = null; |
| Message responseMsg = null; |
| |
| try { |
| res.setBufferSize(1024 * 8); // provide performance boost. |
| |
| // Get message context w/ various properties set |
| msgContext = m_server.createMessageContext(req, res, con); |
| |
| // Get request message |
| Message requestMsg = |
| new Message( |
| req.getInputStream(), false, |
| req.getHeader(HTTPConstants.HEADER_CONTENT_TYPE), |
| req.getHeader(HTTPConstants.HEADER_CONTENT_LOCATION) |
| ); |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Request message:\n" + messageToString(requestMsg)); |
| } |
| |
| // Set the request(incoming) message field in the context |
| msgContext.setRequestMessage(requestMsg); |
| String url = HttpUtils.getRequestURL(req).toString(); |
| msgContext.setProperty(MessageContext.TRANS_URL, url); |
| |
| try { |
| // |
| // Save the SOAPAction header in the MessageContext bag. |
| // This will be used to tell the Axis Engine which service |
| // is being invoked. This will save us the trouble of |
| // having to parse the Request message - although we will |
| // need to double-check later on that the SOAPAction header |
| // does in fact match the URI in the body. |
| // (is this last stmt true??? (I don't think so - Glen)) |
| // |
| soapAction = getSoapAction(req); |
| |
| if (soapAction != null) { |
| msgContext.setUseSOAPAction(true); |
| msgContext.setSOAPActionURI(soapAction); |
| } |
| |
| // Create a Session wrapper for the HTTP session. |
| msgContext.setSession(new AxisHttpSession(req)); |
| |
| // Invoke the Axis engine... |
| if(getLogger().isDebugEnabled()) { |
| getLogger().debug("Invoking Axis Engine"); |
| } |
| |
| m_server.invoke(msgContext); |
| |
| if(getLogger().isDebugEnabled()) { |
| getLogger().debug("Return from Axis Engine"); |
| } |
| |
| responseMsg = msgContext.getResponseMessage(); |
| if (responseMsg == null) { |
| //tell everyone that something is wrong |
| throw new Exception("no response message"); |
| } |
| } catch (AxisFault fault) { |
| if (getLogger().isErrorEnabled()) { |
| getLogger().error("Axis Fault", fault); |
| } |
| |
| // log and sanitize |
| processAxisFault(fault); |
| configureResponseFromAxisFault(res, fault); |
| responseMsg = msgContext.getResponseMessage(); |
| if (responseMsg == null) { |
| responseMsg = new Message(fault); |
| } |
| } catch (Exception e) { |
| //other exceptions are internal trouble |
| responseMsg = msgContext.getResponseMessage(); |
| res.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); |
| if (getLogger().isErrorEnabled()) { |
| getLogger().error("Error during SOAP call", e); |
| } |
| if (responseMsg == null) { |
| AxisFault fault = AxisFault.makeFault(e); |
| processAxisFault(fault); |
| responseMsg = new Message(fault); |
| } |
| } |
| } catch (AxisFault fault) { |
| if (getLogger().isErrorEnabled()) { |
| getLogger().error("Axis fault occured while perforing request", fault); |
| } |
| processAxisFault(fault); |
| configureResponseFromAxisFault(res, fault); |
| responseMsg = msgContext.getResponseMessage(); |
| if( responseMsg == null) { |
| responseMsg = new Message(fault); |
| } |
| } catch (Exception e) { |
| throw new ProcessingException("Exception thrown while performing request", e); |
| } |
| |
| // Send response back |
| if (responseMsg != null) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Sending response:\n" + messageToString(responseMsg)); |
| } |
| |
| sendResponse(getProtocolVersion(req), msgContext.getSOAPConstants(), res, responseMsg); |
| } |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("AxisRPCReader.generate() complete"); |
| } |
| } |
| |
| /** |
| * routine called whenever an axis fault is caught; where they |
| * are logged and any other business. The method may modify the fault |
| * in the process |
| * @param fault what went wrong. |
| */ |
| protected void processAxisFault(AxisFault fault) { |
| //log the fault |
| Element runtimeException = fault.lookupFaultDetail( |
| Constants.QNAME_FAULTDETAIL_RUNTIMEEXCEPTION); |
| if (runtimeException != null) { |
| getLogger().info("AxisFault:", fault); |
| //strip runtime details |
| fault.removeFaultDetail(Constants.QNAME_FAULTDETAIL_RUNTIMEEXCEPTION); |
| } else if (getLogger().isDebugEnabled()) { |
| getLogger().debug("AxisFault:", fault); |
| } |
| //dev systems only give fault dumps |
| if (m_isDevelompent) { |
| //strip out the stack trace |
| fault.removeFaultDetail(Constants.QNAME_FAULTDETAIL_STACKTRACE); |
| } |
| } |
| |
| /** |
| * Configure the servlet response status code and maybe other headers |
| * from the fault info. |
| * @param response response to configure |
| * @param fault what went wrong |
| */ |
| private void configureResponseFromAxisFault(HttpServletResponse response, |
| AxisFault fault) { |
| // then get the status code |
| // It's been suggested that a lack of SOAPAction |
| // should produce some other error code (in the 400s)... |
| int status = getHttpServletResponseStatus(fault); |
| if (status == HttpServletResponse.SC_UNAUTHORIZED) { |
| // unauth access results in authentication request |
| // TODO: less generic realm choice? |
| response.setHeader("WWW-Authenticate","Basic realm=\"AXIS\""); |
| } |
| response.setStatus(status); |
| } |
| |
| /** |
| * Extract information from AxisFault and map it to a HTTP Status code. |
| * |
| * @param af Axis Fault |
| * @return HTTP Status code. |
| */ |
| protected int getHttpServletResponseStatus(AxisFault af) { |
| // This will raise a 401 for both "Unauthenticated" & "Unauthorized"... |
| return af.getFaultCode().getLocalPart().startsWith("Server.Unauth") |
| ? HttpServletResponse.SC_UNAUTHORIZED |
| : HttpServletResponse.SC_INTERNAL_SERVER_ERROR; |
| } |
| |
| /** |
| * write a message to the response, set appropriate headers for content |
| * type..etc. |
| * @param clientVersion client protocol, one of the HTTPConstants strings |
| * @param res response |
| * @param responseMsg message to write |
| * @throws AxisFault |
| * @throws IOException if the response stream can not be written to |
| */ |
| private void sendResponse( |
| final String clientVersion, |
| final SOAPConstants constants, |
| final HttpServletResponse res, |
| final Message responseMsg) |
| throws AxisFault, IOException { |
| if (responseMsg == null) { |
| res.setStatus(HttpServletResponse.SC_NO_CONTENT); |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("No axis response, not sending one"); |
| } |
| } else { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Returned Content-Type:" + responseMsg.getContentType(constants)); |
| getLogger().debug("Returned Content-Length:" + responseMsg.getContentLength()); |
| } |
| |
| try { |
| res.setContentType(responseMsg.getContentType(constants)); |
| responseMsg.writeTo(res.getOutputStream()); |
| } catch (SOAPException e) { |
| getLogger().error("Exception sending response", e); |
| } |
| } |
| |
| if (!res.isCommitted()) { |
| res.flushBuffer(); // Force it right now. |
| } |
| } |
| |
| /** |
| * Extract the SOAPAction header. |
| * if SOAPAction is null then we'll we be forced to scan the body for it. |
| * if SOAPAction is "" then use the URL |
| * @param req incoming request |
| * @return the action |
| * @throws AxisFault |
| */ |
| private String getSoapAction(HttpServletRequest req) |
| throws AxisFault { |
| String soapAction = req.getHeader(HTTPConstants.HEADER_SOAP_ACTION); |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("HEADER_SOAP_ACTION:" + soapAction); |
| } |
| |
| // |
| // Technically, if we don't find this header, we should probably fault. |
| // It's required in the SOAP HTTP binding. |
| // |
| if (soapAction == null) { |
| throw new AxisFault( |
| "Client.NoSOAPAction", |
| "No SOAPAction header", |
| null, null |
| ); |
| } |
| |
| if (soapAction.length() == 0) |
| soapAction = req.getContextPath(); // Is this right? |
| |
| return soapAction; |
| } |
| |
| /** |
| * Return the HTTP protocol level 1.1 or 1.0 |
| * by derived class. |
| */ |
| private String getProtocolVersion(HttpServletRequest req) { |
| String ret = HTTPConstants.HEADER_PROTOCOL_V10; |
| String prot = req.getProtocol(); |
| if (prot!= null) { |
| int sindex= prot.indexOf('/'); |
| if (-1 != sindex) { |
| String ver= prot.substring(sindex+1); |
| if (HTTPConstants.HEADER_PROTOCOL_V11.equals(ver.trim())) { |
| ret = HTTPConstants.HEADER_PROTOCOL_V11; |
| } |
| } |
| } |
| return ret; |
| } |
| |
| /** |
| * Helper method to convert a <code>Message</code> structure |
| * into a <code>String</code>. |
| * |
| * @param msg a <code>Message</code> value |
| * @return a <code>String</code> value |
| */ |
| private String messageToString(final Message msg) { |
| try { |
| OutputStream os = new ByteArrayOutputStream(); |
| msg.writeTo(os); |
| return os.toString(); |
| } catch (Exception e) { |
| if (getLogger().isWarnEnabled()) { |
| getLogger().warn( |
| "Warning, could not convert message (" + msg + ") into string", e |
| ); |
| } |
| |
| return null; |
| } |
| } |
| |
| /** |
| * Dispose this reader. Release all held resources. |
| */ |
| public void dispose() { |
| manager.release(m_server); |
| } |
| } |
