/*
* 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.server.dispatcher;
import org.apache.axis2.Constants;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.context.utils.ContextUtils;
import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.axis2.jaxws.core.util.MessageContextUtils;
import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.jaxws.i18n.Messages;
import org.apache.axis2.jaxws.marshaller.impl.alt.MethodMarshallerUtils;
import org.apache.axis2.jaxws.message.Block;
import org.apache.axis2.jaxws.message.Message;
import org.apache.axis2.jaxws.message.Protocol;
import org.apache.axis2.jaxws.message.XMLFault;
import org.apache.axis2.jaxws.message.databinding.OMBlock;
import org.apache.axis2.jaxws.message.factory.BlockFactory;
import org.apache.axis2.jaxws.message.factory.DataSourceBlockFactory;
import org.apache.axis2.jaxws.message.factory.MessageFactory;
import org.apache.axis2.jaxws.message.factory.OMBlockFactory;
import org.apache.axis2.jaxws.message.factory.SOAPEnvelopeBlockFactory;
import org.apache.axis2.jaxws.message.factory.SourceBlockFactory;
import org.apache.axis2.jaxws.message.factory.XMLStringBlockFactory;
import org.apache.axis2.jaxws.message.util.XMLFaultUtils;
import org.apache.axis2.jaxws.registry.FactoryRegistry;
import org.apache.axis2.jaxws.server.EndpointCallback;
import org.apache.axis2.jaxws.server.EndpointInvocationContext;
import org.apache.axis2.jaxws.server.InvocationHelper;
import org.apache.axis2.jaxws.server.ServerConstants;
import org.apache.axis2.jaxws.utility.ClassUtils;
import org.apache.axis2.jaxws.utility.DataSourceFormatter;
import org.apache.axis2.jaxws.utility.ExecutorFactory;
import org.apache.axis2.jaxws.utility.SingleThreadedExecutor;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.soap.SOAPEnvelope;
import javax.activation.DataSource;
import javax.xml.soap.SOAPMessage;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.Source;
import javax.xml.ws.Provider;
import javax.xml.ws.Service;
import javax.xml.ws.WebServiceException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;
/**
* The ProviderDispatcher is used to invoke instances of a target endpoint that implement the {@link
* javax.xml.ws.Provider} interface.
* <p/>
* The Provider<T> is a generic class, with certain restrictions on the parameterized type T. This
* implementation supports the following types:
* <p/>
* java.lang.String javax.activation.DataSource javax.xml.soap.SOAPMessage
* javax.xml.transform.Source
*/
public class ProviderDispatcher extends JavaDispatcher {
private static Log log = LogFactory.getLog(ProviderDispatcher.class);
private BlockFactory _blockFactory = null; // Cache the block factory
private Class _providerType = null; // Cache the provider type
private Provider providerInstance = null;
private Message message = null;
private EndpointDescription endpointDesc = null;
/**
* Constructor
*
* @param _class
* @param serviceInstance
*/
public ProviderDispatcher(Class _class, Object serviceInstance) {
super(_class, serviceInstance);
}
/* (non-Javadoc)
* @see org.apache.axis2.jaxws.server.EndpointDispatcher#execute()
*/
public MessageContext invoke(MessageContext request) throws Exception {
if (log.isDebugEnabled()) {
log.debug("Preparing to invoke javax.xml.ws.Provider based endpoint");
log.debug("Invocation pattern: two way, sync");
}
initialize(request);
providerInstance = getProviderInstance();
Object param = createRequestParameters(request);
if (log.isDebugEnabled()) {
Class providerType = getProviderType();
final Object input = providerType.cast(param);
log.debug("Invoking Provider<" + providerType.getName() + ">");
if (input != null) {
log.debug("Parameter type: " + input.getClass().getName());
}
else {
log.debug("Parameter is NULL");
}
}
// Invoke the actual Provider.invoke() method
boolean faultThrown = false;
Throwable fault = null;
Object[] input = new Object[] {param};
Object responseParamValue = null;
Method target = null;
try {
target = getJavaMethod();
responseParamValue = invokeTargetOperation(target, input);
} catch (Throwable e) {
fault = ClassUtils.getRootCause(e);
faultThrown = true;
}
// Create the response MessageContext
MessageContext responseMsgCtx = null;
if (faultThrown) {
// If a fault was thrown, we need to create a slightly different
// MessageContext, than in the response path.
responseMsgCtx = createFaultResponse(request, fault);
setExceptionProperties(responseMsgCtx, target, fault);
} else {
responseMsgCtx = createResponse(request, input, responseParamValue);
}
return responseMsgCtx;
}
public void invokeOneWay(MessageContext request) {
if (log.isDebugEnabled()) {
log.debug("Preparing to invoke javax.xml.ws.Provider based endpoint");
log.debug("Invocation pattern: one way");
}
initialize(request);
providerInstance = getProviderInstance();
Object param = createRequestParameters(request);
if (log.isDebugEnabled()) {
Class providerType = getProviderType();
final Object input = providerType.cast(param);
log.debug("Invoking Provider<" + providerType.getName() + ">");
if (input != null) {
log.debug("Parameter type: " + input.getClass().getName());
}
else {
log.debug("Parameter is NULL");
}
}
ExecutorFactory ef = (ExecutorFactory) FactoryRegistry.getFactory(ExecutorFactory.class);
Executor executor = ef.getExecutorInstance(ExecutorFactory.SERVER_EXECUTOR);
// If the property has been set to disable thread switching, then we can
// do so by using a SingleThreadedExecutor instance to continue processing
// work on the existing thread.
Boolean disable = (Boolean) request.getProperty(ServerConstants.SERVER_DISABLE_THREAD_SWITCH);
if (disable != null && disable.booleanValue()) {
if (log.isDebugEnabled()) {
log.debug("Server side thread switch disabled. Setting Executor to the SingleThreadedExecutor.");
}
executor = new SingleThreadedExecutor();
}
Method m = getJavaMethod();
Object[] params = new Object[] {param};
EndpointInvocationContext eic = (EndpointInvocationContext) request.getInvocationContext();
ClassLoader cl = Thread.currentThread().getContextClassLoader();
AsyncInvocationWorker worker = new AsyncInvocationWorker(m, params, cl, eic);
FutureTask task = new FutureTask<AsyncInvocationWorker>(worker);
executor.execute(task);
return;
}
public void invokeAsync(MessageContext request, EndpointCallback callback) {
if (log.isDebugEnabled()) {
log.debug("Preparing to invoke javax.xml.ws.Provider based endpoint");
log.debug("Invocation pattern: two way, async");
}
initialize(request);
providerInstance = getProviderInstance();
Object param = createRequestParameters(request);
if (log.isDebugEnabled()) {
Class providerType = getProviderType();
final Object input = providerType.cast(param);
log.debug("Invoking Provider<" + providerType.getName() + ">");
if (input != null) {
log.debug("Parameter type: " + input.getClass().getName());
}
else {
log.debug("Parameter is NULL");
}
}
ExecutorFactory ef = (ExecutorFactory) FactoryRegistry.getFactory(ExecutorFactory.class);
Executor executor = ef.getExecutorInstance(ExecutorFactory.SERVER_EXECUTOR);
// If the property has been set to disable thread switching, then we can
// do so by using a SingleThreadedExecutor instance to continue processing
// work on the existing thread.
Boolean disable = (Boolean) request.getProperty(ServerConstants.SERVER_DISABLE_THREAD_SWITCH);
if (disable != null && disable.booleanValue()) {
if (log.isDebugEnabled()) {
log.debug("Server side thread switch disabled. Setting Executor to the SingleThreadedExecutor.");
}
executor = new SingleThreadedExecutor();
}
Method m = getJavaMethod();
Object[] params = new Object[] {param};
EndpointInvocationContext eic = (EndpointInvocationContext) request.getInvocationContext();
ClassLoader cl = Thread.currentThread().getContextClassLoader();
AsyncInvocationWorker worker = new AsyncInvocationWorker(m, params, cl, eic);
FutureTask task = new FutureTask<AsyncInvocationWorker>(worker);
executor.execute(task);
return;
}
public Object createRequestParameters(MessageContext request) {
// First we need to know what kind of Provider instance we're going
// to be invoking against
Class providerType = getProviderType();
// REVIEW: This assumes there is only one endpoint description on the service. Is that always the case?
EndpointDescription endpointDesc = request.getEndpointDescription();
// Now that we know what kind of Provider we have, we can create the
// right type of Block for the request parameter data
Object requestParamValue = null;
Message message = request.getMessage();
if (message != null) {
// Enable MTOM if indicated
if (endpointDesc.isMTOMEnabled()) {
message.setMTOMEnabled(true);
}
// Save off the protocol info so we can use it when creating the response message.
Protocol messageProtocol = message.getProtocol();
// Determine what type blocks we want to create (String, Source, etc) based on Provider Type
BlockFactory factory = createBlockFactory(providerType);
Service.Mode providerServiceMode = endpointDesc.getServiceMode();
if (providerServiceMode != null && providerServiceMode == Service.Mode.MESSAGE) {
if (providerType.equals(SOAPMessage.class)) {
// We can get the SOAPMessage directly from the message itself
if (log.isDebugEnabled()) {
log.debug("Provider Type is SOAPMessage.");
log.debug("Number Message attachments=" + message.getAttachmentIDs().size());
}
}
if (providerType.equals(OMElement.class)) {
requestParamValue = message.getAsOMElement();
} else {
requestParamValue = message.getValue(null, factory);
}
if (requestParamValue == null) {
if (log.isDebugEnabled()) {
log.debug(
"There are no elements to unmarshal. ProviderDispatch will pass a null as input");
}
}
} else {
// If it is not MESSAGE, then it is PAYLOAD (which is the default); only work with the body
Block block = message.getBodyBlock(null, factory);
if (block != null) {
try {
requestParamValue = block.getBusinessObject(true);
if (requestParamValue instanceof OMBlock) {
requestParamValue = ((OMBlock)requestParamValue).getOMElement();
}
} catch (WebServiceException e) {
throw ExceptionFactory.makeWebServiceException(e);
} catch (XMLStreamException e) {
throw ExceptionFactory.makeWebServiceException(e);
}
} else {
if (log.isDebugEnabled()) {
log.debug(
"No body blocks in SOAPMessage, Calling provider method with null input parameters");
}
requestParamValue = null;
}
}
}
return requestParamValue;
}
public MessageContext createResponse(MessageContext request, Object[] input, Object output) {
if (log.isDebugEnabled()) {
log.debug("Start createResponse");
}
Message m;
EndpointDescription endpointDesc = null;
try {
endpointDesc = request.getEndpointDescription();
Service.Mode mode = endpointDesc.getServiceMode();
m = createMessageFromValue(output, request.getMessage().getProtocol(), mode);
} catch (Throwable t) {
if (log.isDebugEnabled()) {
log.debug("Throwable caught");
log.debug("Throwable=" + t);
}
throw ExceptionFactory.makeWebServiceException(t);
}
if (log.isDebugEnabled()) {
log.debug("Response message is created.");
}
MessageContext response = null;
try {
// Enable MTOM if indicated
if (endpointDesc.isMTOMEnabled()) {
m.setMTOMEnabled(true);
}
response = MessageContextUtils.createResponseMessageContext(request);
initMessageContext(response, m, output);
} catch (RuntimeException e) {
if (log.isDebugEnabled()) {
log.debug("Throwable caught creating Response MessageContext");
log.debug("Throwable=" + e);
}
} finally {
if (log.isDebugEnabled()) {
log.debug("End createResponse");
}
}
return response;
}
protected void initMessageContext(MessageContext responseMsgCtx, Message m, Object output) {
responseMsgCtx.setMessage(m);
if(output instanceof DataSource){
responseMsgCtx.setProperty(Constants.Configuration.MESSAGE_FORMATTER,
new DataSourceFormatter(((DataSource)output).getContentType()));
}
}
public MessageContext createFaultResponse(MessageContext request, Throwable fault) {
if (log.isDebugEnabled()) {
log.debug("Create XMLFault for createFaultResponse");
}
// call the InvocationListener instances before marshalling
// the fault into a message
Throwable faultMessage = InvocationHelper.determineMappedException(fault, request);
if(faultMessage != null) {
fault = faultMessage;
}
Message m;
try {
EndpointDescription endpointDesc = request.getEndpointDescription();
Service.Mode mode = endpointDesc.getServiceMode();
XMLFault xmlFault = MethodMarshallerUtils.createXMLFaultFromSystemException(fault);
m = createMessageFromValue(xmlFault, request.getMessage().getProtocol(), mode);
} catch (Exception e) {
throw ExceptionFactory.makeWebServiceException(e);
}
MessageContext response = MessageContextUtils.createFaultMessageContext(request);
response.setMessage(m);
return response;
}
/**
* Get the endpoint provider instance
*
* @return Provider
* @throws Exception
*/
public Provider getProvider() throws Exception {
Provider p = getProviderInstance();
setProvider(p);
return p;
}
/**
* Set the endpoint provider instance
*
* @param _provider
*/
public void setProvider(Provider _provider) {
this.providerInstance = _provider;
}
/**
* Get the parameter for a given endpoint invocation
*
* @return
* @throws Exception
*/
public Message getMessage() throws Exception {
return message;
}
/**
* Set the parameter for a given endpoint invocation
*
* @param msg
*/
public void setMessage(Message msg) {
this.message = msg;
}
/*
* Create a Message object out of the value object that was returned.
*/
private Message createMessageFromValue(Object value, Protocol protocol,
Service.Mode mode) throws Exception {
MessageFactory msgFactory =
(MessageFactory)FactoryRegistry.getFactory(MessageFactory.class);
Message message = null;
if (value != null) {
Class providerType = getProviderType();
BlockFactory factory = createBlockFactory(providerType);
if (value instanceof XMLFault) {
if (log.isDebugEnabled()) {
log.debug("Creating message from XMLFault");
}
message = msgFactory.create(protocol);
message.setXMLFault((XMLFault)value);
} else if (mode != null && mode == Service.Mode.MESSAGE) {
// For MESSAGE mode, work with the entire message, Headers and Body
// This is based on logic in org.apache.axis2.jaxws.client.XMLDispatch.createMessageFromBundle()
if (value instanceof SOAPMessage) {
if (log.isDebugEnabled()) {
log.debug("Creating message from SOAPMessage");
}
message = msgFactory.createFrom((SOAPMessage)value);
} else if (value instanceof SOAPEnvelope) {
// The value from the provider is already an SOAPEnvelope OMElement, so
// it doesn't need to be parsed into one.
if (log.isDebugEnabled()) {
log.debug("Creating message from OMElement");
}
message = msgFactory.createFrom((SOAPEnvelope) value, protocol);
} else {
if (log.isDebugEnabled()) {
log.debug("Creating message using " + factory);
}
Block block = factory.createFrom(value, null, null);
message = msgFactory.createFrom(block, null, protocol);
}
} else {
// PAYLOAD mode deals only with the body of the message.
if (log.isDebugEnabled()) {
log.debug("Creating message (payload) using " + factory);
}
Block block = factory.createFrom(value, null, null);
message = msgFactory.create(protocol);
if (XMLFaultUtils.containsFault(block)) {
if (log.isDebugEnabled()) {
log.debug("The response block created contained a fault. Converting to an XMLFault object.");
}
// If the Provider returned a fault, then let's correct the output and
// put an XMLFault on the Message. This makes it easier for downstream
// consumers to get the SOAPFault from the OM SOAPEnvelope.
XMLFault fault = XMLFaultUtils.createXMLFault(block, message.getProtocol());
message.setXMLFault(fault);
}
else {
message.setBodyBlock(block);
}
}
}
if (message == null) {
// If we didn't create a message above (because there was no value), create one here
message = msgFactory.create(protocol);
}
return message;
}
/*
* Determine the Provider type for this instance
*/
private Provider getProviderInstance() {
Class<?> clazz = getProviderType();
if (!isValidProviderType(clazz)) {
// TODO This will change once deployment code it in place
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("InvalidProvider", clazz.getName()));
}
Provider provider = null;
if (clazz == String.class) {
provider = (Provider<String>)serviceInstance;
} else if (clazz == Source.class) {
provider = (Provider<Source>)serviceInstance;
} else if (clazz == SOAPMessage.class) {
provider = (Provider<SOAPMessage>)serviceInstance;
} else if (clazz == DataSource.class) {
provider = (Provider<DataSource>)serviceInstance;
} else if (clazz == OMElement.class) {
provider = (Provider<OMElement>)serviceInstance;
}
if (provider == null) {
throw ExceptionFactory.makeWebServiceException(
Messages.getMessage("InvalidProviderCreate", clazz.getName()));
}
return provider;
}
/*
* Get the provider type from a given implemention class instance
*/
private Class<?> getProviderType() {
if (_providerType != null) {
return _providerType;
}
Class providerType = null;
Type[] giTypes = serviceImplClass.getGenericInterfaces();
for (Type giType : giTypes) {
ParameterizedType paramType = null;
try {
paramType = (ParameterizedType)giType;
} catch (ClassCastException e) {
// this may not be a parameterized interface
continue;
}
Class interfaceName = (Class)paramType.getRawType();
if (interfaceName == javax.xml.ws.Provider.class) {
if (paramType.getActualTypeArguments().length > 1) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("pTypeErr"));
}
providerType = (Class)paramType.getActualTypeArguments()[0];
}
}
_providerType = providerType;
return providerType;
}
/*
* Validate whether or not the Class passed in is a valid type of
* javax.xml.ws.Provider<T>. Per the JAX-WS 2.0 specification, the
* parameterized type of a Provider can only be:
*
* javax.xml.transform.Source
* javax.xml.soap.SOAPMessage
* javax.activation.DataSource
* org.apache.axiom.om.OMElement
*
* We've also added support for String types which is NOT dictated
* by the spec.
*/
private boolean isValidProviderType(Class clazz) {
boolean valid = clazz == String.class ||
clazz == SOAPMessage.class ||
clazz == Source.class ||
clazz == DataSource.class ||
clazz == OMElement.class;
if (!valid) {
if (log.isDebugEnabled()) {
log.debug("Class " + clazz.getName() + " is not a valid Provider<T> type");
}
}
return valid;
}
/*
* Given a target class type for a payload, load the appropriate BlockFactory.
*/
private BlockFactory createBlockFactory(Class type) {
if (_blockFactory != null) {
return _blockFactory;
}
if (type.equals(String.class)) {
_blockFactory = (XMLStringBlockFactory)FactoryRegistry.getFactory(
XMLStringBlockFactory.class);
} else if (type.equals(DataSource.class)) {
_blockFactory = (DataSourceBlockFactory)FactoryRegistry.getFactory(
DataSourceBlockFactory.class);
} else if (type.equals(Source.class)) {
_blockFactory = (SourceBlockFactory)FactoryRegistry.getFactory(
SourceBlockFactory.class);
} else if (type.equals(SOAPMessage.class)) {
_blockFactory = (SOAPEnvelopeBlockFactory)FactoryRegistry.getFactory(
SOAPEnvelopeBlockFactory.class);
} else if (type.equals(OMElement.class)) {
_blockFactory = (OMBlockFactory)FactoryRegistry.getFactory(
OMBlockFactory.class);
} else {
throw ExceptionFactory.makeWebServiceException(
Messages.getMessage("bFactoryErr",type.getName()));
}
return _blockFactory;
}
protected Method getJavaMethod() {
Method m = null;
try {
m = providerInstance.getClass().getMethod("invoke", new Class[] {getProviderType()});
} catch (SecurityException e) {
throw ExceptionFactory.makeWebServiceException(e);
} catch (NoSuchMethodException e) {
throw ExceptionFactory.makeWebServiceException(e);
}
return m;
}
protected void initialize(MessageContext mc) {
mc.setOperationName(mc.getAxisMessageContext().getAxisOperation().getName());
endpointDesc = mc.getEndpointDescription();
if (endpointDesc.isMTOMEnabled()) {
mc.getMessage().setMTOMEnabled(true);
}
//Set SOAP Operation Related properties in SOAPMessageContext.
ContextUtils.addWSDLProperties_provider(mc);
}
}