1
2
3
4
5
6
7
8
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
71
72
73
74
75
76
77
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
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
140 }
141
142 public void doGet(UMOEventContext context, WriterMessageAdapter response)
143 throws UMOException, IOException
144 {
145 try
146 {
147
148
149
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
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
717 String serviceName = getServiceName(context, endpointUri);
718
719 SOAPService service = msgContext.getAxisEngine().getConfig().getService(
720 new QName(serviceName.substring(1)));
721
722
723 if (!("vm".equalsIgnoreCase(endpointUri.getScheme()) || "jms".equalsIgnoreCase(endpointUri.getScheme())))
724 {
725
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 }