Soap get error

This XML file does not appear to have any style information associated with it. The document tree is shown below.

<wsdl:definitions xmlns:xsd=«http://www.w3.org/2001/XMLSchema» xmlns:wsdl=«http://schemas.xmlsoap.org/wsdl/» xmlns:tns=«http://soap.ws.javastudy.ru/» xmlns:soap=«http://schemas.xmlsoap.org/wsdl/soap/» xmlns:ns1=«http://schemas.xmlsoap.org/soap/http» name=«HelloSoap» targetNamespace=«http://soap.ws.javastudy.ru/»>

<wsdl:types>

<xs:schema xmlns:xs=«http://www.w3.org/2001/XMLSchema» xmlns:tns=«http://soap.ws.javastudy.ru/» attributeFormDefault=«unqualified» elementFormDefault=«unqualified» targetNamespace=«http://soap.ws.javastudy.ru/»>

<xs:element name=«exceptionTest» type=«tns:exceptionTest»/>

<xs:element name=«exceptionTestResponse» type=«tns:exceptionTestResponse»/>

<xs:element name=«getGoods» type=«tns:getGoods»/>

<xs:element name=«getGoodsResponse» type=«tns:getGoodsResponse»/>

<xs:element name=«goods» type=«tns:goods»/>

<xs:element name=«sayHelloTo» type=«tns:sayHelloTo»/>

<xs:element name=«sayHelloToResponse» type=«tns:sayHelloToResponse»/>

<xs:element name=«testService» type=«tns:testService»/>

<xs:element name=«testServiceResponse» type=«tns:testServiceResponse»/>

<xs:complexType name=«testService»>

<xs:sequence/>

</xs:complexType>

<xs:complexType name=«testServiceResponse»>

<xs:sequence>

<xs:element minOccurs=«0» name=«return» type=«xs:string»/>

</xs:sequence>

</xs:complexType>

<xs:complexType name=«getGoods»>

<xs:sequence/>

</xs:complexType>

<xs:complexType name=«getGoodsResponse»>

<xs:sequence>

<xs:element minOccurs=«0» name=«return» type=«tns:goods»/>

</xs:sequence>

</xs:complexType>

<xs:complexType name=«goods»>

<xs:sequence>

<xs:element name=«id» type=«xs:int»/>

<xs:element minOccurs=«0» name=«name» type=«xs:string»/>

</xs:sequence>

</xs:complexType>

<xs:complexType name=«sayHelloTo»>

<xs:sequence>

<xs:element minOccurs=«0» name=«text» type=«xs:string»/>

</xs:sequence>

</xs:complexType>

<xs:complexType name=«sayHelloToResponse»>

<xs:sequence>

<xs:element minOccurs=«0» name=«return» type=«xs:string»/>

</xs:sequence>

</xs:complexType>

<xs:complexType name=«exceptionTest»>

<xs:sequence>

<xs:element minOccurs=«0» name=«text» type=«xs:string»/>

</xs:sequence>

</xs:complexType>

<xs:complexType name=«exceptionTestResponse»>

<xs:sequence/>

</xs:complexType>

<xs:complexType name=«exceptionTrace»>

<xs:sequence>

<xs:element minOccurs=«0» name=«trace» type=«xs:string»/>

</xs:sequence>

</xs:complexType>

<xs:element name=«MyWebserviceException» type=«tns:MyWebserviceException»/>

<xs:complexType name=«MyWebserviceException»>

<xs:sequence>

<xs:element minOccurs=«0» name=«exceptionTrace» type=«tns:exceptionTrace»/>

<xs:element minOccurs=«0» name=«message» type=«xs:string»/>

</xs:sequence>

</xs:complexType>

</xs:schema>

</wsdl:types>

<wsdl:message name=«testService»>

<wsdl:part element=«tns:testService» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:message name=«exceptionTestResponse»>

<wsdl:part element=«tns:exceptionTestResponse» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:message name=«getGoods»>

<wsdl:part element=«tns:getGoods» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:message name=«testServiceResponse»>

<wsdl:part element=«tns:testServiceResponse» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:message name=«sayHelloTo»>

<wsdl:part element=«tns:sayHelloTo» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:message name=«exceptionTest»>

<wsdl:part element=«tns:exceptionTest» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:message name=«getGoodsResponse»>

