| /* |
| * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.xml.internal.ws.api.message; |
| |
| import com.oracle.webservices.internal.api.message.ContentType; |
| import com.oracle.webservices.internal.api.message.PropertySet; |
| import com.sun.istack.internal.NotNull; |
| import com.sun.istack.internal.Nullable; |
| import com.sun.xml.internal.bind.marshaller.SAX2DOMEx; |
| import com.sun.xml.internal.ws.addressing.WsaPropertyBag; |
| import com.sun.xml.internal.ws.addressing.WsaServerTube; |
| import com.sun.xml.internal.ws.addressing.WsaTubeHelper; |
| import com.sun.xml.internal.ws.api.Component; |
| import com.sun.xml.internal.ws.api.EndpointAddress; |
| import com.sun.xml.internal.ws.api.SOAPVersion; |
| import com.sun.xml.internal.ws.api.WSBinding; |
| import com.sun.xml.internal.ws.api.addressing.AddressingVersion; |
| import com.sun.xml.internal.ws.api.addressing.WSEndpointReference; |
| import com.sun.xml.internal.ws.api.model.JavaMethod; |
| import com.sun.xml.internal.ws.api.model.SEIModel; |
| import com.sun.xml.internal.ws.api.model.WSDLOperationMapping; |
| import com.sun.xml.internal.ws.api.model.wsdl.WSDLOperation; |
| import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort; |
| import com.sun.xml.internal.ws.api.pipe.Codec; |
| import com.sun.xml.internal.ws.api.pipe.Tube; |
| import com.sun.xml.internal.ws.api.server.Adapter; |
| import com.sun.xml.internal.ws.api.server.TransportBackChannel; |
| import com.sun.xml.internal.ws.api.server.WSEndpoint; |
| import com.sun.xml.internal.ws.api.server.WebServiceContextDelegate; |
| import com.sun.xml.internal.ws.api.streaming.XMLStreamWriterFactory; |
| import com.sun.xml.internal.ws.client.*; |
| import com.sun.xml.internal.ws.developer.JAXWSProperties; |
| import com.sun.xml.internal.ws.encoding.MtomCodec; |
| import com.sun.xml.internal.ws.message.RelatesToHeader; |
| import com.sun.xml.internal.ws.message.StringHeader; |
| import com.sun.xml.internal.ws.util.DOMUtil; |
| import com.sun.xml.internal.ws.util.xml.XmlUtil; |
| import com.sun.xml.internal.ws.wsdl.DispatchException; |
| import com.sun.xml.internal.ws.wsdl.OperationDispatcher; |
| import com.sun.xml.internal.ws.resources.AddressingMessages; |
| |
| |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.xml.sax.SAXException; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.soap.SOAPException; |
| import javax.xml.soap.SOAPMessage; |
| import javax.xml.stream.XMLStreamWriter; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.ws.BindingProvider; |
| import javax.xml.ws.Dispatch; |
| import javax.xml.ws.WebServiceContext; |
| import javax.xml.ws.WebServiceException; |
| import javax.xml.ws.handler.LogicalMessageContext; |
| import javax.xml.ws.handler.MessageContext; |
| import javax.xml.ws.handler.soap.SOAPMessageContext; |
| import javax.xml.ws.soap.MTOMFeature; |
| |
| import java.util.*; |
| import java.util.logging.Logger; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.nio.channels.WritableByteChannel; |
| |
| /** |
| * Represents a container of a {@link Message}. |
| * |
| * <h2>What is a {@link Packet}?</h2> |
| * <p> |
| * A packet can be thought of as a frame/envelope/package that wraps |
| * a {@link Message}. A packet keeps track of optional metadata (properties) |
| * about a {@link Message} that doesn't go across the wire. |
| * This roughly corresponds to {@link MessageContext} in the JAX-WS API. |
| * |
| * <p> |
| * Usually a packet contains a {@link Message} in it, but sometimes |
| * (such as for a reply of an one-way operation), a packet may |
| * float around without a {@link Message} in it. |
| * |
| * |
| * <a name="properties"></a> |
| * <h2>Properties</h2> |
| * <p> |
| * Information frequently used inside the JAX-WS RI |
| * is stored in the strongly-typed fields. Other information is stored |
| * in terms of a generic {@link Map} (see |
| * {@link #invocationProperties}.) |
| * |
| * <p> |
| * Some properties need to be retained between request and response, |
| * some don't. For strongly typed fields, this characteristic is |
| * statically known for each of them, and propagation happens accordingly. |
| * For generic information stored in {@link Map}, {@link #invocationProperties} |
| * stores per-invocation scope information (which carries over to |
| * the response.) |
| * |
| * <p> |
| * This object is used as the backing store of {@link MessageContext}, and |
| * {@link LogicalMessageContext} and {@link SOAPMessageContext} will |
| * be delegating to this object for storing/retrieving values. |
| * |
| * |
| * <h3>Relationship to request/response context</h3> |
| * <p> |
| * {@link BindingProvider#getRequestContext() Request context} is used to |
| * seed the initial values of {@link Packet}. |
| * Some of those values go to strongly-typed fields, and others go to |
| * {@link #invocationProperties}, as they need to be retained in the reply message. |
| * |
| * <p> |
| * Similarly, {@link BindingProvider#getResponseContext() response context} |
| * is constructed from {@link Packet} (or rather it's just a view of {@link Packet}.) |
| * by using properties from {@link #invocationProperties}, |
| * modulo properties named explicitly in {@link #getHandlerScopePropertyNames(boolean)}. |
| * IOW, properties added to {@link #invocationProperties} |
| * are exposed to the response context by default. |
| * |
| * |
| * |
| * <h3>TODO</h3> |
| * <ol> |
| * <li>this class needs to be cloneable since Message is copiable. |
| * <li>The three live views aren't implemented correctly. It will be |
| * more work to do so, although I'm sure it's possible. |
| * <li>{@link PropertySet.Property} annotation is to make it easy |
| * for {@link MessageContext} to export properties on this object, |
| * but it probably needs some clean up. |
| * </ol> |
| * |
| * @author Kohsuke Kawaguchi |
| */ |
| public final class Packet |
| // Packet must continue to extend/implement deprecated interfaces until downstream |
| // usage is updated. |
| extends com.oracle.webservices.internal.api.message.BaseDistributedPropertySet |
| implements com.oracle.webservices.internal.api.message.MessageContext, MessageMetadata { |
| |
| /** |
| * Creates a {@link Packet} that wraps a given {@link Message}. |
| * |
| * <p> |
| * This method should be only used to create a fresh {@link Packet}. |
| * To create a {@link Packet} for a reply, use {@link #createResponse(Message)}. |
| * |
| * @param request |
| * The request {@link Message}. Can be null. |
| */ |
| public Packet(Message request) { |
| this(); |
| this.message = request; |
| if (message != null) message.setMessageMedadata(this); |
| } |
| |
| /** |
| * Creates an empty {@link Packet} that doesn't have any {@link Message}. |
| */ |
| public Packet() { |
| this.invocationProperties = new HashMap<String, Object>(); |
| } |
| |
| /** |
| * Used by {@link #createResponse(Message)} and {@link #copy(boolean)}. |
| */ |
| private Packet(Packet that) { |
| relatePackets(that, true); |
| this.invocationProperties = that.invocationProperties; |
| } |
| |
| /** |
| * Creates a copy of this {@link Packet}. |
| * |
| * @param copyMessage determines whether the {@link Message} from the original {@link Packet} should be copied as |
| * well, or not. If the value is {@code false}, the {@link Message} in the copy of the {@link Packet} is {@code null}. |
| * @return copy of the original packet |
| */ |
| public Packet copy(boolean copyMessage) { |
| // the copy constructor is originally designed for creating a response packet, |
| // but so far the implementation is usable for this purpose as well, so calling the copy constructor |
| // to avoid code dupliation. |
| Packet copy = new Packet(this); |
| if (copyMessage && this.message != null) { |
| copy.message = this.message.copy(); |
| } |
| if (copy.message != null) copy.message.setMessageMedadata(copy); |
| return copy; |
| } |
| |
| private Message message; |
| |
| /** |
| * Gets the last {@link Message} set through {@link #setMessage(Message)}. |
| * |
| * @return may null. See the class javadoc for when it's null. |
| */ |
| public Message getMessage() { |
| if (message != null && !(message instanceof MessageWrapper)) { |
| message = new MessageWrapper(this, message); |
| } |
| return message; |
| } |
| |
| public Message getInternalMessage() { |
| return (message instanceof MessageWrapper)? ((MessageWrapper)message).delegate : message; |
| } |
| |
| public WSBinding getBinding() { |
| if (endpoint != null) { |
| return endpoint.getBinding(); |
| } |
| if (proxy != null) { |
| return (WSBinding) proxy.getBinding(); |
| } |
| return null; |
| } |
| /** |
| * Sets a {@link Message} to this packet. |
| * |
| * @param message Can be null. |
| */ |
| public void setMessage(Message message) { |
| this.message = message; |
| if (message != null) this.message.setMessageMedadata(this); |
| } |
| |
| private WSDLOperationMapping wsdlOperationMapping = null; |
| |
| private QName wsdlOperation; |
| |
| /** |
| * Returns the QName of the wsdl operation associated with this packet. |
| * <p/> |
| * Information such as Payload QName, wsa:Action header, SOAPAction HTTP header are used depending on the features |
| * enabled on the particular port. |
| * |
| * @return null if there is no WSDL model or |
| * runtime cannot uniquely identify the wsdl operation from the information in the packet. |
| */ |
| @Property(MessageContext.WSDL_OPERATION) |
| public final |
| @Nullable |
| QName getWSDLOperation() { |
| if (wsdlOperation != null) return wsdlOperation; |
| if ( wsdlOperationMapping == null) wsdlOperationMapping = getWSDLOperationMapping(); |
| if ( wsdlOperationMapping != null ) wsdlOperation = wsdlOperationMapping.getOperationName(); |
| return wsdlOperation; |
| } |
| |
| public WSDLOperationMapping getWSDLOperationMapping() { |
| if (wsdlOperationMapping != null) return wsdlOperationMapping; |
| OperationDispatcher opDispatcher = null; |
| if (endpoint != null) { |
| opDispatcher = endpoint.getOperationDispatcher(); |
| } else if (proxy != null) { |
| opDispatcher = ((Stub) proxy).getOperationDispatcher(); |
| } |
| //OpDispatcher is null when there is no WSDLModel |
| if (opDispatcher != null) { |
| try { |
| wsdlOperationMapping = opDispatcher.getWSDLOperationMapping(this); |
| } catch (DispatchException e) { |
| //Ignore, this might be a protocol message which may not have a wsdl operation |
| //LOGGER.info("Cannot resolve wsdl operation that this Packet is targeted for."); |
| } |
| } |
| return wsdlOperationMapping; |
| } |
| |
| /** |
| * Set the wsdl operation to avoid lookup from other data. |
| * This is useful in SEI based clients, where the WSDL operation can be known |
| * from the associated {@link JavaMethod} |
| * |
| * @param wsdlOp QName |
| */ |
| public void setWSDLOperation(QName wsdlOp) { |
| this.wsdlOperation = wsdlOp; |
| } |
| |
| /** |
| * True if this message came from a transport (IOW inbound), |
| * and in paricular from a "secure" transport. A transport |
| * needs to set this flag appropriately. |
| * |
| * <p> |
| * This is a requirement from the security team. |
| */ |
| // TODO: expose this as a property |
| public boolean wasTransportSecure; |
| |
| /** |
| * Inbound transport headers are captured in a transport neutral way. |
| * Transports are expected to fill this data after creating a Packet. |
| * <p> |
| * {@link SOAPMessage#getMimeHeaders()} would return these headers. |
| */ |
| public static final String INBOUND_TRANSPORT_HEADERS = "com.sun.xml.internal.ws.api.message.packet.inbound.transport.headers"; |
| |
| /** |
| * Outbound transport headers are captured in a transport neutral way. |
| * |
| * <p> |
| * Transports may choose to ignore certain headers that interfere with |
| * its correct operation, such as |
| * <tt>Content-Type</tt> and <tt>Content-Length</tt>. |
| */ |
| public static final String OUTBOUND_TRANSPORT_HEADERS = "com.sun.xml.internal.ws.api.message.packet.outbound.transport.headers"; |
| |
| /** |
| * |
| */ |
| public static final String HA_INFO = "com.sun.xml.internal.ws.api.message.packet.hainfo"; |
| |
| |
| /** |
| * This property holds the snapshot of HandlerConfiguration |
| * at the time of invocation. |
| * This property is used by MUPipe and HandlerPipe implementations. |
| */ |
| @Property(BindingProviderProperties.JAXWS_HANDLER_CONFIG) |
| public HandlerConfiguration handlerConfig; |
| |
| /** |
| * If a message originates from a proxy stub that implements |
| * a port interface, this field is set to point to that object. |
| * |
| * TODO: who's using this property? |
| */ |
| @Property(BindingProviderProperties.JAXWS_CLIENT_HANDLE_PROPERTY) |
| public BindingProvider proxy; |
| |
| /** |
| * Determines if the governing {@link Adapter} or {@link com.sun.xml.internal.ws.api.pipe.Fiber.CompletionCallback} |
| * will handle delivering response messages targeted at non-anonymous endpoint |
| * addresses. Prior to the introduction of this flag |
| * the {@link WsaServerTube} would deliver non-anonymous responses. |
| */ |
| public boolean isAdapterDeliversNonAnonymousResponse; |
| |
| /** |
| * During invocation of a client Stub or Dispatch a Packet is |
| * created then the Stub's RequestContext is copied into the |
| * Packet. On certain internal cases the Packet is created |
| * *before* the invocation. In those cases we want the contents |
| * of the Packet to take precedence when ever any key/value pairs |
| * collide : if the Packet contains a value for a key use it, |
| * otherwise copy as usual from Stub. |
| */ |
| public boolean packetTakesPriorityOverRequestContext = false; |
| |
| /** |
| * The endpoint address to which this message is sent to. |
| * |
| * <p> |
| * The JAX-WS spec allows this to be changed for each message, |
| * so it's designed to be a property. |
| * |
| * <p> |
| * Must not be null for a request message on the client. Otherwise |
| * it's null. |
| */ |
| public EndpointAddress endpointAddress; |
| |
| /** |
| * @deprecated |
| * The programatic acccess should be done via |
| * {@link #endpointAddress}. This is for JAX-WS client applications |
| * that access this property via {@link BindingProvider#ENDPOINT_ADDRESS_PROPERTY}. |
| */ |
| @Property(BindingProvider.ENDPOINT_ADDRESS_PROPERTY) |
| public String getEndPointAddressString() { |
| if (endpointAddress == null) { |
| return null; |
| } else { |
| return endpointAddress.toString(); |
| } |
| } |
| |
| public void setEndPointAddressString(String s) { |
| if (s == null) { |
| this.endpointAddress = null; |
| } else { |
| this.endpointAddress = EndpointAddress.create(s); |
| } |
| } |
| |
| /** |
| * The value of {@link ContentNegotiation#PROPERTY} |
| * property. |
| * <p/> |
| * This property is used only on the client side. |
| */ |
| public ContentNegotiation contentNegotiation; |
| |
| @Property(ContentNegotiation.PROPERTY) |
| public String getContentNegotiationString() { |
| return (contentNegotiation != null) ? contentNegotiation.toString() : null; |
| } |
| |
| public void setContentNegotiationString(String s) { |
| if (s == null) { |
| contentNegotiation = null; |
| } else { |
| try { |
| contentNegotiation = ContentNegotiation.valueOf(s); |
| } catch (IllegalArgumentException e) { |
| // If the value is not recognized default to none |
| contentNegotiation = ContentNegotiation.none; |
| } |
| } |
| } |
| |
| /** |
| * Gives a list of Reference Parameters in the Message |
| * <p> |
| * Headers which have attribute wsa:IsReferenceParameter="true" |
| * This is not cached as one may reset the Message. |
| *<p> |
| */ |
| @Property(MessageContext.REFERENCE_PARAMETERS) |
| public |
| @NotNull |
| List<Element> getReferenceParameters() { |
| Message msg = getMessage(); |
| List<Element> refParams = new ArrayList<Element>(); |
| if (msg == null) { |
| return refParams; |
| } |
| MessageHeaders hl = msg.getHeaders(); |
| for (Header h : hl.asList()) { |
| String attr = h.getAttribute(AddressingVersion.W3C.nsUri, "IsReferenceParameter"); |
| if (attr != null && (attr.equals("true") || attr.equals("1"))) { |
| Document d = DOMUtil.createDom(); |
| SAX2DOMEx s2d = new SAX2DOMEx(d); |
| try { |
| h.writeTo(s2d, XmlUtil.DRACONIAN_ERROR_HANDLER); |
| refParams.add((Element) d.getLastChild()); |
| } catch (SAXException e) { |
| throw new WebServiceException(e); |
| } |
| /* |
| DOMResult result = new DOMResult(d); |
| XMLDOMWriterImpl domwriter = new XMLDOMWriterImpl(result); |
| try { |
| h.writeTo(domwriter); |
| refParams.add((Element) result.getNode().getLastChild()); |
| } catch (XMLStreamException e) { |
| throw new WebServiceException(e); |
| } |
| */ |
| } |
| } |
| return refParams; |
| } |
| |
| /** |
| * This method is for exposing header list through {@link PropertySet#get(Object)}, |
| * for user applications, and should never be invoked directly from within the JAX-WS RI. |
| */ |
| @Property(JAXWSProperties.INBOUND_HEADER_LIST_PROPERTY) |
| /*package*/ MessageHeaders getHeaderList() { |
| Message msg = getMessage(); |
| if (msg == null) { |
| return null; |
| } |
| return msg.getHeaders(); |
| } |
| |
| /** |
| * The list of MIME types that are acceptable to a receiver |
| * of an outbound message. |
| * |
| * This property is used only on the server side. |
| * |
| * <p>The representation shall be that specified by the HTTP Accept |
| * request-header field. |
| * |
| * <p>The list of content types will be obtained from the transport |
| * meta-data of a inbound message in a request/response message exchange. |
| * Hence this property will be set by the service-side transport pipe. |
| */ |
| public String acceptableMimeTypes; |
| |
| /** |
| * When non-null, this object is consulted to |
| * implement {@link WebServiceContext} methods |
| * exposed to the user application. |
| * |
| * Used only on the server side. |
| * |
| * <p> |
| * This property is set from the parameter |
| * of {@link WSEndpoint.PipeHead#process}. |
| */ |
| public WebServiceContextDelegate webServiceContextDelegate; |
| |
| /** |
| * Used only on the server side so that the transport |
| * can close the connection early. |
| * |
| * <p> |
| * This field can be null. While a message is being processed, |
| * this field can be set explicitly to null, to prevent |
| * future pipes from closing a transport (see {@link #keepTransportBackChannelOpen()}) |
| * |
| * <p> |
| * This property is set from the parameter |
| * of {@link WSEndpoint.PipeHead#process}. |
| */ |
| public |
| @Nullable |
| TransportBackChannel transportBackChannel; |
| |
| /** |
| * Keeps the transport back channel open (by seeting {@link #transportBackChannel} to null.) |
| * |
| * @return |
| * The previous value of {@link #transportBackChannel}. |
| */ |
| public TransportBackChannel keepTransportBackChannelOpen() { |
| TransportBackChannel r = transportBackChannel; |
| transportBackChannel = null; |
| return r; |
| } |
| |
| /** |
| * The governing owner of this packet. On the service-side this is the {@link Adapter} and on the client it is the {@link Stub}. |
| * |
| */ |
| public Component component; |
| |
| /** |
| * The governing {@link WSEndpoint} in which this message is floating. |
| * |
| * <p> |
| * This property is set if and only if this is on the server side. |
| */ |
| @Property(JAXWSProperties.WSENDPOINT) |
| public WSEndpoint endpoint; |
| |
| /** |
| * The value of the SOAPAction header associated with the message. |
| * |
| * <p> |
| * For outgoing messages, the transport may sends out this value. |
| * If this field is null, the transport may choose to send <tt>""</tt> |
| * (quoted empty string.) |
| * |
| * For incoming messages, the transport will set this field. |
| * If the incoming message did not contain the SOAPAction header, |
| * the transport sets this field to null. |
| * |
| * <p> |
| * If the value is non-null, it must be always in the quoted form. |
| * The value can be null. |
| * |
| * <p> |
| * Note that the way the transport sends this value out depends on |
| * transport and SOAP version. |
| * <p/> |
| * For HTTP transport and SOAP 1.1, BP requires that SOAPAction |
| * header is present (See {@BP R2744} and {@BP R2745}.) For SOAP 1.2, |
| * this is moved to the parameter of the "application/soap+xml". |
| */ |
| @Property(BindingProvider.SOAPACTION_URI_PROPERTY) |
| public String soapAction; |
| |
| /** |
| * A hint indicating that whether a transport should expect |
| * a reply back from the server. |
| * |
| * <p> |
| * This property is used on the client-side for |
| * outbound messages, so that a pipeline |
| * can communicate to the terminal (or intermediate) {@link Tube}s |
| * about this knowledge. |
| * |
| * <p> |
| * This property <b>MUST NOT</b> be used by 2-way transports |
| * that have the transport back channel. Those transports |
| * must always check a reply coming through the transport back |
| * channel regardless of this value, and act accordingly. |
| * (This is because the expectation of the client and |
| * that of the server can be different, for example because |
| * of a bug in user's configuration.) |
| * |
| * <p> |
| * This property is for one-way transports, and more |
| * specifically for the coordinator that correlates sent requests |
| * and incoming replies, to decide whether to block |
| * until a response is received. |
| * |
| * <p> |
| * Also note that this property is related to |
| * {@link WSDLOperation#isOneWay()} but not the same thing. |
| * In fact in general, they are completely orthogonal. |
| * |
| * For example, the calling application can choose to invoke |
| * {@link Dispatch#invoke(Object)} or {@link Dispatch#invokeOneWay(Object)} |
| * with an operation (which determines the value of this property), |
| * regardless of whether WSDL actually says it's one way or not. |
| * So these two booleans can take any combinations. |
| * |
| * |
| * <p> |
| * When this property is {@link Boolean#FALSE}, it means that |
| * the pipeline does not expect a reply from a server (and therefore |
| * the correlator should not block for a reply message |
| * -- if such a reply does arrive, it can be just ignored.) |
| * |
| * <p> |
| * When this property is {@link Boolean#TRUE}, it means that |
| * the pipeline expects a reply from a server (and therefore |
| * the correlator should block to see if a reply message is received, |
| * |
| * <p> |
| * This property is always set to {@link Boolean#TRUE} or |
| * {@link Boolean#FALSE} when used on the request message |
| * on the client side. |
| * No other {@link Boolean} instances are allowed. |
| * <p> |
| * |
| * In all other situations, this property is null. |
| * |
| */ |
| @Property(BindingProviderProperties.ONE_WAY_OPERATION) |
| public Boolean expectReply; |
| |
| |
| /** |
| * This property will be removed in a near future. |
| * |
| * <p> |
| * A part of what this flag represented moved to |
| * {@link #expectReply} and the other part was moved |
| * to {@link Message#isOneWay(WSDLPort)}. Please update |
| * your code soon, or risk breaking your build!! |
| */ |
| @Deprecated |
| public Boolean isOneWay; |
| |
| /** |
| * Indicates whether is invoking a synchronous pattern. If true, no |
| * async client programming model (e.g. AsyncResponse or AsyncHandler) |
| * were used to make the request that created this packet. |
| */ |
| public Boolean isSynchronousMEP; |
| |
| /** |
| * Indicates whether a non-null AsyncHandler was given at the point of |
| * making the request that created this packet. This flag can be used |
| * by Tube implementations to decide how to react when isSynchronousMEP |
| * is false. If true, the client gave a non-null AsyncHandler instance |
| * at the point of request, and will be expecting a response on that |
| * handler when this request has been processed. |
| */ |
| public Boolean nonNullAsyncHandlerGiven; |
| |
| /** |
| * USE-CASE: |
| * WS-AT is enabled, but there is no WSDL available. |
| * If Packet.isRequestReplyMEP() is Boolean.TRUE then WS-AT should |
| * add the TX context. |
| * |
| * This value is exposed to users via facades at higher abstraction layers. |
| * The user should NEVER use Packet directly. |
| * This value should ONLY be set by users. |
| */ |
| private Boolean isRequestReplyMEP; |
| public Boolean isRequestReplyMEP() { return isRequestReplyMEP; } |
| public void setRequestReplyMEP(final Boolean x) { isRequestReplyMEP = x; } |
| |
| /** |
| * Lazily created set of handler-scope property names. |
| * |
| * <p> |
| * We expect that this is only used when handlers are present |
| * and they explicitly set some handler-scope values. |
| * |
| * @see #getHandlerScopePropertyNames(boolean) |
| */ |
| private Set<String> handlerScopePropertyNames; |
| |
| /** |
| * Bag to capture properties that are available for the whole |
| * message invocation (namely on both requests and responses.) |
| * |
| * <p> |
| * These properties are copied from a request to a response. |
| * This is where we keep properties that are set by handlers. |
| * |
| * <p> |
| * See <a href="#properties">class javadoc</a> for more discussion. |
| * |
| * @see #getHandlerScopePropertyNames(boolean) |
| */ |
| public final Map<String, Object> invocationProperties; |
| |
| /** |
| * Gets a {@link Set} that stores handler-scope properties. |
| * |
| * <p> |
| * These properties will not be exposed to the response context. |
| * Consequently, if a {@link Tube} wishes to hide a property |
| * to {@link ResponseContext}, it needs to add the property name |
| * to this set. |
| * |
| * @param readOnly |
| * Return true if the caller only intends to read the value of this set. |
| * Internally, the {@link Set} is allocated lazily, and this flag helps |
| * optimizing the strategy. |
| * |
| * @return |
| * always non-null, possibly empty set that stores property names. |
| */ |
| public final Set<String> getHandlerScopePropertyNames(boolean readOnly) { |
| Set<String> o = this.handlerScopePropertyNames; |
| if (o == null) { |
| if (readOnly) { |
| return Collections.emptySet(); |
| } |
| o = new HashSet<String>(); |
| this.handlerScopePropertyNames = o; |
| } |
| return o; |
| } |
| |
| /** |
| * This method no longer works. |
| * |
| * @deprecated |
| * Use {@link #getHandlerScopePropertyNames(boolean)}. |
| * To be removed once Tango components are updated. |
| */ |
| public final Set<String> getApplicationScopePropertyNames(boolean readOnly) { |
| assert false; |
| return new HashSet<String>(); |
| } |
| |
| /** |
| * Creates a response {@link Packet} from a request packet ({@code this}). |
| * |
| * <p> |
| * When a {@link Packet} for a reply is created, some properties need to be |
| * copied over from a request to a response, and this method handles it correctly. |
| * |
| * @deprecated |
| * Use createClientResponse(Message) for client side and |
| * createServerResponse(Message, String) for server side response |
| * creation. |
| * |
| * @param msg |
| * The {@link Message} that represents a reply. Can be null. |
| */ |
| @Deprecated |
| public Packet createResponse(Message msg) { |
| Packet response = new Packet(this); |
| response.setMessage(msg); |
| return response; |
| } |
| |
| /** |
| * Creates a response {@link Packet} from a request packet ({@code this}). |
| * |
| * <p> |
| * When a {@link Packet} for a reply is created, some properties need to be |
| * copied over from a request to a response, and this method handles it correctly. |
| * |
| * @param msg |
| * The {@link Message} that represents a reply. Can be null. |
| */ |
| public Packet createClientResponse(Message msg) { |
| Packet response = new Packet(this); |
| response.setMessage(msg); |
| finishCreateRelateClientResponse(response); |
| return response; |
| } |
| |
| /** |
| * For use cases that start with an existing Packet. |
| */ |
| public Packet relateClientResponse(final Packet response) { |
| response.relatePackets(this, true); |
| finishCreateRelateClientResponse(response); |
| return response; |
| } |
| |
| private void finishCreateRelateClientResponse(final Packet response) { |
| response.soapAction = null; // de-initializing |
| response.setState(State.ClientResponse); |
| } |
| |
| /** |
| * Creates a server-side response {@link Packet} from a request |
| * packet ({@code this}). If WS-Addressing is enabled, a default Action |
| * Message Addressing Property is obtained using <code>wsdlPort</code> {@link WSDLPort} |
| * and <code>binding</code> {@link WSBinding}. |
| * <p><p> |
| * This method should be called to create application response messages |
| * since they are associated with a {@link WSBinding} and {@link WSDLPort}. |
| * For creating protocol messages that require a non-default Action, use |
| * {@link #createServerResponse(Message, com.sun.xml.internal.ws.api.addressing.AddressingVersion, com.sun.xml.internal.ws.api.SOAPVersion, String)}. |
| * |
| * @param responseMessage The {@link Message} that represents a reply. Can be null. |
| * @param wsdlPort The response WSDL port. |
| * @param binding The response Binding. Cannot be null. |
| * @return response packet |
| */ |
| public Packet createServerResponse(@Nullable Message responseMessage, @Nullable WSDLPort wsdlPort, @Nullable SEIModel seiModel, @NotNull WSBinding binding) { |
| Packet r = createClientResponse(responseMessage); |
| return relateServerResponse(r, wsdlPort, seiModel, binding); |
| } |
| |
| /** |
| * Copy all properties from ({@code this}) packet into a input {@link Packet} |
| * @param response packet |
| */ |
| public void copyPropertiesTo(@Nullable Packet response){ |
| relatePackets(response, false); |
| } |
| |
| |
| /** |
| * A common method to make members related between input packet and this packet |
| * |
| * @param packet |
| * @param isCopy 'true' means copying all properties from input packet; |
| * 'false' means copying all properties from this packet to input packet. |
| */ |
| private void relatePackets(@Nullable Packet packet, boolean isCopy) |
| { |
| Packet request; |
| Packet response; |
| |
| if (!isCopy) { //is relate |
| request = this; |
| response = packet; |
| |
| // processing specific properties |
| response.soapAction = null; |
| response.invocationProperties.putAll(request.invocationProperties); |
| if (this.getState().equals(State.ServerRequest)) { |
| response.setState(State.ServerResponse); |
| } |
| } else { //is copy constructor |
| request = packet; |
| response = this; |
| |
| // processing specific properties |
| response.soapAction = request.soapAction; |
| response.setState(request.getState()); |
| } |
| |
| request.copySatelliteInto(response); |
| response.isAdapterDeliversNonAnonymousResponse = request.isAdapterDeliversNonAnonymousResponse; |
| response.handlerConfig = request.handlerConfig; |
| response.handlerScopePropertyNames = request.handlerScopePropertyNames; |
| response.contentNegotiation = request.contentNegotiation; |
| response.wasTransportSecure = request.wasTransportSecure; |
| response.transportBackChannel = request.transportBackChannel; |
| response.endpointAddress = request.endpointAddress; |
| response.wsdlOperation = request.wsdlOperation; |
| response.wsdlOperationMapping = request.wsdlOperationMapping; |
| response.acceptableMimeTypes = request.acceptableMimeTypes; |
| response.endpoint = request.endpoint; |
| response.proxy = request.proxy; |
| response.webServiceContextDelegate = request.webServiceContextDelegate; |
| response.expectReply = request.expectReply; |
| response.component = request.component; |
| response.mtomAcceptable = request.mtomAcceptable; |
| response.mtomRequest = request.mtomRequest; |
| // copy other properties that need to be copied. is there any? |
| } |
| |
| |
| public Packet relateServerResponse(@Nullable Packet r, @Nullable WSDLPort wsdlPort, @Nullable SEIModel seiModel, @NotNull WSBinding binding) { |
| relatePackets(r, false); |
| r.setState(State.ServerResponse); |
| AddressingVersion av = binding.getAddressingVersion(); |
| // populate WS-A headers only if WS-A is enabled |
| if (av == null) { |
| return r; |
| } |
| |
| if (getMessage() == null) { |
| return r; |
| } |
| |
| //populate WS-A headers only if the request has addressing headers |
| String inputAction = AddressingUtils.getAction(getMessage().getHeaders(), av, binding.getSOAPVersion()); |
| if (inputAction == null) { |
| return r; |
| } |
| // if one-way, then dont populate any WS-A headers |
| if (r.getMessage() == null || (wsdlPort != null && getMessage().isOneWay(wsdlPort))) { |
| return r; |
| } |
| |
| // otherwise populate WS-Addressing headers |
| populateAddressingHeaders(binding, r, wsdlPort, seiModel); |
| return r; |
| } |
| |
| /** |
| * Creates a server-side response {@link Packet} from a request |
| * packet ({@code this}). If WS-Addressing is enabled, <code>action</code> |
| * is used as Action Message Addressing Property. |
| * <p><p> |
| * This method should be called only for creating protocol response messages |
| * that require a particular value of Action since they are not associated |
| * with a {@link WSBinding} and {@link WSDLPort} but do know the {@link AddressingVersion} |
| * and {@link SOAPVersion}. |
| * |
| * @param responseMessage The {@link Message} that represents a reply. Can be null. |
| * @param addressingVersion The WS-Addressing version of the response message. |
| * @param soapVersion The SOAP version of the response message. |
| * @param action The response Action Message Addressing Property value. |
| * @return response packet |
| */ |
| public Packet createServerResponse(@Nullable Message responseMessage, @NotNull AddressingVersion addressingVersion, @NotNull SOAPVersion soapVersion, @NotNull String action) { |
| Packet responsePacket = createClientResponse(responseMessage); |
| responsePacket.setState(State.ServerResponse); |
| // populate WS-A headers only if WS-A is enabled |
| if (addressingVersion == null) { |
| return responsePacket; |
| } |
| //populate WS-A headers only if the request has addressing headers |
| String inputAction = AddressingUtils.getAction(this.getMessage().getHeaders(), addressingVersion, soapVersion); |
| if (inputAction == null) { |
| return responsePacket; |
| } |
| |
| populateAddressingHeaders(responsePacket, addressingVersion, soapVersion, action, false); |
| return responsePacket; |
| } |
| |
| /** |
| * Overwrites the {@link Message} of the response packet ({@code this}) by the given {@link Message}. |
| * Unlike {@link #setMessage(Message)}, fill in the addressing headers correctly, and this process |
| * requires the access to the request packet. |
| * |
| * <p> |
| * This method is useful when the caller needs to swap a response message completely to a new one. |
| * |
| * @see #createServerResponse(Message, AddressingVersion, SOAPVersion, String) |
| */ |
| public void setResponseMessage(@NotNull Packet request, @Nullable Message responseMessage, @NotNull AddressingVersion addressingVersion, @NotNull SOAPVersion soapVersion, @NotNull String action) { |
| Packet temp = request.createServerResponse(responseMessage, addressingVersion, soapVersion, action); |
| setMessage(temp.getMessage()); |
| } |
| |
| private void populateAddressingHeaders(Packet responsePacket, AddressingVersion av, SOAPVersion sv, String action, boolean mustUnderstand) { |
| // populate WS-A headers only if WS-A is enabled |
| if (av == null) return; |
| |
| // if one-way, then dont populate any WS-A headers |
| if (responsePacket.getMessage() == null) |
| return; |
| |
| MessageHeaders hl = responsePacket.getMessage().getHeaders(); |
| |
| WsaPropertyBag wpb = getSatellite(WsaPropertyBag.class); |
| Message msg = getMessage(); |
| // wsa:To |
| WSEndpointReference replyTo = null; |
| Header replyToFromRequestMsg = AddressingUtils.getFirstHeader(msg.getHeaders(), av.replyToTag, true, sv); |
| Header replyToFromResponseMsg = hl.get(av.toTag, false); |
| boolean replaceToTag = true; |
| try{ |
| if (replyToFromRequestMsg != null){ |
| replyTo = replyToFromRequestMsg.readAsEPR(av); |
| } |
| if (replyToFromResponseMsg != null && replyTo == null) { |
| replaceToTag = false; |
| } |
| } catch (XMLStreamException e) { |
| throw new WebServiceException(AddressingMessages.REPLY_TO_CANNOT_PARSE(), e); |
| } |
| if (replyTo == null) { |
| replyTo = AddressingUtils.getReplyTo(msg.getHeaders(), av, sv); |
| } |
| |
| // wsa:Action, add if the message doesn't already contain it, |
| // generally true for SEI case where there is SEIModel or WSDLModel |
| // false for Provider with no wsdl, Expects User to set the coresponding header on the Message. |
| if (AddressingUtils.getAction(responsePacket.getMessage().getHeaders(), av, sv) == null) { |
| //wsa:Action header is not set in the message, so use the wsa:Action passed as the parameter. |
| hl.add(new StringHeader(av.actionTag, action, sv, mustUnderstand)); |
| } |
| |
| // wsa:MessageID |
| if (responsePacket.getMessage().getHeaders().get(av.messageIDTag, false) == null) { |
| // if header doesn't exist, method getID creates a new random id |
| String newID = Message.generateMessageID(); |
| hl.add(new StringHeader(av.messageIDTag, newID)); |
| } |
| |
| // wsa:RelatesTo |
| String mid = null; |
| if (wpb != null) { |
| mid = wpb.getMessageID(); |
| } |
| if (mid == null) { |
| mid = AddressingUtils.getMessageID(msg.getHeaders(), av, sv); |
| } |
| if (mid != null) { |
| hl.addOrReplace(new RelatesToHeader(av.relatesToTag, mid)); |
| } |
| |
| |
| // populate reference parameters |
| WSEndpointReference refpEPR = null; |
| if (responsePacket.getMessage().isFault()) { |
| // choose FaultTo |
| if (wpb != null) { |
| refpEPR = wpb.getFaultToFromRequest(); |
| } |
| if (refpEPR == null) { |
| refpEPR = AddressingUtils.getFaultTo(msg.getHeaders(), av, sv); |
| } |
| // if FaultTo is null, then use ReplyTo |
| if (refpEPR == null) { |
| refpEPR = replyTo; |
| } |
| } else { |
| // choose ReplyTo |
| refpEPR = replyTo; |
| } |
| if (replaceToTag && refpEPR != null) { |
| hl.addOrReplace(new StringHeader(av.toTag, refpEPR.getAddress())); |
| refpEPR.addReferenceParametersToList(hl); |
| } |
| } |
| |
| private void populateAddressingHeaders(WSBinding binding, Packet responsePacket, WSDLPort wsdlPort, SEIModel seiModel) { |
| AddressingVersion addressingVersion = binding.getAddressingVersion(); |
| |
| if (addressingVersion == null) { |
| return; |
| } |
| |
| WsaTubeHelper wsaHelper = addressingVersion.getWsaHelper(wsdlPort, seiModel, binding); |
| String action = responsePacket.getMessage().isFault() ? |
| wsaHelper.getFaultAction(this, responsePacket) : |
| wsaHelper.getOutputAction(this); |
| if (action == null) { |
| LOGGER.info("WSA headers are not added as value for wsa:Action cannot be resolved for this message"); |
| return; |
| } |
| populateAddressingHeaders(responsePacket, addressingVersion, binding.getSOAPVersion(), action, AddressingVersion.isRequired(binding)); |
| } |
| |
| public String toShortString() { |
| return super.toString(); |
| } |
| |
| // For use only in a debugger |
| @Override |
| public String toString() { |
| StringBuilder buf = new StringBuilder(); |
| buf.append(super.toString()); |
| String content; |
| try { |
| Message msg = getMessage(); |
| if (msg != null) { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| XMLStreamWriter xmlWriter = XMLStreamWriterFactory.create(baos, "UTF-8"); |
| msg.copy().writeTo(xmlWriter); |
| xmlWriter.flush(); |
| xmlWriter.close(); |
| baos.flush(); |
| XMLStreamWriterFactory.recycle(xmlWriter); |
| |
| byte[] bytes = baos.toByteArray(); |
| //message = Messages.create(XMLStreamReaderFactory.create(null, new ByteArrayInputStream(bytes), "UTF-8", true)); |
| content = new String(bytes, "UTF-8"); |
| } else { |
| content = "<none>"; |
| } |
| } catch (Throwable t) { |
| throw new WebServiceException(t); |
| } |
| buf.append(" Content: ").append(content); |
| return buf.toString(); |
| } |
| |
| // completes TypedMap |
| private static final PropertyMap model; |
| |
| static { |
| model = parse(Packet.class); |
| } |
| |
| @Override |
| protected PropertyMap getPropertyMap() { |
| return model; |
| } |
| |
| public Map<String, Object> asMapIncludingInvocationProperties() { |
| final Map<String, Object> asMap = asMap(); |
| return new AbstractMap<String, Object>() { |
| @Override |
| public Object get(Object key) { |
| Object o = asMap.get(key); |
| if (o != null) |
| return o; |
| |
| return invocationProperties.get(key); |
| } |
| |
| @Override |
| public int size() { |
| return asMap.size() + invocationProperties.size(); |
| } |
| |
| @Override |
| public boolean containsKey(Object key) { |
| if (asMap.containsKey(key)) |
| return true; |
| return invocationProperties.containsKey(key); |
| } |
| |
| @Override |
| public Set<Entry<String, Object>> entrySet() { |
| final Set<Entry<String, Object>> asMapEntries = asMap.entrySet(); |
| final Set<Entry<String, Object>> ipEntries = invocationProperties.entrySet(); |
| |
| return new AbstractSet<Entry<String, Object>>() { |
| @Override |
| public Iterator<Entry<String, Object>> iterator() { |
| final Iterator<Entry<String, Object>> asMapIt = asMapEntries.iterator(); |
| final Iterator<Entry<String, Object>> ipIt = ipEntries.iterator(); |
| |
| return new Iterator<Entry<String, Object>>() { |
| @Override |
| public boolean hasNext() { |
| return asMapIt.hasNext() || ipIt.hasNext(); |
| } |
| |
| @Override |
| public java.util.Map.Entry<String, Object> next() { |
| if (asMapIt.hasNext()) |
| return asMapIt.next(); |
| return ipIt.next(); |
| } |
| |
| @Override |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| }; |
| } |
| |
| @Override |
| public int size() { |
| return asMap.size() + invocationProperties.size(); |
| } |
| }; |
| } |
| |
| @Override |
| public Object put(String key, Object value) { |
| if (supports(key)) |
| return asMap.put(key, value); |
| |
| return invocationProperties.put(key, value); |
| } |
| |
| @Override |
| public void clear() { |
| asMap.clear(); |
| invocationProperties.clear(); |
| } |
| |
| @Override |
| public Object remove(Object key) { |
| if (supports(key)) |
| return asMap.remove(key); |
| |
| return invocationProperties.remove(key); |
| } |
| }; |
| } |
| |
| private static final Logger LOGGER = Logger.getLogger(Packet.class.getName()); |
| |
| @Override |
| public SOAPMessage getSOAPMessage() throws SOAPException { |
| return getAsSOAPMessage(); |
| } |
| |
| //TODO replace the message to a SAAJMEssage issue - JRFSAAJMessage or SAAJMessage? |
| @Override |
| public SOAPMessage getAsSOAPMessage() throws SOAPException { |
| Message msg = this.getMessage(); |
| if (msg == null) |
| return null; |
| if (msg instanceof MessageWritable) |
| ((MessageWritable) msg).setMTOMConfiguration(mtomFeature); |
| return msg.readAsSOAPMessage(this, this.getState().isInbound()); |
| } |
| |
| public |
| Codec codec = null; |
| public Codec getCodec() { |
| if (codec != null) { |
| return codec; |
| } |
| if (endpoint != null) { |
| codec = endpoint.createCodec(); |
| } |
| WSBinding wsb = getBinding(); |
| if (wsb != null) { |
| codec = wsb.getBindingId().createEncoder(wsb); |
| } |
| return codec; |
| } |
| |
| @Override |
| public com.oracle.webservices.internal.api.message.ContentType writeTo( OutputStream out ) throws IOException { |
| Message msg = getInternalMessage(); |
| if (msg instanceof MessageWritable) { |
| ((MessageWritable) msg).setMTOMConfiguration(mtomFeature); |
| return ((MessageWritable)msg).writeTo(out); |
| } |
| return getCodec().encode(this, out); |
| } |
| |
| public com.oracle.webservices.internal.api.message.ContentType writeTo( WritableByteChannel buffer ) { |
| return getCodec().encode(this, buffer); |
| } |
| |
| private ContentType contentType; |
| |
| /** |
| * If the request's Content-Type is multipart/related; type=application/xop+xml, then this set to to true |
| * |
| * Used on server-side, for encoding the repsonse. |
| */ |
| private Boolean mtomRequest; |
| |
| /** |
| * Based on request's Accept header this is set. |
| * Currently only set if MTOMFeature is enabled. |
| * |
| * Should be used on server-side, for encoding the response. |
| */ |
| private Boolean mtomAcceptable; |
| |
| private MTOMFeature mtomFeature; |
| |
| public Boolean getMtomRequest() { |
| return mtomRequest; |
| } |
| |
| public void setMtomRequest(Boolean mtomRequest) { |
| this.mtomRequest = mtomRequest; |
| } |
| |
| public Boolean getMtomAcceptable() { |
| return mtomAcceptable; |
| } |
| |
| Boolean checkMtomAcceptable; |
| public void checkMtomAcceptable() { |
| if (checkMtomAcceptable == null) { |
| if (acceptableMimeTypes == null || isFastInfosetDisabled) { |
| checkMtomAcceptable = false; |
| } else { |
| checkMtomAcceptable = (acceptableMimeTypes.indexOf(MtomCodec.XOP_XML_MIME_TYPE) != -1); |
| // StringTokenizer st = new StringTokenizer(acceptableMimeTypes, ","); |
| // while (st.hasMoreTokens()) { |
| // final String token = st.nextToken().trim(); |
| // if (token.toLowerCase().contains(MtomCodec.XOP_XML_MIME_TYPE)) { |
| // mtomAcceptable = true; |
| // } |
| // } |
| // if (mtomAcceptable == null) mtomAcceptable = false; |
| } |
| } |
| mtomAcceptable = checkMtomAcceptable; |
| } |
| |
| private Boolean fastInfosetAcceptable; |
| |
| public Boolean getFastInfosetAcceptable(String fiMimeType) { |
| if (fastInfosetAcceptable == null) { |
| if (acceptableMimeTypes == null || isFastInfosetDisabled) { |
| fastInfosetAcceptable = false; |
| } else { |
| fastInfosetAcceptable = (acceptableMimeTypes.indexOf(fiMimeType) != -1); |
| } |
| // if (accept == null || isFastInfosetDisabled) return false; |
| // |
| // StringTokenizer st = new StringTokenizer(accept, ","); |
| // while (st.hasMoreTokens()) { |
| // final String token = st.nextToken().trim(); |
| // if (token.equalsIgnoreCase(fiMimeType)) { |
| // return true; |
| // } |
| // } |
| // return false; |
| } |
| return fastInfosetAcceptable; |
| } |
| |
| |
| public void setMtomFeature(MTOMFeature mtomFeature) { |
| this.mtomFeature = mtomFeature; |
| } |
| |
| public MTOMFeature getMtomFeature() { |
| //If we have a binding, use that in preference to an explicitly |
| //set MTOMFeature |
| WSBinding binding = getBinding(); |
| if (binding != null) { |
| return binding.getFeature(MTOMFeature.class); |
| } |
| return mtomFeature; |
| } |
| |
| @Override |
| public com.oracle.webservices.internal.api.message.ContentType getContentType() { |
| if (contentType == null) { |
| contentType = getInternalContentType(); |
| } |
| if (contentType == null) { |
| contentType = getCodec().getStaticContentType(this); |
| } |
| if (contentType == null) { |
| //TODO write to buffer |
| } |
| return contentType; |
| } |
| |
| public ContentType getInternalContentType() { |
| Message msg = getInternalMessage(); |
| if (msg instanceof MessageWritable) { |
| return ((MessageWritable)msg).getContentType(); |
| } |
| return contentType; |
| } |
| |
| public void setContentType(ContentType contentType) { |
| this.contentType = contentType; |
| } |
| |
| public enum Status { |
| Request, Response, Unknown; |
| public boolean isRequest() { return Request.equals(this); } |
| public boolean isResponse() { return Response.equals(this); } |
| } |
| |
| public enum State { |
| ServerRequest(true), ClientRequest(false), ServerResponse(false), ClientResponse(true); |
| private boolean inbound; |
| State(boolean inbound) { |
| this.inbound = inbound; |
| } |
| public boolean isInbound() { |
| return inbound; |
| } |
| } |
| |
| // private Status status = Status.Unknown; |
| |
| //Default state is ServerRequest - some custom adapters may not set the value of state |
| //upon server request - all other code paths should set it |
| private State state = State.ServerRequest; |
| |
| // public Status getStatus() { return status; } |
| |
| public State getState() { return state; } |
| public void setState(State state) { this.state = state; } |
| |
| public boolean shouldUseMtom() { |
| if (getState().isInbound()) { |
| return isMtomContentType(); |
| } else { |
| return shouldUseMtomOutbound(); |
| } |
| } |
| |
| private boolean shouldUseMtomOutbound() { |
| //Use the getter to make sure all the logic is executed correctly |
| MTOMFeature myMtomFeature = getMtomFeature(); |
| if(myMtomFeature != null && myMtomFeature.isEnabled()) { |
| //On client, always use XOP encoding if MTOM is enabled |
| //On Server, mtomAcceptable and mtomRequest will be set - use XOP encoding |
| //if either request is XOP encoded (mtomRequest) or |
| //client accepts XOP encoding (mtomAcceptable) |
| if (getMtomAcceptable() == null && getMtomRequest() == null) { |
| return true; |
| } else { |
| if (getMtomAcceptable() != null && getMtomAcceptable() && getState().equals(State.ServerResponse)) { |
| return true; |
| } |
| if (getMtomRequest() != null && getMtomRequest() && getState().equals(State.ServerResponse)) { |
| return true; |
| } |
| if (getMtomRequest() != null && getMtomRequest() && getState().equals(State.ClientRequest)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean isMtomContentType() { |
| return (getInternalContentType() != null) && |
| (getInternalContentType().getContentType().contains("application/xop+xml")); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| public void addSatellite(@NotNull com.sun.xml.internal.ws.api.PropertySet satellite) { |
| super.addSatellite(satellite); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| public void addSatellite(@NotNull Class keyClass, @NotNull com.sun.xml.internal.ws.api.PropertySet satellite) { |
| super.addSatellite(keyClass, satellite); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| public void copySatelliteInto(@NotNull com.sun.xml.internal.ws.api.DistributedPropertySet r) { |
| super.copySatelliteInto(r); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| public void removeSatellite(com.sun.xml.internal.ws.api.PropertySet satellite) { |
| super.removeSatellite(satellite); |
| } |
| |
| /** |
| * This is propogated from SOAPBindingCodec and will affect isMtomAcceptable and isFastInfosetAcceptable |
| */ |
| private boolean isFastInfosetDisabled; |
| |
| public void setFastInfosetDisabled(boolean b) { |
| isFastInfosetDisabled = b; |
| } |
| } |
