View Javadoc

1   /*
2    * $Id: AxisServiceComponent.java 9435 2007-10-29 14:34:09Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.providers.soap.axis;
12  
13  import org.mule.MuleManager;
14  import org.mule.config.MuleManifest;
15  import org.mule.config.MuleProperties;
16  import org.mule.config.i18n.CoreMessages;
17  import org.mule.impl.MuleMessage;
18  import org.mule.impl.RequestContext;
19  import org.mule.impl.endpoint.MuleEndpointURI;
20  import org.mule.providers.WriterMessageAdapter;
21  import org.mule.providers.http.HttpConnector;
22  import org.mule.providers.http.HttpConstants;
23  import org.mule.providers.soap.SoapConstants;
24  import org.mule.providers.soap.axis.extensions.AxisMuleSession;
25  import org.mule.providers.soap.axis.extensions.MuleConfigProvider;
26  import org.mule.umo.MessagingException;
27  import org.mule.umo.UMOEventContext;
28  import org.mule.umo.UMOException;
29  import org.mule.umo.UMOMessage;
30  import org.mule.umo.endpoint.MalformedEndpointException;
31  import org.mule.umo.endpoint.UMOEndpointURI;
32  import org.mule.umo.lifecycle.Callable;
33  import org.mule.umo.lifecycle.Initialisable;
34  import org.mule.umo.lifecycle.InitialisationException;
35  import org.mule.util.StringUtils;
36  
37  import java.io.ByteArrayInputStream;
38  import java.io.ByteArrayOutputStream;
39  import java.io.File;
40  import java.io.FileInputStream;
41  import java.io.IOException;
42  import java.io.StringWriter;
43  import java.util.ArrayList;
44  import java.util.Iterator;
45  import java.util.Map;
46  import java.util.Properties;
47  
48  import javax.xml.namespace.QName;
49  
50  import org.apache.axis.AxisEngine;
51  import org.apache.axis.AxisFault;
52  import org.apache.axis.ConfigurationException;
53  import org.apache.axis.Constants;
54  import org.apache.axis.Message;
55  import org.apache.axis.MessageContext;
56  import org.apache.axis.description.OperationDesc;
57  import org.apache.axis.description.ServiceDesc;
58  import org.apache.axis.handlers.soap.SOAPService;
59  import org.apache.axis.i18n.Messages;
60  import org.apache.axis.security.servlet.ServletSecurityProvider;
61  import org.apache.axis.server.AxisServer;
62  import org.apache.axis.transport.http.HTTPConstants;
63  import org.apache.axis.transport.http.ServletEndpointContextImpl;
64  import org.apache.axis.utils.Admin;
65  import org.apache.axis.utils.XMLUtils;
66  import org.apache.commons.logging.Log;
67  import org.w3c.dom.Document;
68  
69  /**
70   * <code>AxisServiceComponent</code> is a Mule component implementation of the Axis
71   * servlet. This component supports all the features of the Axis servlet except -
72   * <ol>
73   * <li>Jws class services are not supported as they don't add any value to the Mule
74   * model</li>
75   * <li>Currently there is no HttpSession support. This will be fixed when Session
76   * support is added to the Http Connector</li>
77   * </ol>
78   */
79  
80  public class AxisServiceComponent implements Initialisable, Callable
81  {
82      protected static final Log logger = org.apache.commons.logging.LogFactory.getLog(AxisServiceComponent.class);
83  
84      public static final String INIT_PROPERTY_TRANSPORT_NAME = "transport.name";
85      public static final String INIT_PROPERTY_USE_SECURITY = "use-servlet-security";
86      public static final String INIT_PROPERTY_ENABLE_LIST = "axis.enableListQuery";
87      public static final String DEFAULT_AXIS_HOME = "/axisHome";
88  
89      private String transportName = "http";
90      private ServletSecurityProvider securityProvider;
91      private boolean enableList;
92      private String homeDir;
93      private AxisServer axisServer;
94  
95      public AxisServiceComponent()
96      {
97          securityProvider = null;
98          enableList = true;
99      }
100 
101     /**
102      * Passes the context to the listener
103      * 
104      * @param context the context to process
105      * @return Object this object can be anything. When the
106      *         <code>UMOLifecycleAdapter</code> for the component receives this
107      *         object it will first see if the Object is an <code>UMOEvent</code>
108      *         if not and the Object is not null a new context will be created using
109      *         the returned object as the payload. This new context will then get
110      *         published to the configured outbound endpoint if-
111      *         <ol>
112      *         <li>One has been configured for the UMO.</li>
113      *         <li>the <code>setStopFurtherProcessing(true)</code> wasn't called
114      *         on the previous context.</li>
115      *         </ol>
116      * @throws Exception if the context fails to process properly. If exceptions
117      *             aren't handled by the implementation they will be handled by the
118      *             exceptionListener associated with the component
119      */
120     public Object onCall(UMOEventContext context) throws Exception
121     {
122         WriterMessageAdapter response = new WriterMessageAdapter(new StringWriter(4096));
123         String method = context.getMessage().getStringProperty(HttpConnector.HTTP_METHOD_PROPERTY,
124             HttpConstants.METHOD_POST);
125         if (HttpConstants.METHOD_GET.equalsIgnoreCase(method))
126         {
127             doGet(context, response);
128         }
129         else
130         {
131             doPost(context, response);
132         }
133         response.getWriter().close();
134         return new MuleMessage(response);
135     }
136 
137     public void initialise() throws InitialisationException
138     {
139         // template method
140     }
141 
142     public void doGet(UMOEventContext context, WriterMessageAdapter response)
143         throws UMOException, IOException
144     {
145         try
146         {
147             // We parse a new uri based on the listening host and port with the
148             // request parameters appended
149             // Using the soap prefix ensures that we use a soap endpoint builder
150             UMOEndpointURI endpointUri = context.getEndpointURI();
151             if (!"servlet".equalsIgnoreCase(context.getEndpointURI().getSchemeMetaInfo()))
152             {
153                 String uri = SoapConstants.SOAP_ENDPOINT_PREFIX + context.getEndpointURI().getScheme()
154                                 + "://" + context.getEndpointURI().getHost() + ":"
155                                 + context.getEndpointURI().getPort();
156                 uri += context.getMessageAsString();
157                 endpointUri = new MuleEndpointURI(uri);
158             }
159 
160             AxisEngine engine = getAxisServer();
161             String pathInfo = endpointUri.getPath();
162             boolean wsdlRequested = false;
163             boolean listRequested = false;
164 
165             if (endpointUri.getAddress().endsWith(".jws"))
166             {
167                 throw new AxisFault("Jws not supported by the Mule Axis service");
168             }
169 
170             String queryString = endpointUri.getQuery();
171             if (queryString != null)
172             {
173                 if (queryString.equalsIgnoreCase(SoapConstants.WSDL_PROPERTY))
174                 {
175                     wsdlRequested = true;
176                 }
177                 else
178                 {
179                     if (queryString.equalsIgnoreCase(SoapConstants.LIST_PROPERTY))
180                     {
181                         listRequested = true;
182                     }
183                 }
184             }
185 
186             boolean hasNoPath = (StringUtils.isEmpty(pathInfo) || pathInfo.equals("/"));
187             if (!wsdlRequested && !listRequested && hasNoPath)
188             {
189                 reportAvailableServices(context, response);
190             }
191             else
192             {
193                 MessageContext msgContext = new MessageContext(engine);
194                 populateMessageContext(msgContext, context, endpointUri);
195 
196                 msgContext.setProperty("transport.url", endpointUri.toString());
197                 if (wsdlRequested)
198                 {
199                     processWsdlRequest(msgContext, response);
200                 }
201                 else if (listRequested)
202                 {
203                     processListRequest(response);
204                 }
205                 else
206                 {
207                     processMethodRequest(msgContext, context, response, endpointUri);
208                 }
209             }
210         }
211         catch (AxisFault fault)
212         {
213             reportTroubleInGet(fault, response);
214         }
215         catch (Exception e)
216         {
217             reportTroubleInGet(e, response);
218         }
219     }
220 
221     private void reportTroubleInGet(Exception exception, WriterMessageAdapter response)
222     {
223         response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, "text/html");
224         response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "500");
225         response.write("<h2>" + Messages.getMessage("error00") + "</h2>");
226         response.write("<p>" + Messages.getMessage("somethingWrong00") + "</p>");
227         if (exception instanceof AxisFault)
228         {
229             AxisFault fault = (AxisFault)exception;
230             processAxisFault(fault);
231             writeFault(response, fault);
232         }
233         else
234         {
235             logger.error(exception.getMessage(), exception);
236             response.write("<pre>Exception - " + exception + "<br>");
237             response.write("</pre>");
238         }
239     }
240 
241     protected void processAxisFault(AxisFault fault)
242     {
243         org.w3c.dom.Element runtimeException = fault
244             .lookupFaultDetail(Constants.QNAME_FAULTDETAIL_RUNTIMEEXCEPTION);
245         if (runtimeException != null)
246         {
247             logger.info(Messages.getMessage("axisFault00"), fault);
248             fault.removeFaultDetail(Constants.QNAME_FAULTDETAIL_RUNTIMEEXCEPTION);
249         }
250         else if (logger.isDebugEnabled())
251         {
252             logger.debug(Messages.getMessage("axisFault00"), fault);
253         }
254 
255     }
256 
257     private void writeFault(WriterMessageAdapter response, AxisFault axisFault)
258     {
259         String localizedMessage = XMLUtils.xmlEncodeString(axisFault.getLocalizedMessage());
260         response.write("<pre>Fault - " + localizedMessage + "<br>");
261         response.write(axisFault.dumpToString());
262         response.write("</pre>");
263     }
264 
265     protected void processMethodRequest(MessageContext msgContext,
266                                         UMOEventContext context,
267                                         WriterMessageAdapter response,
268                                         UMOEndpointURI endpointUri) throws AxisFault
269     {
270         Properties params = endpointUri.getUserParams();
271 
272         String method = (String)params.remove(MuleProperties.MULE_METHOD_PROPERTY);
273         if (method == null)
274         {
275             method = endpointUri.getPath().substring(endpointUri.getPath().lastIndexOf("/") + 1);
276         }
277         StringBuffer args = new StringBuffer(64);
278 
279         Map.Entry entry;
280         for (Iterator iterator = params.entrySet().iterator(); iterator.hasNext();)
281         {
282             entry = (Map.Entry)iterator.next();
283             args.append("<").append(entry.getKey()).append(">");
284             args.append(entry.getValue());
285             args.append("</").append(entry.getKey()).append(">");
286         }
287 
288         if (method == null)
289         {
290             response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, "text/html");
291             response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "400");
292             response.write("<h2>" + Messages.getMessage("error00") + ":  "
293                             + Messages.getMessage("invokeGet00") + "</h2>");
294             response.write("<p>" + Messages.getMessage("noMethod01") + "</p>");
295         }
296         else
297         {
298             invokeEndpointFromGet(msgContext, response, method, args.toString());
299         }
300     }
301 
302     protected void processWsdlRequest(MessageContext msgContext, WriterMessageAdapter response)
303         throws AxisFault
304     {
305         AxisEngine engine = getAxisServer();
306         try
307         {
308             engine.generateWSDL(msgContext);
309             Document doc = (Document)msgContext.getProperty("WSDL");
310             if (doc != null)
311             {
312                 response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, "text/xml");
313                 XMLUtils.DocumentToWriter(doc, response.getWriter());
314             }
315             else
316             {
317                 if (logger.isDebugEnabled())
318                 {
319                     logger.debug("processWsdlRequest: failed to create WSDL");
320                 }
321                 reportNoWSDL(response, "noWSDL02", null);
322             }
323         }
324         catch (AxisFault axisFault)
325         {
326             if (axisFault.getFaultCode().equals(Constants.QNAME_NO_SERVICE_FAULT_CODE))
327             {
328                 processAxisFault(axisFault);
329                 response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "404");
330                 reportNoWSDL(response, "noWSDL01", axisFault);
331             }
332             else
333             {
334                 throw axisFault;
335             }
336         }
337     }
338 
339     protected void invokeEndpointFromGet(MessageContext msgContext,
340                                          WriterMessageAdapter response,
341                                          String method,
342                                          String args) throws AxisFault
343     {
344         String body = "<" + method + ">" + args + "</" + method + ">";
345         String msgtxt = "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\"><SOAP-ENV:Body>"
346                         + body + "</SOAP-ENV:Body>" + "</SOAP-ENV:Envelope>";
347         Message responseMsg = null;
348         try
349         {
350             ByteArrayInputStream istream = new ByteArrayInputStream(msgtxt.getBytes("ISO-8859-1"));
351             AxisEngine engine = getAxisServer();
352             Message msg = new Message(istream, false);
353             msgContext.setRequestMessage(msg);
354             engine.invoke(msgContext);
355             responseMsg = msgContext.getResponseMessage();
356             response.setProperty(HTTPConstants.HEADER_CACHE_CONTROL, "no-cache");
357             response.setProperty(HTTPConstants.HEADER_PRAGMA, "no-cache");
358             if (responseMsg == null)
359             {
360                 throw new Exception(Messages.getMessage("noResponse01"));
361             }
362         }
363         catch (AxisFault fault)
364         {
365             processAxisFault(fault);
366             configureResponseFromAxisFault(response, fault);
367             responseMsg = new Message(fault);
368         }
369         catch (Exception e)
370         {
371             response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "500");
372             responseMsg = convertExceptionToAxisFault(e, responseMsg);
373         }
374         response.setProperty(HTTPConstants.HEADER_CONTENT_TYPE, "text/xml");
375         response.write(responseMsg.getSOAPPartAsString());
376     }
377 
378     protected void reportServiceInfo(WriterMessageAdapter response, SOAPService service, String serviceName)
379     {
380         response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, "text/html");
381         response.write("<h1>" + service.getName() + "</h1>");
382         response.write("<p>" + Messages.getMessage("axisService00") + "</p>");
383         response.write("<i>" + Messages.getMessage("perhaps00") + "</i>");
384     }
385 
386     protected void processListRequest(WriterMessageAdapter response) throws AxisFault
387     {
388         AxisEngine engine = getAxisServer();
389         response.setProperty(HTTPConstants.HEADER_CONTENT_TYPE, "text/html");
390         if (enableList)
391         {
392             Document doc = Admin.listConfig(engine);
393             if (doc != null)
394             {
395                 XMLUtils.DocumentToWriter(doc, response.getWriter());
396             }
397             else
398             {
399                 response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "404");
400                 response.write("<h2>" + Messages.getMessage("error00") + "</h2>");
401                 response.write("<p>" + Messages.getMessage("noDeploy00") + "</p>");
402             }
403         }
404         else
405         {
406             response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "403");
407             response.write("<h2>" + Messages.getMessage("error00") + "</h2>");
408             response.write("<p><i>?list</i> " + Messages.getMessage("disabled00") + "</p>");
409         }
410     }
411 
412     private void reportNoWSDL(WriterMessageAdapter response, String moreDetailCode, AxisFault axisFault)
413     {
414         response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "404");
415         response.setProperty(HTTPConstants.HEADER_CONTENT_TYPE, "text/html");
416         response.write("<h2>" + Messages.getMessage("error00") + "</h2>");
417         response.write("<p>" + Messages.getMessage("noWSDL00") + "</p>");
418         if (moreDetailCode != null)
419         {
420             response.write("<p>" + Messages.getMessage(moreDetailCode) + "</p>");
421         }
422 
423     }
424 
425     protected void reportAvailableServices(UMOEventContext context, WriterMessageAdapter response)
426         throws ConfigurationException, AxisFault
427     {
428         AxisEngine engine = getAxisServer();
429         response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, "text/html");
430         response.write("<h2>And now... Some Services</h2>");
431         String version = MuleManifest.getProductVersion();
432         if (version == null)
433         {
434             version = "Version Not Set";
435         }
436         response.write("<h5>(Mule - " + version + ")</h5>");
437         Iterator i;
438 
439         try
440         {
441             response
442                 .write("<table width=\"400\"><tr><th>Mule Component Services</th><th>Axis Services</th></tr><tr><td width=\"200\" valign=\"top\">");
443             i = engine.getConfig().getDeployedServices();
444             listServices(i, response);
445             response.write("</td><td width=\"200\" valign=\"top\">");
446             i = ((MuleConfigProvider)engine.getConfig()).getAxisDeployedServices();
447             listServices(i, response);
448             response.write("</td></tr></table>");
449         }
450         catch (ConfigurationException configException)
451         {
452             if (configException.getContainedException() instanceof AxisFault)
453             {
454                 throw (AxisFault)configException.getContainedException();
455             }
456             else
457             {
458                 throw configException;
459             }
460         }
461 
462     }
463 
464     private void listServices(Iterator i, WriterMessageAdapter response)
465     {
466         response.write("<ul>");
467         while (i.hasNext())
468         {
469             ServiceDesc sd = (ServiceDesc)i.next();
470             StringBuffer sb = new StringBuffer(512);
471             sb.append("<li>");
472             String name = sd.getName();
473             sb.append(name);
474             sb.append(" <a href=\"");
475             if (sd.getEndpointURL() != null)
476             {
477                 sb.append(sd.getEndpointURL());
478                 if (!sd.getEndpointURL().endsWith("/"))
479                 {
480                     sb.append("/");
481                 }
482             }
483             sb.append(name);
484             sb.append("?wsdl\"><i>(wsdl)</i></a></li>");
485             response.write(sb.toString());
486             if (sd.getDocumentation() != null)
487             {
488                 response.write("<ul><h6>" + sd.getDocumentation() + "</h6></ul>");
489             }
490             ArrayList operations = sd.getOperations();
491             if (!operations.isEmpty())
492             {
493                 response.write("<ul>");
494                 OperationDesc desc;
495                 for (Iterator it = operations.iterator(); it.hasNext();)
496                 {
497                     desc = (OperationDesc)it.next();
498                     response.write("<li>" + desc.getName());
499                 }
500                 response.write("</ul>");
501             }
502         }
503         response.write("</ul>");
504     }
505 
506     protected void reportCantGetAxisService(UMOEventContext context, WriterMessageAdapter response)
507     {
508         response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "404");
509         response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, "text/html");
510         response.write("<h2>" + Messages.getMessage("error00") + "</h2>");
511         response.write("<p>" + Messages.getMessage("noService06") + "</p>");
512     }
513 
514     protected void doPost(UMOEventContext context, WriterMessageAdapter response)
515         throws Exception
516     {
517         String soapAction;
518         Message responseMsg;
519         AxisEngine engine = getAxisServer();
520         if (engine == null)
521         {
522 
523             throw new MessagingException(CoreMessages.objectIsNull("Axis Engine"), context.getMessage());
524         }
525         MessageContext msgContext = new MessageContext(engine);
526 
527         String contentType;
528         try
529         {
530             UMOEndpointURI endpointUri = getEndpoint(context);
531             populateMessageContext(msgContext, context, endpointUri);
532             if (securityProvider != null)
533             {
534                 if (logger.isDebugEnabled())
535                 {
536                     logger.debug("securityProvider:" + securityProvider);
537                 }
538                 msgContext.setProperty("securityProvider", securityProvider);
539             }
540 
541             Object request = context.getTransformedMessage();
542             if (request instanceof File)
543             {
544                 request = new FileInputStream((File)request);
545             }
546             else if (request instanceof byte[])
547             {
548                 request = new ByteArrayInputStream((byte[])request);
549             }
550 
551             Message requestMsg = new Message(request, false, context.getMessage().getStringProperty(
552                 HTTPConstants.HEADER_CONTENT_TYPE, null), context.getMessage().getStringProperty(
553                 HTTPConstants.HEADER_CONTENT_LOCATION, null));
554 
555             if (logger.isDebugEnabled())
556             {
557                 logger.debug("Request Message:" + requestMsg);
558             }
559             msgContext.setRequestMessage(requestMsg);
560             msgContext.setProperty("transport.url", endpointUri.toString());
561 
562             soapAction = getSoapAction(context);
563             if (soapAction != null)
564             {
565                 msgContext.setUseSOAPAction(true);
566                 msgContext.setSOAPActionURI(soapAction);
567             }
568             msgContext.setSession(new AxisMuleSession(context.getSession()));
569 
570             if (logger.isDebugEnabled())
571             {
572                 logger.debug("Invoking Axis Engine.");
573             }
574             engine.invoke(msgContext);
575             if (logger.isDebugEnabled())
576             {
577                 logger.debug("Return from Axis Engine.");
578             }
579             if (RequestContext.getExceptionPayload() instanceof Exception)
580             {
581                 throw (Exception)RequestContext.getExceptionPayload().getException();
582             }
583             // remove temporary file used for soap message with attachment
584             if (request instanceof File)
585             {
586                 ((File)request).delete();
587             }
588             responseMsg = msgContext.getResponseMessage();
589             if (responseMsg == null)
590             {
591                 throw new Exception(Messages.getMessage("noResponse01"));
592             }
593         }
594         catch (AxisFault fault)
595         {
596             logger.error(fault.toString() + " target service is: " + msgContext.getTargetService()
597                             + ". Event is: " + context.toString(), fault);
598             processAxisFault(fault);
599             configureResponseFromAxisFault(response, fault);
600             responseMsg = msgContext.getResponseMessage();
601             if (responseMsg == null)
602             {
603                 responseMsg = new Message(fault);
604             }
605         }
606         catch (Exception e)
607         {
608             responseMsg = msgContext.getResponseMessage();
609             response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "500");
610             responseMsg = convertExceptionToAxisFault(e, responseMsg);
611         }
612 
613         contentType = responseMsg.getContentType(msgContext.getSOAPConstants());
614 
615         sendResponse(contentType, response, responseMsg);
616 
617         if (logger.isDebugEnabled())
618         {
619             logger.debug("Response sent.");
620         }
621     }
622 
623     private UMOEndpointURI getEndpoint(UMOEventContext context) throws MalformedEndpointException
624     {
625         String endpoint = context.getEndpointURI().getAddress();
626         String request = context.getMessage().getStringProperty(HttpConnector.HTTP_REQUEST_PROPERTY, null);
627         if (request != null)
628         {
629             int i = endpoint.indexOf("/", endpoint.indexOf("://") + 3);
630             if (i > -1)
631             {
632                 endpoint = endpoint.substring(0, i);
633             }
634             endpoint += request;
635             return new MuleEndpointURI(endpoint);
636         }
637         return context.getEndpointURI();
638     }
639 
640     private void configureResponseFromAxisFault(WriterMessageAdapter response, AxisFault fault)
641     {
642         int status = getHttpResponseStatus(fault);
643         if (status == 401)
644         {
645             response.setProperty(HttpConstants.HEADER_WWW_AUTHENTICATE, "Basic realm=\"AXIS\"");
646         }
647         response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, String.valueOf(status));
648     }
649 
650     private Message convertExceptionToAxisFault(Exception exception, Message responseMsg)
651     {
652         logger.error(exception.getMessage(), exception);
653         if (responseMsg == null)
654         {
655             AxisFault fault = AxisFault.makeFault(exception);
656             processAxisFault(fault);
657             responseMsg = new Message(fault);
658         }
659         return responseMsg;
660     }
661 
662     protected int getHttpResponseStatus(AxisFault af)
663     {
664         return af.getFaultCode().getLocalPart().startsWith("Server.Unauth") ? 401 : '\u01F4';
665     }
666 
667     private void sendResponse(String contentType,
668                               WriterMessageAdapter response,
669                               Message responseMsg) throws Exception
670     {
671         if (responseMsg == null)
672         {
673             response.setProperty(HttpConnector.HTTP_STATUS_PROPERTY, "204");
674             if (logger.isDebugEnabled())
675             {
676                 logger.debug("NO AXIS MESSAGE TO RETURN!");
677             }
678         }
679         else
680         {
681             if (logger.isDebugEnabled())
682             {
683                 logger.debug("Returned Content-Type:" + contentType);
684             }
685                 response.setProperty(HttpConstants.HEADER_CONTENT_TYPE, contentType);
686                 ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
687                 responseMsg.writeTo(baos);
688                 response.write(baos.toString());
689         }
690     }
691 
692     private void populateMessageContext(MessageContext msgContext,
693                                         UMOEventContext context,
694                                         UMOEndpointURI endpointUri) throws AxisFault, ConfigurationException
695     {
696         UMOMessage msg = context.getMessage();
697 
698         if (logger.isDebugEnabled())
699         {
700             logger.debug("MessageContext:" + msgContext);
701             logger.debug("HEADER_CONTENT_TYPE:"
702                             + msg.getStringProperty(HttpConstants.HEADER_CONTENT_TYPE, null));
703             logger.debug("HEADER_CONTENT_LOCATION:"
704                             + msg.getStringProperty(HttpConstants.HEADER_CONTENT_LOCATION, null));
705             logger.debug("Constants.MC_HOME_DIR:" + String.valueOf(getHomeDir()));
706             logger.debug("Constants.MC_RELATIVE_PATH:" + endpointUri.getPath());
707             logger.debug("HTTPConstants.HEADER_AUTHORIZATION:" + msg.getStringProperty("Authorization", null));
708             logger.debug("Constants.MC_REMOTE_ADDR:" + endpointUri.getHost());
709         }
710 
711         msgContext.setTransportName(transportName);
712         msgContext.setProperty("home.dir", getHomeDir());
713         msgContext.setProperty("path", endpointUri.getPath());
714         msgContext.setProperty(HTTPConstants.MC_HTTP_SERVLET, this);
715         msgContext.setProperty(HTTPConstants.MC_HTTP_SERVLETLOCATION, endpointUri.getPath());
716         // determine service name
717         String serviceName = getServiceName(context, endpointUri);
718         // Validate Service path against request path
719         SOAPService service = msgContext.getAxisEngine().getConfig().getService(
720             new QName(serviceName.substring(1)));
721 
722         // if using jms or vm we can skip this
723         if (!("vm".equalsIgnoreCase(endpointUri.getScheme()) || "jms".equalsIgnoreCase(endpointUri.getScheme())))
724         {            
725             // Component Name is set by Mule so if its null we can skip this check
726             if (service.getOption(AxisConnector.SERVICE_PROPERTY_COMPONENT_NAME) != null)
727             {
728                 String servicePath = (String)service.getOption("servicePath");
729                 if (StringUtils.isEmpty(endpointUri.getPath()))
730                 {
731                     if (!("/" + endpointUri.getAddress()).startsWith(servicePath + serviceName))
732                     {
733                         throw new AxisFault("Failed to find service: " + "/" + endpointUri.getAddress());
734                     }
735                 }
736                 else if (!endpointUri.getPath().startsWith(servicePath + serviceName))
737                 {
738                     throw new AxisFault("Failed to find service: " + endpointUri.getPath());
739                 }
740             }
741         }
742 
743         msgContext.setProperty(HTTPConstants.MC_HTTP_SERVLETPATHINFO, serviceName);
744         msgContext.setProperty("serviceName", serviceName);
745 
746         msgContext.setProperty("Authorization", msg.getStringProperty("Authorization", null));
747         msgContext.setProperty("remoteaddr", endpointUri.getHost());
748         ServletEndpointContextImpl sec = new ServletEndpointContextImpl();
749         msgContext.setProperty("servletEndpointContext", sec);
750     }
751 
752     private String getSoapAction(UMOEventContext context) throws AxisFault
753     {
754         String soapAction = context.getMessage().getStringProperty("SOAPAction", null);
755         if (logger.isDebugEnabled())
756         {
757             logger.debug("Header Soap Action:" + soapAction);
758         }
759 
760         if (StringUtils.isEmpty(soapAction))
761         {
762             soapAction = context.getEndpointURI().getAddress();
763         }
764         return soapAction;
765     }
766 
767     protected String getServiceName(UMOEventContext context, UMOEndpointURI endpointUri) throws AxisFault
768     {
769         String serviceName = endpointUri.getPath();
770         if (StringUtils.isEmpty(serviceName))
771         {
772             serviceName = getSoapAction(context);
773             serviceName = serviceName.replaceAll("\"", "");
774             int i = serviceName.indexOf("/", serviceName.indexOf("//"));
775             if (i < -1)
776             {
777                 serviceName = serviceName.substring(i + 2);
778             }
779 
780         }
781 
782         int i = serviceName.lastIndexOf('/');
783         if (i > -1)
784         {
785             serviceName = serviceName.substring(i);
786         }
787         i = serviceName.lastIndexOf('?');
788         if (i > -1)
789         {
790             serviceName = serviceName.substring(0, i);
791         }
792         return serviceName;
793     }
794 
795     public String getTransportName()
796     {
797         return transportName;
798     }
799 
800     public void setTransportName(String transportName)
801     {
802         this.transportName = transportName;
803     }
804 
805     public boolean isEnableList()
806     {
807         return enableList;
808     }
809 
810     public void setEnableList(boolean enableList)
811     {
812         this.enableList = enableList;
813     }
814 
815     public String getHomeDir()
816     {
817         if (homeDir == null)
818         {
819             homeDir = MuleManager.getConfiguration().getWorkingDirectory() + DEFAULT_AXIS_HOME;
820         }
821         return homeDir;
822     }
823 
824     public void setHomeDir(String homeDir)
825     {
826         this.homeDir = homeDir;
827     }
828 
829     public AxisServer getAxisServer()
830     {
831         return axisServer;
832     }
833 
834     public void setAxisServer(AxisServer axisServer)
835     {
836         this.axisServer = axisServer;
837     }
838 }