org.apache.axis2.jaxws.client.dispatch.BaseDispatch Maven / Gradle / Ivy
/*
* 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.jaxws.client.dispatch;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.ServiceClient;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.jaxws.BindingProvider;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.client.async.AsyncResponse;
import org.apache.axis2.jaxws.core.InvocationContext;
import org.apache.axis2.jaxws.core.InvocationContextFactory;
import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.axis2.jaxws.core.controller.InvocationController;
import org.apache.axis2.jaxws.core.controller.InvocationControllerFactory;
import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.jaxws.description.EndpointInterfaceDescription;
import org.apache.axis2.jaxws.description.OperationDescription;
import org.apache.axis2.jaxws.i18n.Messages;
import org.apache.axis2.jaxws.marshaller.impl.alt.MethodMarshallerUtils;
import org.apache.axis2.jaxws.message.Message;
import org.apache.axis2.jaxws.registry.FactoryRegistry;
import org.apache.axis2.jaxws.spi.Binding;
import org.apache.axis2.jaxws.spi.Constants;
import org.apache.axis2.jaxws.spi.ServiceDelegate;
import org.apache.axis2.jaxws.spi.migrator.ApplicationContextMigratorUtil;
import org.apache.axis2.transport.http.HTTPConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.w3c.dom.Node;
import javax.xml.namespace.QName;
import javax.xml.soap.SOAPBody;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;
import javax.xml.transform.dom.DOMSource;
import javax.xml.ws.AsyncHandler;
import javax.xml.ws.ProtocolException;
import javax.xml.ws.Response;
import javax.xml.ws.Service.Mode;
import javax.xml.ws.WebServiceException;
import javax.xml.ws.WebServiceFeature;
import javax.xml.ws.http.HTTPBinding;
import javax.xml.ws.soap.SOAPBinding;
import java.io.IOException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
public abstract class BaseDispatch extends BindingProvider
implements javax.xml.ws.Dispatch {
private static Log log = LogFactory.getLog(BaseDispatch.class);
protected InvocationController ic;
protected ServiceClient serviceClient;
protected Mode mode;
protected BaseDispatch(ServiceDelegate svcDelgate,
EndpointDescription epDesc,
EndpointReference epr,
String addressingNamespace,
WebServiceFeature... features) {
super(svcDelgate, epDesc, epr, addressingNamespace, features);
InvocationControllerFactory icf = (InvocationControllerFactory) FactoryRegistry.getFactory(InvocationControllerFactory.class);
ic = icf.getInvocationController();
if (ic == null) {
throw new WebServiceException(Messages.getMessage("missingInvocationController"));
}
}
/**
* Take the input object and turn it into an OMElement so that it can be sent.
*
* @param value
* @return
*/
protected abstract Message createMessageFromValue(Object value);
/**
* Given a message, return the business object based on the requestor's required format (PAYLOAD
* vs. MESSAGE) and datatype.
*
* @param message
* @return
*/
protected abstract Object getValueFromMessage(Message message);
/**
* Creates an instance of the AsyncListener that is to be used for waiting for async responses.
*
* @return a configured AsyncListener instance
*/
protected abstract AsyncResponse createAsyncResponseListener();
/**
* Note to developer: When making a change or fix to this method, please consider
* all 5 Proxy/Dispatch "invoke" methods now available in JAX-WS. For Dispatch,
* these are:
* 1) Synchronous invoke()
* 2) invokeOneWay()
* 3) invokeAsynch (Future)
* 4) invokeAsynch (Callback)
*
* For Proxy:
* 5) invokeSEIMethod()
*
*/
public Object invoke(Object obj) throws WebServiceException {
// Catch all exceptions and rethrow an appropriate WebService Exception
try {
if (log.isDebugEnabled()) {
log.debug("Entered synchronous invocation: BaseDispatch.invoke()");
}
// Create the InvocationContext instance for this request/response flow.
InvocationContext invocationContext =
InvocationContextFactory.createInvocationContext(null);
invocationContext.setServiceClient(serviceClient);
// Create the MessageContext to hold the actual request message and its
// associated properties
MessageContext requestMsgCtx = new MessageContext();
requestMsgCtx.getAxisMessageContext().setProperty(BINDING_PROVIDER, this);
requestMsgCtx.setEndpointDescription(getEndpointDescription());
invocationContext.setRequestMessageContext(requestMsgCtx);
/*
* TODO: review: make sure the handlers are set on the InvocationContext
* This implementation of the JAXWS runtime does not use Endpoint, which
* would normally be the place to initialize and store the handler list.
* In lieu of that, we will have to intialize and store them on the
* InvocationContext. also see the InvocationContextFactory. On the client
* side, the binding is not yet set when we call into that factory, so the
* handler list doesn't get set on the InvocationContext object there. Thus
* we gotta do it here.
*/
// be sure to use whatever handlerresolver is registered on the Service
Binding binding = (Binding) getBinding();
invocationContext.setHandlers(binding.getHandlerChain());
initMessageContext(obj, requestMsgCtx);
// call common init method for all invoke* paths
preInvokeInit(invocationContext);
// Migrate the properties from the client request context bag to
// the request MessageContext.
ApplicationContextMigratorUtil.performMigrationToMessageContext(
Constants.APPLICATION_CONTEXT_MIGRATOR_LIST_ID,
getRequestContext(), requestMsgCtx);
// Perform the WebServiceFeature configuration requested by the user.
binding.configure(requestMsgCtx, this);
// Initializing the message context above will put the outbound message onto the messageContext
// Determine the operation if possible from the outbound message. If it can not be determined
// it will be set to null. In this case, an anonymous operation will be used. Note that determining
// the operation will mean deserializing the message. That means that any WebServiceFeatures must have
// been configured first so that any relevant configurations (such as MTOM) have been initialized prior to
// the message being deserialized. This is particularly true for Dispatch.
requestMsgCtx.setOperationDescription(getOperationDescriptionForDispatch(requestMsgCtx));
// Send the request using the InvocationController
ic.invoke(invocationContext);
MessageContext responseMsgCtx = invocationContext.getResponseMessageContext();
responseMsgCtx.setEndpointDescription(requestMsgCtx.getEndpointDescription());
// Migrate the properties from the response MessageContext back
// to the client response context bag.
ApplicationContextMigratorUtil.performMigrationFromMessageContext(
Constants.APPLICATION_CONTEXT_MIGRATOR_LIST_ID,
getResponseContext(), responseMsgCtx);
if (hasFaultResponse(responseMsgCtx)) {
WebServiceException wse = BaseDispatch.getFaultResponse(responseMsgCtx);
throw wse;
}
// Get the return object
Object returnObj = null;
try {
Message responseMsg = responseMsgCtx.getMessage();
returnObj = getValueFromMessage(responseMsg);
}
finally {
// Free the incoming input stream
try {
responseMsgCtx.freeInputStream();
}
catch (Throwable t) {
throw ExceptionFactory.makeWebServiceException(t);
}
}
//Check to see if we need to maintain session state
checkMaintainSessionState(requestMsgCtx, invocationContext);
if (log.isDebugEnabled()) {
log.debug("Synchronous invocation completed: BaseDispatch.invoke()");
}
return returnObj;
} catch (WebServiceException e) {
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invoke(): Synchronous invocation failed, "
+ "caught a WebServiceException: ", e);
}
throw e;
} catch (Exception e) {
// All exceptions are caught and rethrown as a WebServiceException
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invoke(): Synchronous invocation failed, caught an Exception, " +
"wrapping into a WebServiceException. Exception caught: ", e);
}
throw ExceptionFactory.makeWebServiceException(e);
}
}
/**
* Given a JAXWS Message Context which contains an outbound service-requester Message for a Dispatch client,
* determine the OperationDescription for the operation contained in that Dispatch message.
*
* Note that operation resolution can be disabled by a property setting.
* @see org.apache.axis2.jaxws.Constants.DISPATCH_CLIENT_OUTBOUND_RESOLUTION
*
* @param requestMessageCtx JAXWS Message Context containing the outbound Dispatch message
* @return the OperationDescription corresponding to the operation contained in the Dispatch message, or null
* if it can not be determined or if dispatch operation resolution is disabled via a property.
*/
private OperationDescription getOperationDescriptionForDispatch(MessageContext requestMessageCtx) {
OperationDescription operationDesc = null;
if (dispatchOperationResolutionEnabled()) {
EndpointInterfaceDescription endpointInterfaceDesc = getEndpointDescription().getEndpointInterfaceDescription();
// The SEI interface could be null (for example if there was no SEI and all the ports were dynamically added).
// If there is an SEI, then try to determine the operation for the outbound dispatch message.
if (endpointInterfaceDesc != null) {
QName bodyElementQName = getBodyElementQNameFromDispatchMessage(requestMessageCtx);
operationDesc = determineOperationDescFromBodyElementQName(endpointInterfaceDesc, bodyElementQName);
}
}
return operationDesc;
}
/**
* Returns the OperationDescription corresponding to the bodyElementQName passed in. What that body element corresponds to
* depends on the type of the message:
* - For Doc/Lit/Wrapped, the body element is the operation name
* - For Doc/Lit/Bare, the body element is the element name contained in the wsdl:message wsdl:part
* - For RPC, the body element is effectively the operation name.
*
* @param endpointInterfaceDesc The interface (i.e. SEI) on which to search for the operation
* @param bodyElementQName the QName of the first body element for which to find the operation
*
* @return The OperationDescription corresponding to the body element QName or null if one can not be found.
*/
private OperationDescription determineOperationDescFromBodyElementQName(EndpointInterfaceDescription endpointInterfaceDesc,
QName bodyElementQName) {
OperationDescription operationDesc = null;
// If there's no bodyElementQName for us to work with, there's nothing more we can do.
if (bodyElementQName != null) {
// This logic mimics the code in SOAPMessageBodyBasedOperationDispatcher.findOperation. We will look for
// the AxisOperation corresponding to the body element name. Note that we are searching for the AxisOperation instead
// of searching through the OperationDescriptions so that we can use the getOperationByMessageElementQName
// for the Doc/Lit/Bare case. Once we have the AxisOperation, we'll use that to find the Operation Description.
AxisService axisService = endpointInterfaceDesc.getEndpointDescription().getAxisService();
AxisOperation axisOperation = null;
// Doc/Lit/Wrapped and RPC, the operation name is the first body element qname
axisOperation = axisService.getOperation(new QName(bodyElementQName.getLocalPart()));
if (axisOperation == null) {
// Doc/Lit/Bare, the first body element qname is the element name contained in the wsdl:message part
axisOperation = axisService.getOperationByMessageElementQName(bodyElementQName);
}
if (axisOperation == null) {
// Not sure why we wouldn't have found the operation above using just the localPart rather than the full QName used here,
// but this is what SOAPMessageBodyBasedOperationDispatcher.findOperation does.
axisOperation = axisService.getOperation(bodyElementQName);
}
// If we found an axis operation, then find the operation description that corresponds to it
if (axisOperation != null) {
OperationDescription allOpDescs[] = endpointInterfaceDesc.getDispatchableOperations();
for (OperationDescription checkOpDesc : allOpDescs ) {
AxisOperation checkAxisOperation = checkOpDesc.getAxisOperation();
if (checkAxisOperation == axisOperation) {
operationDesc = checkOpDesc;
break;
}
}
}
}
return operationDesc;
}
/**
* Answer if operation resolution on outbound messages for dispatch clients should be done. The default value
* is TRUE, enabling operation resolution. Resolution can be disabled via a property on the AxisConfiguration
* or on the RequestContext.
*
* Operation resolution is also disabled if a non-null value is specified on the request context for the Action
*
* @see org.apache.axis2.jaxws.Constants.DISPATCH_CLIENT_OUTBOUND_RESOLUTION
* @see javax.xml.ws.BindingProvider.SOAPACTION_USE_PROPERTY
* @see javax.xml.ws.BindingProvider.SOAPACTION_URI_PROPERTY
*
* @return true if operation resolution should be performed on outbound
*/
private boolean dispatchOperationResolutionEnabled() {
boolean resolutionEnabled = true;
// See if any properties disabled operation resolution
// Check for System property setting
String flagValue = getProperty(org.apache.axis2.jaxws.Constants.DISPATCH_CLIENT_OUTBOUND_RESOLUTION);
// If no System property was set, see if one was set on this request context.
if (flagValue == null) {
flagValue = (String) getRequestContext().get(org.apache.axis2.jaxws.Constants.DISPATCH_CLIENT_OUTBOUND_RESOLUTION);
}
// If any property was set, check the value.
if (flagValue != null) {
if ("false".equalsIgnoreCase(flagValue)) {
resolutionEnabled = false;
} else if ("true".equalsIgnoreCase(flagValue)) {
resolutionEnabled = true;
}
}
// If a property didn't disable resolution, then see if a URI value was specified.
// If so, we'll use that later and there's no need to do operation resolution.
if (resolutionEnabled) {
Boolean useSoapAction = (Boolean) getRequestContext().get(SOAPACTION_USE_PROPERTY);
if (useSoapAction != null && useSoapAction.booleanValue()) {
String soapAction = (String) getRequestContext().get(SOAPACTION_URI_PROPERTY);
if (soapAction != null) {
resolutionEnabled = false;
}
}
}
return resolutionEnabled;
}
/**
* Retrieve the specified property from the AxisConfiguration.
*
* @param key The property to retrieve from the AxisConfiguration
* @return the value associated with the property or null if the property did not exist on the configuration.
*/
private String getProperty(String key) {
String propertyValue = null;
AxisConfiguration axisConfig = serviceDelegate.getServiceDescription().getAxisConfigContext().getAxisConfiguration();
Parameter parameter = axisConfig.getParameter(key);
if (parameter != null) {
propertyValue = (String) parameter.getValue();
}
return propertyValue;
}
/**
* Given a JAXWS Message Context which contains an outbound service-requester Message for a Dispatch client,
* determine the QName of the first body element contained in that message.
*
* @param requestMessageCtx requestMessageCtx JAXWS Message Context containing the outbound Dispatch message
* @return the QName of the first body element contained in the outbound Dispatch message, or null if it
* can not be determined.
*/
QName getBodyElementQNameFromDispatchMessage(MessageContext requestMessageCtx) {
QName bodyElementQName = null;
Message dispatchMessage = requestMessageCtx.getMessage();
SOAPMessage soapMessage = dispatchMessage.getAsSOAPMessage();
try {
SOAPBody soapBody = soapMessage.getSOAPBody();
Node firstElement = soapBody.getFirstChild();
// A Doc/Lit/Bare message may not have a firsElement. The soap:Body element may be empty if there
// are no arguments to the operation.
if (firstElement != null) {
String ns = firstElement.getNamespaceURI();
String lp= firstElement.getLocalName();
// A Doc/Lit/Bare message may not have a localPart on the element. That can happen if the first element
// is the argument value and there is no wrapper element surrounding it.
if (lp != null) {
bodyElementQName = new QName(ns, lp);
}
}
} catch (SOAPException e) {
if (log.isDebugEnabled()) {
log.debug("Unabled to get the first body element from the outbound dispatch message", e);
}
}
return bodyElementQName;
}
protected void initMessageContext(Object obj, MessageContext requestMsgCtx) {
Message requestMsg = createRequestMessage(obj);
setupMessageProperties(requestMsg);
requestMsgCtx.setMessage(requestMsg);
// handle HTTP_REQUEST_METHOD property
String method = (String)requestContext.get(javax.xml.ws.handler.MessageContext.HTTP_REQUEST_METHOD);
if (method != null) {
requestMsgCtx.setProperty(org.apache.axis2.Constants.Configuration.HTTP_METHOD, method);
}
}
/**
* Note to developer: When making a change or fix to this method, please consider
* all 5 Proxy/Dispatch "invoke" methods now available in JAX-WS. For Dispatch,
* these are:
* 1) Synchronous invoke()
* 2) invokeOneWay()
* 3) invokeAsynch (Future)
* 4) invokeAsynch (Callback)
*
* For Proxy:
* 5) invokeSEIMethod()
*
*/
public void invokeOneWay(Object obj) throws WebServiceException {
// All exceptions are caught and rethrown as a WebServiceException
MessageContext requestMsgCtx = null;
try {
if (log.isDebugEnabled()) {
log.debug("Entered one-way invocation: BaseDispatch.invokeOneWay()");
}
// Create the InvocationContext instance for this request/response flow.
InvocationContext invocationContext =
InvocationContextFactory.createInvocationContext(null);
invocationContext.setServiceClient(serviceClient);
// Create the MessageContext to hold the actual request message and its
// associated properties
requestMsgCtx = new MessageContext();
requestMsgCtx.getAxisMessageContext().setProperty(BINDING_PROVIDER, this);
requestMsgCtx.setEndpointDescription(getEndpointDescription());
invocationContext.setRequestMessageContext(requestMsgCtx);
/*
* TODO: review: make sure the handlers are set on the InvocationContext
* This implementation of the JAXWS runtime does not use Endpoint, which
* would normally be the place to initialize and store the handler list.
* In lieu of that, we will have to intialize and store them on the
* InvocationContext. also see the InvocationContextFactory. On the client
* side, the binding is not yet set when we call into that factory, so the
* handler list doesn't get set on the InvocationContext object there. Thus
* we gotta do it here.
*/
// be sure to use whatever handlerresolver is registered on the Service
Binding binding = (Binding) getBinding();
invocationContext.setHandlers(binding.getHandlerChain());
initMessageContext(obj, requestMsgCtx);
/*
* if SESSION_MAINTAIN_PROPERTY is true, and the client app has explicitly set a HEADER_COOKIE on the request context, assume the client
* app is expecting the HEADER_COOKIE to be the session id. If we were establishing a new session, no cookie would be sent, and the
* server would reply with a "Set-Cookie" header, which is copied as a "Cookie"-keyed property to the service context during response.
* In this case, if we succeed in using an existing server session, no "Set-Cookie" header will be returned, and therefore no
* "Cookie"-keyed property would be set on the service context. So, let's copy our request context HEADER_COOKIE key to the service
* context now to prevent the "no cookie" exception in BindingProvider.setupSessionContext. It is possible the server does not support
* sessions, in which case no error occurs, but the client app would assume it is participating in a session.
*/
if ((requestContext.containsKey(BindingProvider.SESSION_MAINTAIN_PROPERTY)) && ((Boolean)requestContext.get(BindingProvider.SESSION_MAINTAIN_PROPERTY))) {
if ((requestContext.containsKey(HTTPConstants.HEADER_COOKIE)) && (requestContext.get(HTTPConstants.HEADER_COOKIE) != null)) {
if (invocationContext.getServiceClient().getServiceContext().getProperty(HTTPConstants.HEADER_COOKIE) == null) {
invocationContext.getServiceClient().getServiceContext().setProperty(HTTPConstants.HEADER_COOKIE, requestContext.get(HTTPConstants.HEADER_COOKIE));
if (log.isDebugEnabled()) {
log.debug("Client-app defined Cookie property (assume to be session cookie) on request context copied to service context." +
" Caution: server may or may not support sessions, but client app will not be informed when not supported.");
}
}
}
}
// call common init method for all invoke* paths
preInvokeInit(invocationContext);
// Migrate the properties from the client request context bag to
// the request MessageContext.
ApplicationContextMigratorUtil.performMigrationToMessageContext(
Constants.APPLICATION_CONTEXT_MIGRATOR_LIST_ID,
getRequestContext(), requestMsgCtx);
// Perform the WebServiceFeature configuration requested by the user.
binding.configure(requestMsgCtx, this);
// Initializing the message context above will put the outbound message onto the messageContext
// Determine the operation if possible from the outbound message. If it can not be determined
// it will be set to null. In this case, an anonymous operation will be used. Note that determining
// the operation will mean deserializing the message. That means that any WebServiceFeatures must have
// been configured first so that any relevant configurations (such as MTOM) have been initialized prior to
// the message being deserialized. This is particularly true for Dispatch.
requestMsgCtx.setOperationDescription(getOperationDescriptionForDispatch(requestMsgCtx));
// Send the request using the InvocationController
ic.invokeOneWay(invocationContext);
//Check to see if we need to maintain session state
checkMaintainSessionState(requestMsgCtx, invocationContext);
if (log.isDebugEnabled()) {
log.debug("One-way invocation completed: BaseDispatch.invokeOneWay()");
}
return;
} catch (WebServiceException e) {
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invokeOneWay(): One-way invocation failed, " +
"caught a WebServiceException: ", e);
}
throw e;
} catch (Exception e) {
// All exceptions are caught and rethrown as a WebServiceException
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invokeOneWay(): One-way invocation failed, " +
"caught an Exception, wrapping into a WebServicesException. " +
" Exception caught: ", e);
}
throw ExceptionFactory.makeWebServiceException(e);
} finally {
// In all other cases we rely on freeInputStream to perform the clean up. Since we don't expect
// a response in the invokeOneWay case, we need to perform call TransportSender#cleanup explicitly
try {
if (requestMsgCtx != null && requestMsgCtx.getAxisMessageContext() != null) {
org.apache.axis2.context.MessageContext axisMsgCtx = requestMsgCtx.getAxisMessageContext();
if (axisMsgCtx.getTransportOut() != null && axisMsgCtx.getTransportOut().getSender() != null) {
axisMsgCtx.getTransportOut().getSender().cleanup(axisMsgCtx);
}
}
} catch (Exception ignore) {
}
}
}
/**
* Note to developer: When making a change or fix to this method, please consider
* all 5 Proxy/Dispatch "invoke" methods now available in JAX-WS. For Dispatch,
* these are:
* 1) Synchronous invoke()
* 2) invokeOneWay()
* 3) invokeAsynch (Future)
* 4) invokeAsynch (Callback)
*
* For Proxy:
* 5) invokeSEIMethod()
*
*/
public Future invokeAsync(Object obj, AsyncHandler asynchandler) throws WebServiceException {
// All exceptions are caught and rethrown as a WebServiceException
try {
if (log.isDebugEnabled()) {
log.debug("Entered asynchronous (callback) invocation: BaseDispatch.invokeAsync()");
}
// Create the InvocationContext instance for this request/response flow.
InvocationContext invocationContext =
InvocationContextFactory.createInvocationContext(null);
invocationContext.setServiceClient(serviceClient);
// Create the MessageContext to hold the actual request message and its
// associated properties
MessageContext requestMsgCtx = new MessageContext();
requestMsgCtx.getAxisMessageContext().setProperty(BINDING_PROVIDER, this);
requestMsgCtx.setEndpointDescription(getEndpointDescription());
invocationContext.setRequestMessageContext(requestMsgCtx);
/*
* TODO: review: make sure the handlers are set on the InvocationContext
* This implementation of the JAXWS runtime does not use Endpoint, which
* would normally be the place to initialize and store the handler list.
* In lieu of that, we will have to intialize and store them on the
* InvocationContext. also see the InvocationContextFactory. On the client
* side, the binding is not yet set when we call into that factory, so the
* handler list doesn't get set on the InvocationContext object there. Thus
* we gotta do it here.
*/
// be sure to use whatever handlerresolver is registered on the Service
Binding binding = (Binding) getBinding();
invocationContext.setHandlers(binding.getHandlerChain());
initMessageContext(obj, requestMsgCtx);
/*
* if SESSION_MAINTAIN_PROPERTY is true, and the client app has explicitly set a HEADER_COOKIE on the request context, assume the client
* app is expecting the HEADER_COOKIE to be the session id. If we were establishing a new session, no cookie would be sent, and the
* server would reply with a "Set-Cookie" header, which is copied as a "Cookie"-keyed property to the service context during response.
* In this case, if we succeed in using an existing server session, no "Set-Cookie" header will be returned, and therefore no
* "Cookie"-keyed property would be set on the service context. So, let's copy our request context HEADER_COOKIE key to the service
* context now to prevent the "no cookie" exception in BindingProvider.setupSessionContext. It is possible the server does not support
* sessions, in which case no error occurs, but the client app would assume it is participating in a session.
*/
if ((requestContext.containsKey(BindingProvider.SESSION_MAINTAIN_PROPERTY)) && ((Boolean)requestContext.get(BindingProvider.SESSION_MAINTAIN_PROPERTY))) {
if ((requestContext.containsKey(HTTPConstants.HEADER_COOKIE)) && (requestContext.get(HTTPConstants.HEADER_COOKIE) != null)) {
if (invocationContext.getServiceClient().getServiceContext().getProperty(HTTPConstants.HEADER_COOKIE) == null) {
invocationContext.getServiceClient().getServiceContext().setProperty(HTTPConstants.HEADER_COOKIE, requestContext.get(HTTPConstants.HEADER_COOKIE));
if (log.isDebugEnabled()) {
log.debug("Client-app defined Cookie property (assume to be session cookie) on request context copied to service context." +
" Caution: server may or may not support sessions, but client app will not be informed when not supported.");
}
}
}
}
// call common init method for all invoke* paths
preInvokeInit(invocationContext);
// Migrate the properties from the client request context bag to
// the request MessageContext.
ApplicationContextMigratorUtil.performMigrationToMessageContext(
Constants.APPLICATION_CONTEXT_MIGRATOR_LIST_ID,
getRequestContext(), requestMsgCtx);
// Perform the WebServiceFeature configuration requested by the user.
binding.configure(requestMsgCtx, this);
// Initializing the message context above will put the outbound message onto the messageContext
// Determine the operation if possible from the outbound message. If it can not be determined
// it will be set to null. In this case, an anonymous operation will be used. Note that determining
// the operation will mean deserializing the message. That means that any WebServiceFeatures must have
// been configured first so that any relevant configurations (such as MTOM) have been initialized prior to
// the message being deserialized. This is particularly true for Dispatch.
requestMsgCtx.setOperationDescription(getOperationDescriptionForDispatch(requestMsgCtx));
// Setup the Executor that will be used to drive async responses back to
// the client.
// FIXME: We shouldn't be getting this from the ServiceDelegate, rather each
// Dispatch object should have it's own.
Executor e = serviceDelegate.getExecutor();
invocationContext.setExecutor(e);
// Create the AsyncListener that is to be used by the InvocationController.
AsyncResponse listener = createAsyncResponseListener();
invocationContext.setAsyncResponseListener(listener);
// Send the request using the InvocationController
Future asyncResponse = ic.invokeAsync(invocationContext, asynchandler);
//Check to see if we need to maintain session state
checkMaintainSessionState(requestMsgCtx, invocationContext);
if (log.isDebugEnabled()) {
log.debug("Asynchronous (callback) invocation sent: BaseDispatch.invokeAsync()");
}
return asyncResponse;
} catch (WebServiceException e) {
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invokeAsync() [Callback]: Asynchronous invocation failed, " +
"caught a WebServiceException: ", e);
}
throw e;
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invokeAsync() [Callback]: Asynchronous invocation failed, " +
"caught an Exception, wrapping into a WebServiceException. Exception caught: ", e);
}
// All exceptions are caught and rethrown as a WebServiceException
throw ExceptionFactory.makeWebServiceException(e);
}
}
/**
* Note to developer: When making a change or fix to this method, please consider
* all 5 Proxy/Dispatch "invoke" methods now available in JAX-WS. For Dispatch,
* these are:
* 1) Synchronous invoke()
* 2) invokeOneWay()
* 3) invokeAsynch (Future)
* 4) invokeAsynch (Callback)
*
* For Proxy:
* 5) invokeSEIMethod()
*
*/
public Response invokeAsync(Object obj) throws WebServiceException {
// All exceptions are caught and rethrown as a WebServiceException
try {
if (log.isDebugEnabled()) {
log.debug("Entered asynchronous (polling) invocation: BaseDispatch.invokeAsync()");
}
// Create the InvocationContext instance for this request/response flow.
InvocationContext invocationContext =
InvocationContextFactory.createInvocationContext(null);
invocationContext.setServiceClient(serviceClient);
// Create the MessageContext to hold the actual request message and its
// associated properties
MessageContext requestMsgCtx = new MessageContext();
requestMsgCtx.getAxisMessageContext().setProperty(BINDING_PROVIDER, this);
requestMsgCtx.setEndpointDescription(getEndpointDescription());
invocationContext.setRequestMessageContext(requestMsgCtx);
/*
* TODO: review: make sure the handlers are set on the InvocationContext
* This implementation of the JAXWS runtime does not use Endpoint, which
* would normally be the place to initialize and store the handler list.
* In lieu of that, we will have to intialize and store them on the
* InvocationContext. also see the InvocationContextFactory. On the client
* side, the binding is not yet set when we call into that factory, so the
* handler list doesn't get set on the InvocationContext object there. Thus
* we gotta do it here.
*/
// be sure to use whatever handlerresolver is registered on the Service
Binding binding = (Binding) getBinding();
invocationContext.setHandlers(binding.getHandlerChain());
initMessageContext(obj, requestMsgCtx);
/*
* if SESSION_MAINTAIN_PROPERTY is true, and the client app has explicitly set a HEADER_COOKIE on the request context, assume the client
* app is expecting the HEADER_COOKIE to be the session id. If we were establishing a new session, no cookie would be sent, and the
* server would reply with a "Set-Cookie" header, which is copied as a "Cookie"-keyed property to the service context during response.
* In this case, if we succeed in using an existing server session, no "Set-Cookie" header will be returned, and therefore no
* "Cookie"-keyed property would be set on the service context. So, let's copy our request context HEADER_COOKIE key to the service
* context now to prevent the "no cookie" exception in BindingProvider.setupSessionContext. It is possible the server does not support
* sessions, in which case no error occurs, but the client app would assume it is participating in a session.
*/
if ((requestContext.containsKey(BindingProvider.SESSION_MAINTAIN_PROPERTY)) && ((Boolean)requestContext.get(BindingProvider.SESSION_MAINTAIN_PROPERTY))) {
if ((requestContext.containsKey(HTTPConstants.HEADER_COOKIE)) && (requestContext.get(HTTPConstants.HEADER_COOKIE) != null)) {
if (invocationContext.getServiceClient().getServiceContext().getProperty(HTTPConstants.HEADER_COOKIE) == null) {
invocationContext.getServiceClient().getServiceContext().setProperty(HTTPConstants.HEADER_COOKIE, requestContext.get(HTTPConstants.HEADER_COOKIE));
if (log.isDebugEnabled()) {
log.debug("Client-app defined Cookie property (assume to be session cookie) on request context copied to service context." +
" Caution: server may or may not support sessions, but client app will not be informed when not supported.");
}
}
}
}
// call common init method for all invoke* paths
preInvokeInit(invocationContext);
// Migrate the properties from the client request context bag to
// the request MessageContext.
ApplicationContextMigratorUtil.performMigrationToMessageContext(
Constants.APPLICATION_CONTEXT_MIGRATOR_LIST_ID,
getRequestContext(), requestMsgCtx);
// Perform the WebServiceFeature configuration requested by the user.
binding.configure(requestMsgCtx, this);
// Initializing the message context above will put the outbound message onto the messageContext
// Determine the operation if possible from the outbound message. If it can not be determined
// it will be set to null. In this case, an anonymous operation will be used. Note that determining
// the operation will mean deserializing the message. That means that any WebServiceFeatures must have
// been configured first so that any relevant configurations (such as MTOM) have been initialized prior to
// the message being deserialized. This is particularly true for Dispatch.
requestMsgCtx.setOperationDescription(getOperationDescriptionForDispatch(requestMsgCtx));
// Setup the Executor that will be used to drive async responses back to
// the client.
// FIXME: We shouldn't be getting this from the ServiceDelegate, rather each
// Dispatch object should have it's own.
Executor e = serviceDelegate.getExecutor();
invocationContext.setExecutor(e);
// Create the AsyncListener that is to be used by the InvocationController.
AsyncResponse listener = createAsyncResponseListener();
invocationContext.setAsyncResponseListener(listener);
// Send the request using the InvocationController
Response asyncResponse = ic.invokeAsync(invocationContext);
//Check to see if we need to maintain session state
checkMaintainSessionState(requestMsgCtx, invocationContext);
if (log.isDebugEnabled()) {
log.debug("Asynchronous (polling) invocation sent: BaseDispatch.invokeAsync()");
}
return asyncResponse;
} catch (WebServiceException e) {
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invokeAsync() [Polling]: Asynchronous invocation failed, " +
"caught a WebServiceException: ", e);
}
throw e;
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("BaseDispatch.invokeAsync() [Polling]: Asynchronous invocation failed, " +
"caught an Exception, wrapping into a WebServiceException. Exception caught: ",e);
}
// All exceptions are caught and rethrown as a WebServiceException
throw ExceptionFactory.makeWebServiceException(e);
}
}
public void setServiceClient(ServiceClient sc) {
serviceClient = sc;
}
public Mode getMode() {
return mode;
}
public void setMode(Mode m) {
mode = m;
}
/**
* Returns the fault that is contained within the MessageContext for an invocation. If no fault
* exists, null will be returned.
*
* @param msgCtx
* @return
*/
public static WebServiceException getFaultResponse(MessageContext msgCtx) {
try {
Message msg = msgCtx.getMessage();
if (msg != null && msg.isFault()) {
//XMLFault fault = msg.getXMLFault();
// 4.3.2 conformance bullet 1 requires a ProtocolException here
ProtocolException pe =
MethodMarshallerUtils.createSystemException(msg.getXMLFault(), msg);
if (msgCtx.getLocalException() != null) {
// If a local exception occured, set it as the initial cause of the
// exception that will be returned
ExceptionFactory.setInitialCause(pe, msgCtx.getLocalException());
}
return pe;
} else if (msgCtx.getLocalException() != null) {
// use the factory, it'll throw the right thing:
return ExceptionFactory.makeWebServiceException(msgCtx.getLocalException());
}
} finally {
// Free the incoming input stream
try {
msgCtx.freeInputStream();
} catch (IOException ioe) {
return ExceptionFactory.makeWebServiceException(ioe);
}
}
return null;
}
/**
* Returns a boolean indicating whether or not the MessageContext contained a fault.
*
* @param msgCtx
* @return
*/
public boolean hasFaultResponse(MessageContext msgCtx) {
if(!msgCtx.getAxisMessageContext().getOptions().isExceptionToBeThrownOnSOAPFault()){
if(log.isDebugEnabled()){
log.debug("msgCtx.Options.isExceptionToBeThrownOnSOAPFault set to false; Exception will not be thrown on fault");
}
return false;
}
if (msgCtx.getMessage() != null && msgCtx.getMessage().isFault())
return true;
else if (msgCtx.getLocalException() != null)
return true;
else
return false;
}
/*
* Configure any properties that will be needed on the Message
*/
private void setupMessageProperties(Message msg) {
// If the user has enabled MTOM on the SOAPBinding, we need
// to make sure that gets pushed to the Message object.
Binding binding = (Binding) getBinding();
if (binding != null && binding instanceof SOAPBinding) {
SOAPBinding soapBinding = (SOAPBinding)binding;
if (soapBinding.isMTOMEnabled())
msg.setMTOMEnabled(true);
}
}
/*
* Checks to see if the parameter for the invocation is valid
* given the scenario that the client is operating in. There are
* some cases when nulls are allowed and others where it is
* an error.
*/
private boolean isValidInvocationParam(Object object) {
String bindingId = endpointDesc.getClientBindingID();
// If no bindingId was found, use the default.
if (bindingId == null) {
bindingId = SOAPBinding.SOAP11HTTP_BINDING;
}
// If it's not an HTTP_BINDING, then we can allow for null params,
// but only in PAYLOAD mode per JAX-WS Section 4.3.2.
if (!bindingId.equals(HTTPBinding.HTTP_BINDING)) {
if (mode.equals(Mode.MESSAGE) && object == null) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("dispatchNullParamMessageMode"));
}
} else {
// In all cases (PAYLOAD and MESSAGE) we must throw a WebServiceException
// if the parameter is null and request method is POST or PUT.
if (object == null && isPOSTorPUTRequest()) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("dispatchNullParamHttpBinding"));
}
}
if (object instanceof DOMSource) {
DOMSource ds = (DOMSource)object;
if (ds.getNode() == null && ds.getSystemId() == null) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("dispatchBadDOMSource"));
}
}
// If we've gotten this far, then all is good.
return true;
}
private boolean isPOSTorPUTRequest() {
String method = (String)this.requestContext.get(javax.xml.ws.handler.MessageContext.HTTP_REQUEST_METHOD);
// if HTTP_REQUEST_METHOD is not specified, assume it is a POST method
return (method == null ||
HTTPConstants.HEADER_POST.equalsIgnoreCase(method) ||
HTTPConstants.HEADER_PUT.equalsIgnoreCase(method));
}
private Message createRequestMessage(Object obj) throws WebServiceException {
// Check to see if the object is a valid invocation parameter.
// Then create the message from the object.
// If an exception occurs, it is local to the client and therefore is a
// WebServiceException (and not ProtocolExceptions).
// This code complies with JAX-WS 2.0 sections 4.3.2, 4.3.3 and 4.3.4.
if (!isValidInvocationParam(obj)) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("dispatchInvalidParam"));
}
Message requestMsg = null;
try {
requestMsg = createMessageFromValue(obj);
} catch (Throwable t) {
// The webservice exception wraps the thrown exception.
throw ExceptionFactory.makeWebServiceException(t);
}
return requestMsg;
}
private void preInvokeInit(InvocationContext requestIC) {
/*
* if SESSION_MAINTAIN_PROPERTY is true, and the client app has explicitly set a HEADER_COOKIE on the request context, assume the client
* app is expecting the HEADER_COOKIE to be the session id. If we were establishing a new session, no cookie would be sent, and the
* server would reply with a "Set-Cookie" header, which is copied as a "Cookie"-keyed property to the service context during response.
* In this case, if we succeed in using an existing server session, no "Set-Cookie" header will be returned, and therefore no
* "Cookie"-keyed property would be set on the service context. So, let's copy our request context HEADER_COOKIE key to the service
* context now to prevent the "no cookie" exception in BindingProvider.setupSessionContext. It is possible the server does not support
* sessions, in which case no error occurs, but the client app would assume it is participating in a session.
*/
if ((requestContext.containsKey(BindingProvider.SESSION_MAINTAIN_PROPERTY)) && ((Boolean)requestContext.get(BindingProvider.SESSION_MAINTAIN_PROPERTY))) {
if ((requestContext.containsKey(HTTPConstants.HEADER_COOKIE)) && (requestContext.get(HTTPConstants.HEADER_COOKIE) != null)) {
if (requestIC.getServiceClient().getServiceContext().getProperty(HTTPConstants.HEADER_COOKIE) == null) {
requestIC.getServiceClient().getServiceContext().setProperty(HTTPConstants.HEADER_COOKIE, requestContext.get(HTTPConstants.HEADER_COOKIE));
if (log.isDebugEnabled()) {
log.debug("Client-app defined Cookie property (assume to be session cookie) on request context copied to service context." +
" Caution: server may or may not support sessions, but client app will not be informed when not supported.");
}
}
}
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy