| /* |
| * 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.saaj; |
| |
| import org.apache.axiom.attachments.Attachments; |
| import org.apache.axiom.attachments.ConfigurableDataHandler; |
| import org.apache.axiom.om.OMAttribute; |
| import org.apache.axiom.om.OMElement; |
| import org.apache.axiom.om.OMNode; |
| import org.apache.axiom.om.OMText; |
| import org.apache.axiom.om.impl.MTOMConstants; |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.Constants; |
| import org.apache.axis2.addressing.EndpointReference; |
| import org.apache.axis2.client.OperationClient; |
| import org.apache.axis2.client.Options; |
| import org.apache.axis2.client.ServiceClient; |
| import org.apache.axis2.context.ConfigurationContext; |
| import org.apache.axis2.context.ConfigurationContextFactory; |
| import org.apache.axis2.context.MessageContext; |
| import org.apache.axis2.engine.AxisConfiguration; |
| import org.apache.axis2.engine.DispatchPhase; |
| import org.apache.axis2.engine.Phase; |
| import org.apache.axis2.saaj.util.IDGenerator; |
| import org.apache.axis2.saaj.util.SAAJUtil; |
| import org.apache.axis2.saaj.util.UnderstandAllHeadersHandler; |
| import org.apache.axis2.transport.http.HTTPConstants; |
| import org.apache.axis2.wsdl.WSDLConstants; |
| |
| import javax.activation.DataHandler; |
| import javax.xml.namespace.QName; |
| import javax.xml.soap.AttachmentPart; |
| import javax.xml.soap.MessageFactory; |
| import javax.xml.soap.MimeHeader; |
| import javax.xml.soap.MimeHeaders; |
| import javax.xml.soap.SOAPBody; |
| import javax.xml.soap.SOAPConnection; |
| import javax.xml.soap.SOAPElement; |
| import javax.xml.soap.SOAPException; |
| import javax.xml.soap.SOAPHeader; |
| import javax.xml.soap.SOAPHeaderElement; |
| import javax.xml.soap.SOAPMessage; |
| import javax.xml.soap.SOAPPart; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.HttpURLConnection; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.StringTokenizer; |
| |
| |
| /** |
| * |
| */ |
| public class SOAPConnectionImpl extends SOAPConnection { |
| |
| /** Attribute which keeps track of whether this connection has been closed */ |
| private boolean closed = false; |
| |
| private final ConfigurationContext configurationContext; |
| |
| SOAPConnectionImpl() throws SOAPException { |
| // Create a new ConfigurationContext that will be used by all ServiceClient instances. |
| // There are two reasons why this is necessary: |
| // * Starting with r921685, if no ConfigurationContext is supplied to the ServiceClient, |
| // it will create a new one (unless it can locate one using MessageContext.getCurrentMessageContext(), |
| // but this is not the most common use case for SOAPConnection). This means that |
| // SOAPConnection#call would create a new ConfigurationContext every time, and this is |
| // too expensive. |
| // * We need to disable mustUnderstand processing. However, we can't do that on an AxisConfiguration |
| // that is shared with other components, because this would lead to unpredictable results. |
| // Note that we could also use a single ServiceClient instance, but then the SOAPConnection |
| // implementation would no longer be thread safe. Although thread safety is not explicitly required |
| // by the SAAJ specs, it appears that the SOAPConnection in Sun's reference implementation is |
| // thread safe. |
| try { |
| configurationContext = ConfigurationContextFactory.createConfigurationContextFromFileSystem(null, null); |
| disableMustUnderstandProcessing(configurationContext.getAxisConfiguration()); |
| } catch (AxisFault ex) { |
| throw new SOAPException(ex); |
| } |
| } |
| |
| /** |
| * Sends the given message to the specified endpoint and blocks until it has returned the |
| * response. |
| * |
| * @param request the <CODE>SOAPMessage</CODE> object to be sent |
| * @param endpoint an <code>Object</code> that identifies where the message should be sent. It |
| * is required to support Objects of type <code>java.lang.String</code>, |
| * <code>java.net.URL</code>, and when JAXM is present <code>javax.xml.messaging.URLEndpoint</code> |
| * @return the <CODE>SOAPMessage</CODE> object that is the response to the message that was |
| * sent |
| * @throws javax.xml.soap.SOAPException if there is a SOAP error, or this SOAPConnection is |
| * already closed |
| */ |
| public SOAPMessage call(SOAPMessage request, Object endpoint) throws SOAPException { |
| if (closed) { |
| throw new SOAPException("SOAPConnection closed"); |
| } |
| |
| // initialize URL |
| URL url; |
| try { |
| url = (endpoint instanceof URL) ? (URL)endpoint : new URL(endpoint.toString()); |
| } catch (MalformedURLException e) { |
| throw new SOAPException(e.getMessage()); |
| } |
| |
| // initialize and set Options |
| Options options = new Options(); |
| options.setTo(new EndpointReference(url.toString())); |
| |
| // initialize the Sender |
| ServiceClient serviceClient; |
| OperationClient opClient; |
| try { |
| serviceClient = new ServiceClient(configurationContext, null); |
| opClient = serviceClient.createClient(ServiceClient.ANON_OUT_IN_OP); |
| } catch (AxisFault e) { |
| throw new SOAPException(e); |
| } |
| |
| options.setProperty(Constants.Configuration.CHARACTER_SET_ENCODING, |
| request.getProperty(SOAPMessage.CHARACTER_SET_ENCODING)); |
| |
| opClient.setOptions(options); |
| |
| MessageContext requestMsgCtx = new MessageContext(); |
| org.apache.axiom.soap.SOAPEnvelope envelope; |
| if (isMTOM(request)) { |
| envelope = SAAJUtil.toOMSOAPEnvelope(request); |
| options.setProperty(Constants.Configuration.ENABLE_MTOM, Constants.VALUE_TRUE); |
| } else { |
| envelope = SAAJUtil.toOMSOAPEnvelope(request.getSOAPPart().getDocumentElement()); |
| if (request.countAttachments() != 0) { // SOAPMessage with attachments |
| Attachments attachments = requestMsgCtx.getAttachmentMap(); |
| for (Iterator it = request.getAttachments(); it.hasNext(); ) { |
| AttachmentPart attachment = (AttachmentPart)it.next(); |
| String contentId = attachment.getContentId(); |
| // Axiom currently doesn't support attachments without Content-ID |
| // (see WSCOMMONS-418); generate one if necessary. |
| if (contentId == null) { |
| contentId = IDGenerator.generateID(); |
| } |
| DataHandler handler = attachment.getDataHandler(); |
| // make sure that AttachmentPart content-type overrides DataHandler content-type |
| if (!SAAJUtil.compareContentTypes(attachment.getContentType(), handler.getContentType())) { |
| ConfigurableDataHandler configuredHandler = new ConfigurableDataHandler(handler.getDataSource()); |
| configuredHandler.setContentType(attachment.getContentType()); |
| handler = configuredHandler; |
| } |
| attachments.addDataHandler(contentId, handler); |
| } |
| options.setProperty(Constants.Configuration.ENABLE_SWA, Constants.VALUE_TRUE); |
| } |
| } |
| |
| Map<String,String> httpHeaders = null; |
| for (Iterator it = request.getMimeHeaders().getAllHeaders(); it.hasNext(); ) { |
| MimeHeader header = (MimeHeader)it.next(); |
| String name = header.getName().toLowerCase(); |
| if (name.equals("soapaction")) { |
| requestMsgCtx.setSoapAction(header.getValue()); |
| } else if (name.equals("content-type")) { |
| // Don't set the Content-Type explicitly since it will be computed by the |
| // message builder. |
| } else { |
| if (httpHeaders == null) { |
| httpHeaders = new HashMap<String,String>(); |
| } |
| httpHeaders.put(header.getName(), header.getValue()); |
| } |
| } |
| if (httpHeaders != null) { |
| requestMsgCtx.setProperty(HTTPConstants.HTTP_HEADERS, httpHeaders); |
| } |
| |
| try { |
| MessageContext responseMsgCtx; |
| try { |
| requestMsgCtx.setEnvelope(envelope); |
| opClient.addMessageContext(requestMsgCtx); |
| opClient.execute(true); |
| responseMsgCtx = |
| opClient.getMessageContext(WSDLConstants.MESSAGE_LABEL_IN_VALUE); |
| } catch (AxisFault ex) { |
| throw new SOAPException(ex.getMessage(), ex); |
| } |
| |
| SOAPMessage response = getSOAPMessage(responseMsgCtx.getEnvelope()); |
| Attachments attachments = responseMsgCtx.getAttachmentMap(); |
| for (String contentId : attachments.getAllContentIDs()) { |
| if (!contentId.equals(attachments.getRootPartContentID())) { |
| AttachmentPart ap = response.createAttachmentPart( |
| attachments.getDataHandler(contentId)); |
| ap.setContentId(contentId); |
| response.addAttachmentPart(ap); |
| } |
| } |
| |
| return response; |
| } finally { |
| try { |
| serviceClient.cleanupTransport(); |
| serviceClient.cleanup(); |
| } catch (AxisFault ex) { |
| throw new SOAPException(ex); |
| } |
| } |
| } |
| |
| private static boolean isMTOM(SOAPMessage soapMessage) { |
| SOAPPart soapPart = soapMessage.getSOAPPart(); |
| String[] contentTypes = soapPart.getMimeHeader("Content-Type"); |
| if (contentTypes != null && contentTypes.length > 0) { |
| return SAAJUtil.normalizeContentType(contentTypes[0]).equals("application/xop+xml"); |
| } else { |
| return false; |
| } |
| } |
| |
| /* |
| * Installs UnderstandAllHeadersHandler that marks all headers as processed |
| * because MU validation should not be done for SAAJ clients. |
| */ |
| private void disableMustUnderstandProcessing(AxisConfiguration config) { |
| DispatchPhase phase; |
| phase = getDispatchPhase(config.getInFlowPhases()); |
| if (phase != null) { |
| phase.addHandler(new UnderstandAllHeadersHandler()); |
| } |
| phase = getDispatchPhase(config.getInFaultFlowPhases()); |
| if (phase != null) { |
| phase.addHandler(new UnderstandAllHeadersHandler()); |
| } |
| } |
| |
| private static DispatchPhase getDispatchPhase(List<Phase> phases) { |
| for (Phase phase : phases) { |
| if (phase instanceof DispatchPhase) { |
| return (DispatchPhase)phase; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Closes this <CODE>SOAPConnection</CODE> object. |
| * |
| * @throws javax.xml.soap.SOAPException if there is a SOAP error, or this SOAPConnection is |
| * already closed |
| */ |
| public void close() throws SOAPException { |
| if (closed) { |
| throw new SOAPException("SOAPConnection Closed"); |
| } |
| try { |
| configurationContext.terminate(); |
| } catch (AxisFault axisFault) { |
| throw new SOAPException(axisFault.getMessage()); |
| } |
| closed = true; |
| } |
| |
| /** |
| * This method handles the conversion of an OM SOAP Envelope to a SAAJ SOAPMessage |
| * |
| * @param respOMSoapEnv |
| * @return the SAAJ SOAPMessage |
| * @throws SOAPException If an exception occurs during this conversion |
| */ |
| private SOAPMessage getSOAPMessage(org.apache.axiom.soap.SOAPEnvelope respOMSoapEnv) |
| throws SOAPException { |
| |
| // Create the basic SOAP Message |
| MessageFactory mf = MessageFactory.newInstance(); |
| SOAPMessage response = mf.createMessage(); |
| SOAPPart sPart = response.getSOAPPart(); |
| javax.xml.soap.SOAPEnvelope env = sPart.getEnvelope(); |
| SOAPBody body = env.getBody(); |
| SOAPHeader header = env.getHeader(); |
| |
| // Convert all header blocks |
| org.apache.axiom.soap.SOAPHeader header2 = respOMSoapEnv.getHeader(); |
| if (header2 != null) { |
| for (Iterator hbIter = header2.examineAllHeaderBlocks(); hbIter.hasNext();) { |
| // Converting a single OM SOAP HeaderBlock to a SAAJ SOAP |
| // HeaderBlock |
| org.apache.axiom.soap.SOAPHeaderBlock hb = (org.apache.axiom.soap.SOAPHeaderBlock) |
| hbIter.next(); |
| final QName hbQName = hb.getQName(); |
| final SOAPHeaderElement headerEle = header.addHeaderElement(env.createName(hbQName |
| .getLocalPart(), hbQName.getPrefix(), hbQName.getNamespaceURI())); |
| for (Iterator attribIter = hb.getAllAttributes(); attribIter.hasNext();) { |
| OMAttribute attr = (OMAttribute)attribIter.next(); |
| final QName attrQName = attr.getQName(); |
| headerEle.addAttribute(env.createName(attrQName.getLocalPart(), attrQName |
| .getPrefix(), attrQName.getNamespaceURI()), attr.getAttributeValue()); |
| } |
| final String role = hb.getRole(); |
| if (role != null) { |
| headerEle.setActor(role); |
| } |
| headerEle.setMustUnderstand(hb.getMustUnderstand()); |
| |
| toSAAJElement(headerEle, hb, response); |
| } |
| } |
| |
| // Convert the body |
| toSAAJElement(body, respOMSoapEnv.getBody(), response); |
| |
| return response; |
| } |
| |
| /** |
| * Converts an OMNode into a SAAJ SOAPElement |
| * |
| * @param saajEle |
| * @param omNode |
| * @param saajSOAPMsg |
| * @throws SOAPException If conversion fails |
| */ |
| private void toSAAJElement(SOAPElement saajEle, |
| OMNode omNode, |
| javax.xml.soap.SOAPMessage saajSOAPMsg) throws SOAPException { |
| |
| if (omNode instanceof OMText) { |
| return; // simply return since the text has already been added to saajEle |
| } |
| |
| if (omNode instanceof OMElement) { |
| OMElement omEle = (OMElement)omNode; |
| for (Iterator childIter = omEle.getChildren(); childIter.hasNext();) { |
| OMNode omChildNode = (OMNode)childIter.next(); |
| SOAPElement saajChildEle = null; |
| |
| if (omChildNode instanceof OMText) { |
| // check whether the omtext refers to an attachment |
| |
| final OMText omText = (OMText)omChildNode; |
| if (omText.isOptimized()) { // is this an attachment? |
| final DataHandler datahandler = (DataHandler)omText.getDataHandler(); |
| AttachmentPart attachment = saajSOAPMsg.createAttachmentPart(datahandler); |
| final String id = IDGenerator.generateID(); |
| attachment.setContentId("<" + id + ">"); |
| attachment.setContentType(datahandler.getContentType()); |
| saajSOAPMsg.addAttachmentPart(attachment); |
| |
| SOAPElement xopInclude = saajEle.addChildElement(MTOMConstants.XOP_INCLUDE, |
| "xop", MTOMConstants.XOP_NAMESPACE_URI); |
| xopInclude.addAttribute( |
| saajSOAPMsg.getSOAPPart().getEnvelope().createName("href"), |
| "cid:" + id); |
| } else { |
| saajChildEle = saajEle.addTextNode(omText.getText()); |
| } |
| } else if (omChildNode instanceof OMElement) { |
| OMElement omChildEle = (OMElement)omChildNode; |
| final QName omChildQName = omChildEle.getQName(); |
| saajChildEle = |
| saajEle.addChildElement(omChildQName.getLocalPart(), |
| omChildQName.getPrefix(), |
| omChildQName.getNamespaceURI()); |
| for (Iterator attribIter = omChildEle.getAllAttributes(); |
| attribIter.hasNext();) { |
| OMAttribute attr = (OMAttribute)attribIter.next(); |
| final QName attrQName = attr.getQName(); |
| saajChildEle.addAttribute(saajSOAPMsg.getSOAPPart().getEnvelope(). |
| createName(attrQName.getLocalPart(), |
| attrQName.getPrefix(), |
| attrQName.getNamespaceURI()), |
| attr.getAttributeValue()); |
| } |
| } |
| |
| // go down the tree adding child elements, till u reach a leaf(i.e. text element) |
| toSAAJElement(saajChildEle, omChildNode, saajSOAPMsg); |
| } |
| } |
| } |
| |
| /** overrided SOAPConnection's get() method */ |
| |
| public SOAPMessage get(Object to) throws SOAPException { |
| URL url = null; |
| try { |
| url = (to instanceof URL) ? (URL)to : new URL(to.toString()); |
| } catch (MalformedURLException e) { |
| throw new SOAPException(e); |
| } |
| |
| int responseCode; |
| boolean isFailure = false; |
| HttpURLConnection httpCon = null; |
| try { |
| httpCon = (HttpURLConnection)url.openConnection(); |
| httpCon.setDoOutput(true); |
| httpCon.setDoInput(true); |
| httpCon.setUseCaches(false); |
| httpCon.setRequestMethod("GET"); |
| HttpURLConnection.setFollowRedirects(true); |
| |
| httpCon.connect(); |
| responseCode = httpCon.getResponseCode(); |
| // 500 is allowed for SOAP faults |
| if (responseCode == HttpURLConnection.HTTP_INTERNAL_ERROR) { |
| isFailure = true; |
| } else if ((responseCode / 100) != 2) { |
| throw new SOAPException("Error response: (" + responseCode |
| + httpCon.getResponseMessage()); |
| } |
| } catch (IOException e) { |
| throw new SOAPException(e); |
| } |
| |
| //Construct the soapmessage from http response |
| SOAPMessage soapMessage = null; |
| if (responseCode == HttpURLConnection.HTTP_OK) { |
| try { |
| //read http headers & load mimeheaders |
| MimeHeaders mimeHeaders = new MimeHeaders(); |
| String key, value; |
| // skip status line |
| int i = 1; |
| while (true) { |
| key = httpCon.getHeaderFieldKey(i); |
| value = httpCon.getHeaderField(i); |
| if (key == null && value == null) { |
| break; |
| } |
| |
| if (key != null) { |
| StringTokenizer values = new StringTokenizer(value, ","); |
| while (values.hasMoreTokens()) { |
| mimeHeaders.addHeader(key, values.nextToken().trim()); |
| } |
| } |
| i++; |
| } |
| InputStream httpInputStream; |
| if (isFailure) { |
| httpInputStream = httpCon.getErrorStream(); |
| } else { |
| httpInputStream = httpCon.getInputStream(); |
| } |
| |
| soapMessage = new SOAPMessageImpl(httpInputStream, mimeHeaders, false); |
| httpInputStream.close(); |
| httpCon.disconnect(); |
| |
| } catch (SOAPException e) { |
| throw e; |
| } catch (Exception e) { |
| throw new SOAPException(e.getMessage()); |
| } |
| } |
| return soapMessage; |
| } |
| |
| } |