<wsdl:part element=«tns:getGoodsResponse» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:message name=«MyWebserviceException»>

<wsdl:part element=«tns:MyWebserviceException» name=«MyWebserviceException»></wsdl:part>

</wsdl:message>

<wsdl:message name=«sayHelloToResponse»>

<wsdl:part element=«tns:sayHelloToResponse» name=«parameters»></wsdl:part>

</wsdl:message>

<wsdl:portType name=«WebserviceSEI»>

<wsdl:operation name=«testService»>

<wsdl:input message=«tns:testService» name=«testService»></wsdl:input>

<wsdl:output message=«tns:testServiceResponse» name=«testServiceResponse»></wsdl:output>

</wsdl:operation>

<wsdl:operation name=«getGoods»>

<wsdl:input message=«tns:getGoods» name=«getGoods»></wsdl:input>

<wsdl:output message=«tns:getGoodsResponse» name=«getGoodsResponse»></wsdl:output>

</wsdl:operation>

<wsdl:operation name=«sayHelloTo»>

<wsdl:input message=«tns:sayHelloTo» name=«sayHelloTo»></wsdl:input>

<wsdl:output message=«tns:sayHelloToResponse» name=«sayHelloToResponse»></wsdl:output>

</wsdl:operation>

<wsdl:operation name=«exceptionTest»>

<wsdl:input message=«tns:exceptionTest» name=«exceptionTest»></wsdl:input>

<wsdl:output message=«tns:exceptionTestResponse» name=«exceptionTestResponse»></wsdl:output>

<wsdl:fault message=«tns:MyWebserviceException» name=«MyWebserviceException»></wsdl:fault>

</wsdl:operation>

</wsdl:portType>

<wsdl:binding name=«HelloSoapSoapBinding» type=«tns:WebserviceSEI»>

<soap:binding style=«document» transport=«http://schemas.xmlsoap.org/soap/http»/>

<wsdl:operation name=«testService»>

<soap:operation soapAction=«» style=«document»/>

<wsdl:input name=«testService»>

<soap:body use=«literal»/>

</wsdl:input>

<wsdl:output name=«testServiceResponse»>

<soap:body use=«literal»/>

</wsdl:output>

</wsdl:operation>

<wsdl:operation name=«getGoods»>

<soap:operation soapAction=«» style=«document»/>

<wsdl:input name=«getGoods»>

<soap:body use=«literal»/>

</wsdl:input>

<wsdl:output name=«getGoodsResponse»>

<soap:body use=«literal»/>

</wsdl:output>

</wsdl:operation>

<wsdl:operation name=«sayHelloTo»>

<soap:operation soapAction=«» style=«document»/>

<wsdl:input name=«sayHelloTo»>

<soap:body use=«literal»/>

</wsdl:input>

<wsdl:output name=«sayHelloToResponse»>

<soap:body use=«literal»/>

</wsdl:output>

</wsdl:operation>

<wsdl:operation name=«exceptionTest»>

<soap:operation soapAction=«» style=«document»/>

<wsdl:input name=«exceptionTest»>

<soap:body use=«literal»/>

</wsdl:input>

<wsdl:output name=«exceptionTestResponse»>

<soap:body use=«literal»/>

</wsdl:output>

<wsdl:fault name=«MyWebserviceException»>

<soap:fault name=«MyWebserviceException» use=«literal»/>

</wsdl:fault>

</wsdl:operation>

</wsdl:binding>

<wsdl:service name=«HelloSoap»>

<wsdl:port binding=«tns:HelloSoapSoapBinding» name=«HelloSoapPort»>

<soap:address location=«http://localhost:8080/soap/webserviceSEI»/>

</wsdl:port>

</wsdl:service>

</wsdl:definitions>

If an error occurs during processing, the response to a SOAP message is a SOAP fault element in the body of the message, and the fault is returned to the sender of the SOAP message.

The SOAP fault mechanism returns specific information about the error, including a predefined code, a description, and the address of the SOAP processor that generated the fault.

Points to Note

• A SOAP message can carry only one fault block.

• Fault is an optional part of a SOAP message.

• For HTTP binding, a successful response is linked to the 200 to 299 range of status codes.

• SOAP Fault is linked to the 500 to 599 range of status codes.

Sub-elements of Fault

The SOAP Fault has the following sub elements −

