/*
* 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.axis2.util;
import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMNamespace;
import org.apache.axiom.soap.SOAP12Constants;
import org.apache.axiom.soap.SOAPConstants;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.SOAPFactory;
import org.apache.axiom.soap.SOAPFault;
import org.apache.axiom.soap.SOAPFaultCode;
import org.apache.axiom.soap.SOAPFaultDetail;
import org.apache.axiom.soap.SOAPFaultReason;
import org.apache.axiom.soap.SOAPFaultSubCode;
import org.apache.axiom.soap.SOAPFaultValue;
import org.apache.axiom.soap.SOAPHeader;
import org.apache.axiom.soap.SOAPHeaderBlock;
import org.apache.axiom.soap.SOAPProcessingException;
import org.apache.axiom.soap.SOAPFaultNode;
import org.apache.axiom.util.UIDGenerator;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.addressing.AddressingConstants;
import org.apache.axis2.addressing.AddressingConstants.Final;
import org.apache.axis2.addressing.AddressingHelper;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.addressing.RelatesTo;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.context.OperationContext;
import org.apache.axis2.description.*;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.transport.http.HTTPConstants;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.namespace.QName;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Iterator;
import java.util.List;
public class MessageContextBuilder {
protected static final Log log = LogFactory.getLog(MessageContextBuilder.class);
/**
* Creates a new 'response' message context based on a 'request' message context
* Only deals with properties/fields that are the same for both 'normal' and fault responses.
*
* @param inMessageContext context for which the response will be created
* @return response message context for the given in message context
* @throws org.apache.axis2.AxisFault error in creating the response message context
*/
private static MessageContext createResponseMessageContext(MessageContext inMessageContext)
throws AxisFault {
MessageContext newmsgCtx =
inMessageContext.getConfigurationContext().createMessageContext();
newmsgCtx.setSessionContext(inMessageContext.getSessionContext());
newmsgCtx.setTransportIn(inMessageContext.getTransportIn());
newmsgCtx.setTransportOut(inMessageContext.getTransportOut());
newmsgCtx.setServerSide(inMessageContext.isServerSide());
newmsgCtx.setProperty(MessageContext.IN_MESSAGE_CONTEXT, inMessageContext);
// TODO: Should this be specifying (or defaulting to) the "response" relationshipType??
newmsgCtx.addRelatesTo(new RelatesTo(inMessageContext.getOptions().getMessageId()));
newmsgCtx.setProperty(AddressingConstants.WS_ADDRESSING_VERSION,
inMessageContext.getProperty(
AddressingConstants.WS_ADDRESSING_VERSION));
newmsgCtx.setProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES,
inMessageContext.getProperty(
AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES));
newmsgCtx.setProperty(WSDL2Constants.ENDPOINT_LOCAL_NAME,
inMessageContext.getProperty(WSDL2Constants.ENDPOINT_LOCAL_NAME));
newmsgCtx.setProperty(Constants.AXIS_BINDING_OPERATION,
inMessageContext.getProperty(Constants.AXIS_BINDING_OPERATION));
// Setting the charater set encoding
newmsgCtx.setProperty(Constants.Configuration.CHARACTER_SET_ENCODING,
inMessageContext.getProperty(
Constants.Configuration.CHARACTER_SET_ENCODING));
//Setting the message type property
newmsgCtx.setProperty(Constants.Configuration.MESSAGE_TYPE,
inMessageContext.getProperty(Constants.Configuration.MESSAGE_TYPE));
newmsgCtx.setDoingREST(inMessageContext.isDoingREST());
newmsgCtx.setOperationContext(inMessageContext.getOperationContext());
newmsgCtx.setProperty(MessageContext.TRANSPORT_OUT,
inMessageContext.getProperty(MessageContext.TRANSPORT_OUT));
newmsgCtx.setProperty(Constants.OUT_TRANSPORT_INFO,
inMessageContext.getProperty(Constants.OUT_TRANSPORT_INFO));
handleCorrelationID(inMessageContext,newmsgCtx);
return newmsgCtx;
}
/**
* Creates a MessageContext for use with a non-fault response based on an request MessageContext
*
* @param inMessageContext for the out message context to be created
* @return created out message context from the given in message context
* @throws org.apache.axis2.AxisFault error in creating the out message context
*/
public static MessageContext createOutMessageContext(MessageContext inMessageContext)
throws AxisFault {
// Create a basic response MessageContext with basic fields copied
MessageContext newmsgCtx = createResponseMessageContext(inMessageContext);
// Simple response so set To to value of inbound ReplyTo
newmsgCtx.setTo(inMessageContext.getReplyTo());
if (newmsgCtx.getTo() == null) {
newmsgCtx.setTo(new EndpointReference(AddressingConstants.Final.WSA_ANONYMOUS_URL));
}
// do Target Resolution
TargetResolver targetResolver =
newmsgCtx.getConfigurationContext().getAxisConfiguration().getTargetResolverChain();
if (targetResolver != null) {
targetResolver.resolveTarget(newmsgCtx);
}
// Determine ReplyTo for response message.
AxisService axisService = inMessageContext.getAxisService();
if (axisService != null && Constants.SCOPE_SOAP_SESSION.equals(axisService.getScope())) {
//If the wsa 2004/08 (submission) spec is in effect use the wsa anonymous URI as the default replyTo value.
//This is necessary because the wsa none URI is not available in that spec.
Object version = inMessageContext.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
if (AddressingConstants.Submission.WSA_NAMESPACE.equals(version)) {
newmsgCtx.setReplyTo(
new EndpointReference(AddressingConstants.Submission.WSA_ANONYMOUS_URL));
} else {
newmsgCtx.setReplyTo(new EndpointReference(AddressingConstants.Final.WSA_NONE_URI));
}
newmsgCtx.setMessageID(UIDGenerator.generateURNString());
// add the service group id as a reference parameter
String serviceGroupContextId = inMessageContext.getServiceGroupContextId();
if (serviceGroupContextId != null && !"".equals(serviceGroupContextId)) {
EndpointReference replyToEPR = newmsgCtx.getReplyTo();
replyToEPR.addReferenceParameter(new QName(Constants.AXIS2_NAMESPACE_URI,
Constants.SERVICE_GROUP_ID,
Constants.AXIS2_NAMESPACE_PREFIX),
serviceGroupContextId);
}
} else {
EndpointReference outboundToEPR = newmsgCtx.getTo();
Object version = newmsgCtx.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
if (AddressingConstants.Submission.WSA_NAMESPACE.equals(version) ||
(outboundToEPR != null && !outboundToEPR.hasAnonymousAddress())) {
newmsgCtx.setMessageID(UIDGenerator.generateURNString());
newmsgCtx.setReplyTo(new EndpointReference(AddressingConstants.Final.WSA_NONE_URI));
}
}
// Set wsa:Action for response message
// Use specified value if available
AxisOperation ao = inMessageContext.getAxisOperation();
if ((ao != null) && (ao.getOutputAction() != null)) {
newmsgCtx.setWSAAction(ao.getOutputAction());
} else { // If not, simply copy the request value. Almost always invalid.
newmsgCtx.setWSAAction(inMessageContext.getWSAAction());
}
if (ao != null){
newmsgCtx.setAxisMessage(ao.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE));
}
// setting the out bound binding message
AxisBindingMessage inboundAxisBindingMessage
= (AxisBindingMessage)inMessageContext.getProperty(Constants.AXIS_BINDING_MESSAGE);
if (inboundAxisBindingMessage != null){
AxisBindingOperation axisBindingOperation = inboundAxisBindingMessage.getAxisBindingOperation();
newmsgCtx.setProperty(Constants.AXIS_BINDING_MESSAGE,
axisBindingOperation.getChild(WSDLConstants.MESSAGE_LABEL_OUT_VALUE));
}
newmsgCtx.setDoingMTOM(inMessageContext.isDoingMTOM());
newmsgCtx.setDoingSwA(inMessageContext.isDoingSwA());
newmsgCtx.setServiceGroupContextId(inMessageContext.getServiceGroupContextId());
// Ensure transport settings match the scheme for the To EPR
setupCorrectTransportOut(newmsgCtx);
return newmsgCtx;
}
/**
* Copies the correlation id (jms) from the in message ctx
* to the out message ctx. Currently this check is for jms
* only, but can be expanded to other transports if the need
* arises.
*/
private static void handleCorrelationID(MessageContext inMessageContext,MessageContext outMessageContext)
{
if (inMessageContext.getIncomingTransportName()!= null &&
inMessageContext.getIncomingTransportName().equals(Constants.TRANSPORT_JMS))
{
log.debug("Incoming Transport is JMS, lets check for JMS correlation id");
String correlationId =
(String) inMessageContext.getProperty(Constants.JMS_COORELATION_ID);
log.debug("Correlation id is " + correlationId);
if (correlationId != null && correlationId.length() > 0) {
outMessageContext.setProperty(Constants.JMS_COORELATION_ID, correlationId);
}
}
}
/**
* This method is called to handle any error that occurs at inflow or outflow. But if the
* method is called twice, it implies that sending the error handling has failed, in which case
* the method logs the error and exits.
*/
public static MessageContext createFaultMessageContext(MessageContext processingContext,
Throwable e)
throws AxisFault {
if (processingContext.isProcessingFault()) {
// We get the error file processing the fault. nothing we can do
throw new AxisFault(Messages.getMessage("errorwhileProcessingFault"));
}
// See if the throwable is an AxisFault and if it already contains the
// fault MessageContext
if (e instanceof AxisFault) {
MessageContext faultMessageContext = ((AxisFault) e).getFaultMessageContext();
if (faultMessageContext != null) {
// These may not have been set correctly when the original context
// was created -- an example of this is with the SimpleHTTPServer.
// I'm not sure if this is the correct thing to do, or if the
// code that created this context in the first place should
// expect that the transport out info was set correctly, as
// it may need to use that info at some point before we get to
// this code.
faultMessageContext.setProperty(MessageContext.TRANSPORT_OUT,
processingContext.getProperty(
MessageContext.TRANSPORT_OUT));
faultMessageContext.setProperty(Constants.OUT_TRANSPORT_INFO,
processingContext.getProperty(
Constants.OUT_TRANSPORT_INFO));
faultMessageContext.setProperty(MessageContext.IN_MESSAGE_CONTEXT, processingContext);
faultMessageContext.setProcessingFault(true);
return faultMessageContext;
}
}
// Create a basic response MessageContext with basic fields copied
MessageContext faultContext = createResponseMessageContext(processingContext);
// Register the fault message context
OperationContext operationContext = processingContext.getOperationContext();
if (operationContext != null) {
processingContext.getAxisOperation().addFaultMessageContext(faultContext,
operationContext);
}
faultContext.setProcessingFault(true);
// Set wsa:Action for response message
// Use specified value if available
String faultAction = (e instanceof AxisFault) ? ((AxisFault)e).getFaultAction() : null;
if (faultAction == null) {
AxisOperation op = processingContext.getAxisOperation();
if (op != null && op.getFaultAction() != null) {
// TODO: Should the op be able to pick a fault action based on the fault?
faultAction = op.getFaultAction();
} else { //If, for some reason there is no value set, should use a sensible action.
faultAction = Final.WSA_SOAP_FAULT_ACTION;
}
}
faultContext.setWSAAction(faultAction);
// there are some information that the fault thrower wants to pass to the fault path.
// Means that the fault is a ws-addressing one hence use the ws-addressing fault action.
Object faultInfoForHeaders =
processingContext.getLocalProperty(Constants.FAULT_INFORMATION_FOR_HEADERS);
if (faultInfoForHeaders != null) {
faultContext.setProperty(Constants.FAULT_INFORMATION_FOR_HEADERS, faultInfoForHeaders);
// Note that this overrides any action set above
faultContext.setWSAAction(Final.WSA_FAULT_ACTION);
}
// if the exception is due to a problem in the faultTo header itself, we can not use that
// fault information to send the error. Try to send using replyTo, else leave it to transport
boolean shouldSendFaultToFaultTo =
AddressingHelper.shouldSendFaultToFaultTo(processingContext);
EndpointReference faultTo = processingContext.getFaultTo();
if (faultTo != null && shouldSendFaultToFaultTo) {
faultContext.setTo(faultTo);
} else {
faultContext.setTo(processingContext.getReplyTo());
}
if (faultContext.getTo() == null) {
faultContext.setTo(new EndpointReference(AddressingConstants.Final.WSA_ANONYMOUS_URL));
}
// Not worth setting up the session information on a fault flow
EndpointReference outboundToEPR = faultContext.getTo();
Object version = faultContext.getProperty(AddressingConstants.WS_ADDRESSING_VERSION);
if (AddressingConstants.Submission.WSA_NAMESPACE.equals(version) ||
(outboundToEPR != null && !outboundToEPR.hasAnonymousAddress())) {
faultContext.setMessageID(UIDGenerator.generateURNString());
faultContext.setReplyTo(new EndpointReference(AddressingConstants.Final.WSA_NONE_URI));
}
// do Target Resolution
TargetResolver targetResolver = faultContext.getConfigurationContext()
.getAxisConfiguration().getTargetResolverChain();
if (targetResolver != null) {
targetResolver.resolveTarget(faultContext);
}
// Ensure transport settings match the scheme for the To EPR
setupCorrectTransportOut(faultContext);
SOAPEnvelope envelope = createFaultEnvelope(processingContext, e);
faultContext.setEnvelope(envelope);
//get the SOAP headers, user is trying to send in the fault
// TODO: Rationalize this mechanism a bit - maybe headers should live in the fault?
List soapHeadersList =
(List) processingContext.getProperty(SOAPConstants.HEADER_LOCAL_NAME);
if (soapHeadersList != null) {
SOAPHeader soapHeaderElement = envelope.getHeader();
for (Object aSoapHeadersList : soapHeadersList) {
OMElement soapHeaderBlock = (OMElement)aSoapHeadersList;
soapHeaderElement.addChild(soapHeaderBlock);
}
}
// TODO: Transport-specific stuff in here? Why? Is there a better way?
// now add HTTP Headers
faultContext.setProperty(HTTPConstants.HTTP_HEADERS,
processingContext.getProperty(HTTPConstants.HTTP_HEADERS));
//setting the out bound binding message
AxisBindingMessage inboundAxisBindingMessage
= (AxisBindingMessage)processingContext.getProperty(Constants.AXIS_BINDING_MESSAGE);
if (inboundAxisBindingMessage != null){
AxisBindingOperation axisBindingOperation = inboundAxisBindingMessage.getAxisBindingOperation();
faultContext.setProperty(Constants.AXIS_BINDING_MESSAGE,
axisBindingOperation.getChild(WSDLConstants.MESSAGE_LABEL_OUT_VALUE));
}
return faultContext;
}
/**
* Ensure that if the scheme of the To EPR for the response is different than the
* transport used for the request that the correct TransportOut is available
*/
private static void setupCorrectTransportOut(MessageContext context) throws AxisFault {
// Determine that we have the correct transport available.
TransportOutDescription transportOut = context.getTransportOut();
try {
EndpointReference responseEPR = context.getTo();
if (context.isServerSide() && responseEPR != null) {
if (!responseEPR.hasAnonymousAddress() && !responseEPR.hasNoneAddress()) {
URI uri = new URI(responseEPR.getAddress());
String scheme = uri.getScheme();
if ((transportOut == null) || !transportOut.getName().equals(scheme)) {
ConfigurationContext configurationContext =
context.getConfigurationContext();
transportOut = configurationContext.getAxisConfiguration()
.getTransportOut(scheme);
if (transportOut == null) {
throw new AxisFault("Can not find the transport sender : " + scheme);
}
context.setTransportOut(transportOut);
}
if (context.getOperationContext() != null) {
context.getOperationContext().setProperty(
Constants.DIFFERENT_EPR, Constants.VALUE_TRUE);
}
}
}
} catch (URISyntaxException urise) {
throw AxisFault.makeFault(urise);
}
}
/**
* Information to create the SOAPFault can be extracted from different places.
* 1. Those information may have been put in to the message context by some handler. When someone
* is putting like that, he must make sure the SOAPElements he is putting must be from the
* correct SOAP Version.
* 2. SOAPProcessingException is flexible enough to carry information about the fault. For example
* it has an attribute to store the fault code. The fault reason can be extracted from the
* message of the exception. I opted to put the stacktrace under the detail element.
* eg : <Detail>
* <Exception> stack trace goes here </Exception>
* <Detail>
* <p/>
* If those information can not be extracted from any of the above places, I default the soap
* fault values to following.
* <Fault>
* <Code>
* <Value>env:Receiver</Value>
* </Code>
* <Reason>
* <Text>unknown</Text>
* </Reason>
* <Role/>
* <Node/>
* <Detail/>
* </Fault>
* <p/>
* -- EC
*
* @param context
* @param e
*/
private static SOAPEnvelope createFaultEnvelope(MessageContext context, Throwable e) {
SOAPEnvelope envelope;
if(log.isDebugEnabled()){
log.debug("start createFaultEnvelope()");
}
if (context.isSOAP11()) {
envelope = OMAbstractFactory.getSOAP11Factory().getDefaultFaultEnvelope();
} else {
// Following will make SOAP 1.2 as the default, too.
envelope = OMAbstractFactory.getSOAP12Factory().getDefaultFaultEnvelope();
}
SOAPFault fault = envelope.getBody().getFault();
SOAPProcessingException soapException = null;
AxisFault axisFault = null;
if (e == null) return envelope;
if (e instanceof AxisFault) {
axisFault = (AxisFault) e;
} else if (e.getCause() instanceof AxisFault) {
axisFault = (AxisFault) e.getCause();
}
if (axisFault != null) {
Iterator iter = axisFault.headerIterator();
while (iter.hasNext()) {
SOAPHeaderBlock header = (SOAPHeaderBlock) iter.next();
envelope.getHeader().addChild(header);
}
}
if (e instanceof SOAPProcessingException) {
soapException = (SOAPProcessingException) e;
} else if (axisFault != null) {
if (axisFault.getCause() instanceof SOAPProcessingException) {
soapException = (SOAPProcessingException) axisFault.getCause();
}
}
// user can set the fault information to the message context or to the AxisFault itself.
// whatever user sets to the message context, supercedes eerything.
Object faultCode = context.getProperty(SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME);
String soapFaultCode = "";
if (faultCode != null) {
if(log.isDebugEnabled()){
log.debug("faultCode != null");
}
fault.setCode((SOAPFaultCode) faultCode);
soapFaultCode = ((SOAPFaultCode) faultCode).getText();
} else if (soapException != null) {
if(log.isDebugEnabled()){
log.debug("soapException != null");
}
soapFaultCode = soapException.getFaultCode();
OMNamespace namespace = null;
if(envelope!=null){
if(log.isDebugEnabled()){
log.debug("envelope!=null");
}
namespace = envelope.getNamespace();
}
if (namespace != null){
String sfcLocalPart = soapFaultCode.substring(soapFaultCode.lastIndexOf(":")+1);
//If the fault code is one of the predefined ones that make sure the prefix
//matches that of the envelope NS
if (sfcLocalPart.equals(SOAPConstants.FAULT_CODE_VERSION_MISMATCH) ||
sfcLocalPart.equals(SOAPConstants.FAULT_CODE_MUST_UNDERSTAND) ||
sfcLocalPart.equals(SOAPConstants.FAULT_CODE_DATA_ENCODING_UNKNOWN) ||
sfcLocalPart.equals(SOAPConstants.FAULT_CODE_RECEIVER) ||
sfcLocalPart.equals(SOAPConstants.FAULT_CODE_SENDER)) {
if(log.isDebugEnabled()){
log.debug("SoapFaultCode local part= " +sfcLocalPart);
}
String prefix = namespace.getPrefix() + ":";
if (!soapFaultCode.contains(":")) {
soapFaultCode = prefix + soapFaultCode;
} else {
soapFaultCode = prefix + soapFaultCode.substring(soapFaultCode.indexOf(":")+1);
}
if(log.isDebugEnabled()){
log.debug("SoapFaultCode reset to " +soapFaultCode);
}
}
} else {
if(log.isDebugEnabled()){
log.debug("Namespace is null, cannot attach prefix to SOAPFaultCode");
}
}
if(log.isDebugEnabled()){
log.debug("SoapFaultCode ="+soapFaultCode);
}
} else if (axisFault != null) {
if(log.isDebugEnabled()){
log.debug("axisFault != null");
}
if (axisFault.getFaultCodeElement() != null) {
fault.setCode(axisFault.getFaultCodeElement());
soapFaultCode = axisFault.getFaultCodeElement().getText();
} else {
QName faultCodeQName = axisFault.getFaultCode();
if (faultCodeQName != null) {
if(log.isDebugEnabled()){
log.debug("prefix ="+faultCodeQName.getPrefix());
log.debug("Fault Code namespace ="+faultCodeQName.getNamespaceURI());
log.debug("Fault Code ="+faultCodeQName.getLocalPart());
}
if (faultCodeQName.getLocalPart().indexOf(":") == -1) {
if(log.isDebugEnabled()){
log.debug("faultCodeQName.getLocalPart().indexOf(\":\") == -1");
}
String prefix = faultCodeQName.getPrefix();
if(log.isDebugEnabled()){
log.debug("prefix = "+prefix);
}
String uri = faultCodeQName.getNamespaceURI();
// Get the specified uri
uri = uri == null || "" .equals(uri) ?
fault.getNamespace().getNamespaceURI() : uri;
// Make sure the prefix and uri are declared on the fault, and
// get the resulting prefix. If no prefix is defined, let declareNamespace
// generate one.
prefix = fault.declareNamespace(uri, prefix.length() == 0 ? null : prefix).getPrefix();
soapFaultCode = prefix + ":" + faultCodeQName.getLocalPart();
if(log.isDebugEnabled()){
log.debug("Altered soapFaultCode ="+soapFaultCode);
}
} else {
soapFaultCode = faultCodeQName.getLocalPart();
}
}
}
}
// defaulting to fault code Receiver, if no message is available
if (faultCode == null && context.getEnvelope() != null) {
soapFaultCode = ("".equals(soapFaultCode) || (soapFaultCode == null))
? SOAP12Constants.SOAP_DEFAULT_NAMESPACE_PREFIX + ":" +
context.getEnvelope().getVersion().getReceiverFaultCode().getLocalPart()
: soapFaultCode;
}
if (faultCode == null) {
if(log.isDebugEnabled()){
log.debug("faultCode == null");
}
if (context.isSOAP11()) {
if(log.isDebugEnabled()){
log.debug("context.isSOAP11() = true");
SOAPFaultCode code = (fault!=null)?fault.getCode():null;
SOAPFaultValue value = (code!=null)?code.getValue():null;
if(value !=null){
QName name = value.getQName();
log.debug("prefix ="+name.getPrefix());
log.debug("Fault Code namespace ="+name.getNamespaceURI());
log.debug("Fault Code ="+name.getLocalPart());
}
}
fault.getCode().setText(soapFaultCode);
} else {
if(log.isDebugEnabled()){
log.debug("context.isSOAP11() = false");
SOAPFaultCode code = (fault!=null)?fault.getCode():null;
SOAPFaultValue value = (code!=null)?code.getValue():null;
if(value !=null){
QName name = value.getQName();
log.debug("prefix ="+name.getPrefix());
log.debug("Fault Code namespace ="+name.getNamespaceURI());
log.debug("Fault Code ="+name.getLocalPart());
}
}
SOAPFaultValue value = fault.getCode().getValue();
if(log.isDebugEnabled()){
log.debug("soapFaultCode originally was set to : " + soapFaultCode);
}
OMNamespace namespace = value.getNamespace();
soapFaultCode = switchNamespacePrefix(soapFaultCode, namespace);
value.setText(soapFaultCode);
}
}
if (axisFault != null && !context.isSOAP11()) {
if (axisFault.getFaultSubCodes() != null) {
List faultSubCodes = axisFault.getFaultSubCodes();
QName faultSubCodeQName;
for (Object faultSubCode : faultSubCodes) {
faultSubCodeQName = (QName)faultSubCode;
SOAPFactory sf = (SOAPFactory)envelope.getOMFactory();
SOAPFaultSubCode soapFaultSubCode = sf.createSOAPFaultSubCode(fault.getCode());
SOAPFaultValue saopFaultValue = sf.createSOAPFaultValue(fault.getCode());
saopFaultValue.setText(faultSubCodeQName);
soapFaultSubCode.setValue(saopFaultValue);
fault.getCode().setSubCode(soapFaultSubCode);
}
}
}
SOAPFaultReason faultReason = (SOAPFaultReason)context.getProperty(
SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME);
if (faultReason == null && axisFault != null) {
faultReason = axisFault.getFaultReasonElement();
}
if (faultReason != null) {
fault.setReason(faultReason);
} else {
String message = "";
if (soapException != null) {
message = soapException.getMessage();
} else if (axisFault != null) {
// Couldn't find FaultReasonElement, try reason string
message = axisFault.getReason();
}
if (message == null || "".equals(message)) {
message = getFaultReasonFromException(e, context);
}
if (message == null || "".equals(message)) message = "unknown";
if (context.isSOAP11()) {
fault.getReason().setText(message);
} else {
fault.getReason().getFirstSOAPText().setLang("en-US");
fault.getReason().getFirstSOAPText().setText(message);
}
}
Object faultRole = context.getProperty(SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME);
if (faultRole != null) {
fault.getRole().setText((String) faultRole);
} else if (axisFault != null) {
if (axisFault.getFaultRoleElement() != null) {
fault.setRole(axisFault.getFaultRoleElement());
}
}
Object faultNode = context.getProperty(SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME);
if (faultNode != null) {
SOAPFaultNode soapFaultNode = fault.getNode();
if(soapFaultNode != null) {
soapFaultNode.setText((String) faultNode);
}
} else if (axisFault != null) {
if (axisFault.getFaultNodeElement() != null) {
fault.setNode(axisFault.getFaultNodeElement());
}
}
// Allow handlers to override the sendStacktraceDetailsWithFaults setting from the Configuration to allow
// WS-* protocol faults to not include the exception.
boolean sendStacktraceDetailsWithFaults = false;
OperationContext oc = context.getOperationContext();
Object flagFromContext = null;
if (oc != null) {
flagFromContext = context.getOperationContext()
.getProperty(Constants.Configuration.SEND_STACKTRACE_DETAILS_WITH_FAULTS);
}
if (flagFromContext != null) {
sendStacktraceDetailsWithFaults = JavaUtils.isTrue(flagFromContext);
} else {
Parameter param = context.getParameter(
Constants.Configuration.SEND_STACKTRACE_DETAILS_WITH_FAULTS);
if (param != null) {
sendStacktraceDetailsWithFaults = JavaUtils.isTrue(param.getValue());
}
}
Object faultDetail = context.getProperty(SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME);
if (faultDetail != null) {
fault.setDetail((SOAPFaultDetail) faultDetail);
} else if (axisFault != null) {
if (axisFault.getFaultDetailElement() != null) {
fault.setDetail(axisFault.getFaultDetailElement());
} else {
OMElement detail = axisFault.getDetail();
if (detail != null) {
fault.getDetail().addDetailEntry(detail);
} else if (sendStacktraceDetailsWithFaults) {
fault.setException(axisFault);
}
}
} else if (fault.getException() == null && sendStacktraceDetailsWithFaults) {
if (e instanceof Exception) {
fault.setException((Exception) e);
} else {
fault.setException(new Exception(e));
}
}
if(log.isDebugEnabled())
log.debug("End createFaultEnvelope()");
return envelope;
}
/**
* Switch the namespace prefix in the soap fault code. It should match the prefix used
* by the outgoing soap envelope.
*
* @param soapFaultCode
* @param namespace
* @return
*/
public static String switchNamespacePrefix(String soapFaultCode, OMNamespace namespace) {
if(soapFaultCode != null &&
soapFaultCode.endsWith(":" + SOAPConstants.FAULT_CODE_VERSION_MISMATCH)) {
String prefix = namespace.getPrefix();
if(log.isDebugEnabled()){
log.debug("prefix being used in the outgoing soap envelope is : " + prefix);
}
// The following methods set the prefix of the incoming soap envelope in soapFaultCode
// validateSOAPVersion method in BuilderUtil or
// identifySOAPVersion method in StAXSOAPModelBuilder
// But the outgoing envelope may have a different prefix, if it does then
// we need to strip the prefix set by those methods and add the
// correct one.
if (!soapFaultCode.startsWith(prefix + ":")) {
if(log.isDebugEnabled()){
log.debug("stripping old prefix and adding the new one - " + prefix);
}
// Strip the original prefix
int index = soapFaultCode.indexOf(':') + 1;
soapFaultCode = soapFaultCode.substring(index);
// Use the correct prefix for the outgoing soap envelope namespace
soapFaultCode = prefix + ":" + soapFaultCode;
}
}
if(log.isDebugEnabled()){
log.debug("soapFaultCode is being set to : " + soapFaultCode);
}
return soapFaultCode;
}
/**
* By the time the exception comes here it can be wrapped by so many levels. This will crip down
* to the root cause and get the initial error depending on the property
*
* @param e exception to get the string representation
* @param context current message context for which the exception occurred
* @return generated fault reason as a string
*/
private static String getFaultReasonFromException(Throwable e, MessageContext context) {
Throwable throwable = e;
Parameter param = context.getParameter(
Constants.Configuration.DRILL_DOWN_TO_ROOT_CAUSE_FOR_FAULT_REASON);
boolean drillDownToRootCauseForFaultReason =
param != null && ((String) param.getValue()).equalsIgnoreCase("true");
if (drillDownToRootCauseForFaultReason) {
while (throwable.getCause() != null) {
throwable = throwable.getCause();
}
}
return throwable.getMessage();
}
}