SOAP Fault Codes

The faultCode values defined below must be used in the faultcode element while describing faults.

SOAP Fault Example

The following code is a sample Fault. The client has requested a method named ValidateCreditCard, but the service does not support such a method. This represents a client request error, and the server returns the following SOAP response −

<?xml version = '1.0' encoding = 'UTF-8'?>
<SOAP-ENV:Envelope
   xmlns:SOAP-ENV = "http://schemas.xmlsoap.org/soap/envelope/"
   xmlns:xsi = "http://www.w3.org/1999/XMLSchema-instance"
   xmlns:xsd = "http://www.w3.org/1999/XMLSchema">

   <SOAP-ENV:Body>
      <SOAP-ENV:Fault>
         <faultcode xsi:type = "xsd:string">SOAP-ENV:Client</faultcode>
         <faultstring xsi:type = "xsd:string">
            Failed to locate method (ValidateCreditCard) in class (examplesCreditCard) at
               /usr/local/ActivePerl-5.6/lib/site_perl/5.6.0/SOAP/Lite.pm line 1555.
         </faultstring>
      </SOAP-ENV:Fault>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

SOAP errors are handled using a specialized envelope known as a

Fault Envelope. If an error occurs
while the server processes a SOAP message, it constructs a SOAP Fault
and sends it back to the client. Here’s a typical
SOAP 1.1 Fault:

<?xml version='1.0' encoding='UTF-8'?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:
xsi="http://www.w3.org/1999/XMLSchema-instance" xmlns:xsd="http://www.w3.org/1999/
XMLSchema">

<SOAP-ENV:Body>
    <SOAP-ENV:Fault>
        <faultcode>SOAP-ENV:Server</faultcode>
         <faultstring>Test Fault</faultstring>
         <faultactor>/soap/servlet/rpcrouter</faultactor>
         <detail>
            <stackTrace>[SOAPException: faultCode=SOAP-ENV:Server; msg=Test Fault]
            at StockQuantity.getQty(StockQuantity.java:21)
            at java.lang.reflect.Method.invoke(Native Method)
            at org.apache.soap.server.RPCRouter.invoke(RPCRouter.java:146)
            ...
            at org.apache.tomcat.util.ThreadPool$ControlRunnable.run(
                ThreadPool.java:501)
            at java.lang.Thread.run(Thread.java:498)
         </stackTrace>
         </detail>
     </SOAP-ENV:Fault>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

A SOAP Fault is a special element that must appear as an immediate
child of the SOAP body element. The
<faultcode> and
<faultstring> elements are required. The
<faultactor> and
<detail> elements are optional. Table 4-1 lists the possible values for the faultcodes
and their meanings.

The body and Fault elements are namespace-qualified to the
envelope’s namespace—for example,
<SOAP-ENV:body> and
<SOAP-ENV:Fault>. The
<faultcode> element uses the local namespace
(it has no namespace prefix), and the
<faultcode> value that the element contains
is a qualified name using the envelope’s
namespace—for example,
<faultcode>SOAP-ENV:Client</faultcode>.

The SOAP Fault from the previous listing was achieved by making a
slight modification to the StockQuantity service.
In Apache SOAP, having the service throw
an exception is all that’s needed to generate a
fault; Apache takes care of the rest:

public class StockQuantity{

  public int getQty (String item) 
    throws org.apache.soap.SOAPException {

    int inStockQty = (int)(java.lang.Math.random(  ) * (double)1000);
    
    if (item.equalsIgnoreCase("Fail"))
        throw new org.apache.soap.SOAPException   
                      (org.apache.soap.Constants.FAULT_CODE_SERVER, 
                                "Test Fault");    

    return inStockQty;
   }
...
}

In Apache SOAP 2.2, this code is all that is necessary to send a
complete SOAP 1.1 Fault message back to the sender. To view the full
output of the Fault message, redirect the
CheckStock RPC call through the TunnelGui utility
by using the command:

java CheckStock -url http://localhost:5555/soap/servlet/rpcrouter -item Fail

In this command, 5555 is the port on which the
TunnelGui is listening. The RPC request and the corresponding SOAP
Fault can be viewed in the TunnelGui window, as shown in Figure 4-1.

The sending client can trap the Fault programatically and take
appropriate action. Apache
SOAP has a Fault object that can be used to access
the pieces of the Fault message, as indicated in this excerpt from
CheckStock:

    //Invoke the service
    Response resp = call.invoke (url,"urn:go-do-this");

    //Check the response
    if (resp != null) {
        if (resp.generatedFault (  )) {
                        Fault fault = resp.getFault (  );
            System.out.println ("Call failed due to a SOAP Fault: ");
            System.out.println ("  Fault Code   = " + fault.getFaultCode (  ));
            System.out.println ("  Fault String = " + fault.getFaultString (  ));

While the ability to generate a fault by throwing an exception is
handy, you may want more control over what goes into a fault message.
For example, Apache SOAP, by default, puts the current stacktrace
into the <detail> element of the SOAP fault.
That may not be what you want. We will explore how to build your own
Fault message in the context of the mustUnderstand
attribute.

            // Create a header element in a namespace
            org.w3c.dom.Element headerElement =
                doc.createElementNS(URI,"jaws:MessageHeader");
            headerElement.setAttributeNS(URI,"SOAP-ENV:mustUnderstand","1");

            // Create subnodes within the MessageHeader
            org.w3c.dom.Element ele = doc.createElement("From");
            org.w3c.dom.Text textNode = doc.createTextNode("Me");

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" 
    xmlns:xsi="http://www.w3.org/1999/XMLSchema-instance" 
    xmlns:xsd="http://www.w3.org/1999/XMLSchema">
<SOAP-ENV:Header>
    <jaws:MessageHeader xmlns:jaws="urn:http://oreilly/jaws/samples"
        SOAP-ENV:MustUnderstand="1" >
        <From>Me</From>
        <To>You</To>
        <MessageId>9999</MessageId>
        ...
    </jaws:MessageHeader>
</SOAP-ENV:Header>
<SOAP-ENV:Body>
...
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

<?xml version='1.0' encoding='UTF-8'?>

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:
xsi="http://www.w3.org/1999/XMLSchema-instance" xmlns:xsd="http://www.w3.org/1999/
XMLSchema">
    <SOAP-ENV:Body>
         <SOAP-ENV:Fault>
         <faultcode>SOAP-ENV:MustUnderstand</faultcode>
         <faultstring>Unsupported header: jaws:MessageHeader</faultstring>
         <faultactor>/examples/servlet/FaultServlet</faultactor>
         </SOAP-ENV:Fault>
     </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

public class FaultServlet extends HttpServlet
{
...

    public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws IOException, ServletException
    {
    ...
           // Get the header and check it for mustunderstand
           Header header = env.getHeader(  );
           java.util.Vector headerEntries = header.getHeaderEntries(  );
                    
           screenWriter.write("nHeader==>n");
           for (java.util.Enumeration e = headerEntries.elements(  ); 
                            e.hasMoreElements(  );)
           {
               org.w3c.dom.Element el = (org.w3c.dom.Element)e.nextElement(  );
               org.apache.soap.util.xml.DOM2Writer.serializeAsXML(
                 (org.w3c.dom.Node)el, screenWriter);
                        
            // process mustUnderstand
               String mustUnderstand=
                        el.getAttributeNS(Constants.NS_URI_SOAP_ENV, 
                          "mustUnderstand");                  
               screenWriter.write("nMustUnderstand: " 
                + mustUnderstand + "n");

               String tagName = el.getTagName(  );    
               screenWriter.write("Tag Name: " + tagName + "n");

                  if(!tagName.equalsIgnoreCase("IOnlyUnderstandThis"))
                  {
                      //generate a fault.
                      screenWriter.write("Unsupported header: " + tagName + "n");
                      screenWriter.write("Generating Fault....n");
                      SOAPException se = 
                      new SOAPException(Constants.FAULT_CODE_MUST_UNDERSTAND, 
                               "Unsupported header: " + tagName);
                      Fault fault = new Fault(se);
                      fault.setFaultActorURI (request.getRequestURI (  ));
                            
                      String respEncStyle = Constants.NS_URI_SOAP_ENC;

                      org.apache.soap.rpc.Response soapResponse = 
                      new org.apache.soap.rpc.Response (
                                 null,         // targetObjectURI
                                 null,         // methodName
                                 fault,
                                 null,         // params
                                 null,         // headers
                                 respEncStyle, // encodingStyleURI
                                 null);        // SOAPContext

                      Envelope faultEnvelope = soapResponse.buildEnvelope(  );  

                      org.apache.soap.encoding.SOAPMappingRegistry smr 
                           = new org.apache.soap.encoding.SOAPMappingRegistry(  );

                      PrintWriter resW = response.getWriter(  );

                      faultEnvelope.marshall(resW, smr,   
                          soapResponse.getSOAPContext(  ));
                      response.setContentType(request.getContentType(  )); 
                      response.setStatus(response.SC_INTERNAL_SERVER_ERROR);
                      ...
                      }
                  }

<env:Envelope xmlns:env='http://www.w3.org/2001/09/soap-envelope'
         xmlns:f='http://www.w3.org/2001/09/soap-faults' >
    <env:Header>
        <f:misunderstood qname="jaws:MessageHeader"
            xmlns:jaws="urn:http://oreilly/jaws/samples" />
       </env:Header>
    <env:Body>
        <env:Fault>
                   <faultcode>env:mustUnderstand</faultcode>
                   <faultstring>
                One or more mandatory headers not understood
            </faultstring>
           </env:Fault>
    </env:Body>
</env:Envelope>

rpc:ProcedureNotPresent

rpc:BadArguments

env:DataEncodingUnknown

Introduction

If you are working on integration development for Cloud Platform Integration (CPI), you have probably already used the SOAP receiver adapter with the request-reply pattern.

As long as everything works fine on the receiver side, it works fine on the CPI side, I get the SOAP response and can work with it. But in case of server errors, I noticed an undesirable behavior. SOAP Faults or error messages were not accessible for me, in the error subprocesses. The message body was simply empty, after the request-reply step.

Context

In my case, I have set up a web service call to a SOAP endpoint from SAP Process Orchestration (PO). The endpoint is configured to send an error message with details to the sender when an error occurs.

To accomplish this on SAP PO site, follow this SAP Note 2293430 – Processing error response at sender SOAP adapter – SAP ONE Support Launchpad

In the CPI I want to process these error details and display them to the responsible user. This did not work out of the box, the message text was always just empty after the error occurred.

First Attempts

The only thing I got was a generic message “Server Error” from the exchange object with the ${exception.message} operation.

Next I’ve tried a script for http error response extraction from ${property.CamelExceptionCaught} , mentioned on this help site:
Script Example for Exception Handling in HTTP Receiver – SAP Help Portal
But this script works only with HTTP exceptions, like

org.apache.camel.component.ahc.AhcOperationFailedException

It doesn’t work because we captured another object in this property during runtime. It is not AhcOperationFailedException, but an object of SoapFault class.

Adjusted Solution

I’ve stickend to the solution with a script and tried to adjust it to SOAP Fault objects.

——————————————————————–

org.apache.cxf.binding.soap

Class SoapFault extends Fault

ref.: SoapFault (Apache CXF JavaDoc 3.2.0 API)

——————————————————————–

Those both functions provide an org.w3c.dom.Element, which is (unfortunately) not parsable by the CPI. You can set this Element as a new body and you will see the message body during trace. But operations (like XPath, Content Modifier) won’t work on your new message body. You will receive an error message like:

org.apache.camel.NoTypeConversionAvailableException: 
No type converter available to convert from type: com.sun.org.apache.xerces.internal.dom.ElementNSImpl 
to the required type: javax.xml.transform.sax.SAXSource

Serializing the org.w3c.dom.Element object to a simple String and set it as the message body, works great for the CPI.

import com.sap.gateway.ip.core.customdev.util.Message;
import java.util.HashMap;
import org.w3c.dom.Node;
import groovy.xml.*

def Message processData(Message message) {
    def map = message.getProperties();
    def ex = map.get("CamelExceptionCaught");
    if (ex.getClass().getCanonicalName().equals("org.apache.cxf.binding.soap.SoapFault")) {
        def xml = XmlUtil.serialize(ex.getOrCreateDetail());
        message.setBody(xml);
    }
    
    return message;
}

– Improvements by Thomas Buerki 

Conclusion

This script gives me the ability to process the SOAP fault response with the usual XPath operations and even mappings. I can now distinguish between nodes and evaluate them individually.

I hope this script helps someone who is struggling with the same problem.

I am open for improvements, opinions and questions.

Cheers

Dennis Sentler