modules/jaxws/src/org/apache/axis2/jaxws/AxisController.java - axis-axis2-java-rampart - Git at Google

 /*
  * Copyright 2004,2005 The Apache Software Foundation.
  * Copyright 2006 International Business Machines Corp.
  *
  * Licensed 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;

 import java.net.URL;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;

 import javax.xml.namespace.QName;
 import javax.xml.ws.AsyncHandler;
 import javax.xml.ws.Response;
 import javax.xml.ws.WebServiceException;
 import javax.xml.ws.Service.Mode;

 import org.apache.axiom.om.OMElement;
 import org.apache.axiom.soap.SOAPBody;
 import org.apache.axiom.soap.SOAPEnvelope;
 import org.apache.axiom.soap.SOAPHeader;
 import org.apache.axis2.AxisFault;
 import org.apache.axis2.addressing.EndpointReference;
 import org.apache.axis2.addressing.AddressingConstants;
 import org.apache.axis2.client.ServiceClient;
 import org.apache.axis2.context.ConfigurationContext;
 import org.apache.axis2.context.ServiceContext;
 import org.apache.axis2.context.ServiceGroupContext;
 import org.apache.axis2.description.AxisService;
 import org.apache.axis2.jaxws.handler.PortData;
 import org.apache.axis2.jaxws.i18n.Messages;
 import org.apache.axis2.jaxws.impl.AsyncListenerWrapper;
 import org.apache.axis2.jaxws.impl.AsyncListener;
 import org.apache.axis2.jaxws.param.JAXBParameter;
 import org.apache.axis2.jaxws.param.Parameter;
 import org.apache.axis2.jaxws.param.ParameterFactory;
 import org.apache.axis2.jaxws.param.ParameterUtils;
 import org.apache.axis2.jaxws.util.Constants;
 import org.apache.axis2.jaxws.util.WSDLWrapper;


 public class AxisController {
     private AxisService axisService = null;
 //  TODO: This configContext will come from websphere deployment code later
     private ConfigurationContext configContext = null;
     private ServiceClient serviceClient = null;
     private ServiceContext serviceContext = null;
     private JAXWSClientContext clientContext = null;
     private ServiceGroupContext groupContext = null;
     private EndpointReference myEPR;

     public AxisService getAxisService() {
         return axisService;
     }
     public void setAxisService(AxisService axisService) {
         this.axisService = axisService;
     }
     public ConfigurationContext getConfigContext() {
         return configContext;
     }
     public void setConfigContext(ConfigurationContext configContext) {
         this.configContext = configContext;
     }
     public ServiceClient getServiceClient() {
         return serviceClient;
     }
     public void setServiceClient(ServiceClient serviceClient) {
         this.serviceClient = serviceClient;
     }
     public ServiceContext getServiceContext() {
         return serviceContext;
     }
     public void setServiceContext(ServiceContext serviceContext) {
         this.serviceContext = serviceContext;
     }
     public JAXWSClientContext getClientContext() {
         return clientContext;
     }
     public void setClientContext(JAXWSClientContext clientContext) {
         this.clientContext = clientContext;
     }
     public ServiceGroupContext getGroupContext() {
         return groupContext;
     }
     public void setGroupContext(ServiceGroupContext groupContext) {
         this.groupContext = groupContext;
     }
     public PortData getPortInfo(){
         return clientContext.getPort();
     }
     public QName getServiceName(){
         return getPortInfo().getServiceName();
     }
     public QName getPortName(){
         return getPortInfo().getPortName();
     }
     public String getEndpointAddress(){
         return getPortInfo().getEndpointAddress();
     }
     public String getBindingId(){
         return getPortInfo().getBindingID();
     }
     public WSDLWrapper getWSDLContext(){
         return clientContext.getWsdlContext();
     }
     public ExecutorService getExecutor() {
         return clientContext.getExecutor();
     }
     public Mode getServiceMode() {
         return (Mode) clientContext.getServiceMode();
     }
     public URL getWSDLLocation(){
         return clientContext.getWSDLLocation();
     }

     public Object invoke(Parameter param, Map requestContext) throws WebServiceException {
         setupProperties(requestContext);

         try{
             //TODO: This is not the correct way to setup the JAXBContext
             if (clientContext.getJAXBContext() != null) {
                 JAXBParameter p = (JAXBParameter) param;
                 p.setJAXBContext(clientContext.getJAXBContext());
             }

             serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(getEndpointURL(requestContext)));
             String soapAction = getSOAPAction(requestContext);
             if (soapAction != null) {
                 serviceClient.getOptions().setAction(soapAction);
             }
             else {
                 //TODO: This should be an addressing exception on the client side
                 serviceClient.getOptions().setAction("none");
             }

             //Create the Parameter wrapper for the response based on what the input
             //type was.  If it was a JAXBParameter, then set the JAXBContext on it as well
             Parameter response = ParameterFactory.createParameter(param.getValue().getClass());
             if (param instanceof JAXBParameter) {
                 JAXBParameter p = (JAXBParameter) response;
                 p.setJAXBContext(clientContext.getJAXBContext());
             }
             OMElement axisResponse = null;

             //TODO: Team needs to decide if we are going to use ServiceClient api or go to AxisEngine api directly. ServiceClient requires that we send a OMElement
             //and it creates a SOAPEnvelop by reading the headers that dispatch sets in ServiceClient. This is not a good way for message modeas we will be
             //manuplating client message first to read all the headers and then read the body. we add the headers in ServiceClient then create OMElement from body
             //and send then OMElement in SendReceive operation, which then is converted again to an envelope and header headers are added to it by ServiceClient
             //before sending it to axis enging.
             axisResponse = serviceClient.sendReceive(ServiceClient.ANON_OUT_IN_OP, toOM(param));

             //TODO: If ServiceClient can return the actual sopaEnvelope from MessageContext we can use the message mode and param this way.
             //response.fromEnvelope(mode, axisResponse);
             //return response.getValue();
             return buildResponse(axisResponse, response).getValue();
         }catch(AxisFault e){
         	// TODO Add Fault Processing
         	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("faultProcessingNotSupported", e.getMessage()), e);

         }
     }

     public void invokeOneWay(Parameter param, Map requestContext) throws WebServiceException{
         setupProperties(requestContext);

         try{
             //TODO: This is not the correct way to setup the JAXBContext
             if (clientContext.getJAXBContext() != null) {
                 JAXBParameter p = (JAXBParameter) param;
                 p.setJAXBContext(clientContext.getJAXBContext());
             }

             serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(getEndpointURL(requestContext)));
             String soapAction = getSOAPAction(requestContext);
             if (soapAction != null) {
                 serviceClient.getOptions().setAction(soapAction);
             }
             else {
                 serviceClient.getOptions().setAction("none");
             }

             serviceClient.fireAndForget(ServiceClient.ANON_OUT_ONLY_OP, toOM(param));
         } catch(AxisFault e) {
         	// TODO Add Fault Processing
         	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("faultProcessingNotSupported", e.getMessage()), e);

         }
     }

     public Future<?> invokeAsync(Parameter param, AsyncHandler asynchandler, Map requestContext) throws WebServiceException{
         setupProperties(requestContext);

         try{
             //TODO: This is not the correct way to setup the JAXBContext
             if (clientContext.getJAXBContext() != null) {
                 JAXBParameter p = (JAXBParameter) param;
                 p.setJAXBContext(clientContext.getJAXBContext());
             }

             serviceClient.getOptions().setTo(new EndpointReference(getEndpointURL(requestContext)));
             serviceClient.getOptions().setReplyTo(getMyEPR());

             //TODO: This is a hack.  Need a better way to determine the default wsa:Action if
             //a SOAPAction header does not exist.
             String soapAction = getSOAPAction(requestContext);
             if (soapAction != null) {
                 serviceClient.getOptions().setAction(soapAction);
             }
             else {
                 serviceClient.getOptions().setAction("none");
             }

             AxisCallback callback = new AxisCallback();
             Boolean useAsyncMep = (Boolean) requestContext.get(Constants.USE_ASYNC_MEP);

             if((useAsyncMep != null && useAsyncMep.booleanValue())
                     || serviceClient.getOptions().isUseSeparateListener()) {
                 serviceClient.getOptions().setUseSeparateListener(true);
                 serviceClient.getOptions().setTransportInProtocol("http");
             }

             serviceClient.sendReceiveNonBlocking(ServiceClient.ANON_OUT_IN_OP,
                     toOM(param), callback);

             //Create the Parameter wrapper for the response based on what the input
             //type was.  If it was a JAXBParameter, then set the JAXBContext on it as well
             Parameter responseParam = ParameterFactory.createParameter(param.getValue().getClass());
             if (param instanceof JAXBParameter) {
                 JAXBParameter p = (JAXBParameter) responseParam;
                 p.setJAXBContext(clientContext.getJAXBContext());
             }

             AsyncListener asyncProcessor = new AsyncListener(callback);
             asyncProcessor.setMode((Mode) clientContext.getServiceMode());
             //asyncProcessor.setParameter(responseParam);

             AsyncListenerWrapper<?> response = new AsyncListenerWrapper<Object>(asyncProcessor);
             if(asynchandler !=null){
                 response.setAsyncHandler(asynchandler);
             }

             try {
                 getExecutor().submit(response).get();
             } catch (InterruptedException e) {
                 e.printStackTrace();
                 throw ExceptionFactory.makeWebServiceException(e);
             } catch (ExecutionException e) {
                 e.printStackTrace();
                 throw ExceptionFactory.makeWebServiceException(e);
             }

             //TODO: Need to figure out who/when the Listener should be shutdown
             //Do we do it after this request?  Or, can we ask the listener to check
             //itself to see if any other responses are outstanding.
             return response;
         }catch(AxisFault e){
         	// TODO Add Fault Processing
         	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("faultProcessingNotSupported", e.getMessage()), e);
         }
     }

     public Response invokeAsync(Parameter param, Map requestContext)throws WebServiceException{
     	AsyncListenerWrapper<Object>  response= (AsyncListenerWrapper<Object>)invokeAsync(param, null, requestContext);
         return response;
     }

     private String getEndpointURL(Map requestContext){
         return (String) requestContext.get(BindingProvider.ENDPOINT_ADDRESS_PROPERTY);
     }

     private String getSOAPAction(Map requestContext){
         Boolean useSoapAction = (Boolean)requestContext.get(BindingProvider.SOAPACTION_USE_PROPERTY);
         if(useSoapAction!=null && useSoapAction.booleanValue()){
             return (String)requestContext.get(BindingProvider.SOAPACTION_URI_PROPERTY);
         }
         return null;
     }

     private OMElement toOM(Parameter param){
         /*TODO: This is a a hack.... I am getting the Header of the message and setting serviceClent header, then
         * extract body of message as OM and ServiceCleint will create the envelope.
         * I am doing this because ServiceClient wants to form the envelope and send it to AxisEngine.
         * I would like to return param.toEnvelope() but ServiceClient will try to build envelope on top of envelope.
         * Let just go directly to AxisEngine forget about ServiceClient... can I?
         */
         SOAPEnvelope env = ParameterUtils.toEnvelope((Mode) clientContext.getServiceMode(),
                 serviceClient.getOptions().getSoapVersionURI(),
                 param);
         SOAPBody body= env.getBody();
         SOAPHeader soapHeader = env.getHeader();
         addHeadersToServiceClient(soapHeader);
         return body.getFirstElement();
     }

     private void addHeadersToServiceClient(SOAPHeader soapHeader){
         if(soapHeader!=null){
             for(Iterator headers = soapHeader.getChildElements(); headers.hasNext();){
                 OMElement header = (OMElement)headers.next();
                 serviceClient.addHeader(header);
             }
         }
     }

     private Parameter buildResponse(OMElement element, Parameter xmlResponse){
         //Create empty SoapResponse first
         Parameter soapResponse = xmlResponse;

         /* get xmlResponse param from ServiceClient OM response, By the way ServiceClient always retuns an
          * OMElement xml string not Soap Env or Body.
          * It does something like msgCtx.getEnvelope().getBody.getChild() --> i.e OMElement under the body.
          * So we now have to go thru the pain of recreating the envelope. This is a performance issue...
         */
         xmlResponse.fromOM(element);
         /*I will convert param toEnvelope since ServiceClient always send xml string.
          * toEnvelope() in Parameter is coded just to handle this.
          */
         SOAPEnvelope env =xmlResponse.toEnvelope(null,serviceClient.getOptions().getSoapVersionURI());

         //TODO:(NLG) Need to figure out why we have to cast to (Mode) here.
         soapResponse.fromEnvelope((Mode) clientContext.getServiceMode(), env);

         return soapResponse;
     }

     /*
      * Returns the EPR that should be used for in-bound async responses
      */
     private EndpointReference getMyEPR() {
         if (myEPR != null) {
             return myEPR;
         }
         else {
             try {
                 //TODO:(NLG) This should not be hard coded to HTTP and should allow
                 //for other transports to be used.
                 myEPR = serviceClient.getMyEPR("http");
             } catch (AxisFault e) {
                 e.printStackTrace();
             }
             return myEPR;
         }
     }


     /*
      * TODO: This is a first pass at filtering the properties that are set on the
      * RequestContext.  Right now it's called during the invoke, but needs to be
      * moved over to when the property is set.  This should not be in the path
      * of performance.
      */
     private void setupProperties(Map<String, Object> requestCtx) {
         for (Iterator<String> it = requestCtx.keySet().iterator(); it.hasNext(); ) {
             String key = it.next();
             Object value = requestCtx.get(key);

             serviceClient.getOptions().setProperty(key, value);
         }
     }
 }
	/*
	* Copyright 2004,2005 The Apache Software Foundation.
	* Copyright 2006 International Business Machines Corp.
	*
	* Licensed 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;

	import java.net.URL;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Future;

	import javax.xml.namespace.QName;
	import javax.xml.ws.AsyncHandler;
	import javax.xml.ws.Response;
	import javax.xml.ws.WebServiceException;
	import javax.xml.ws.Service.Mode;

	import org.apache.axiom.om.OMElement;
	import org.apache.axiom.soap.SOAPBody;
	import org.apache.axiom.soap.SOAPEnvelope;
	import org.apache.axiom.soap.SOAPHeader;
	import org.apache.axis2.AxisFault;
	import org.apache.axis2.addressing.EndpointReference;
	import org.apache.axis2.addressing.AddressingConstants;
	import org.apache.axis2.client.ServiceClient;
	import org.apache.axis2.context.ConfigurationContext;
	import org.apache.axis2.context.ServiceContext;
	import org.apache.axis2.context.ServiceGroupContext;
	import org.apache.axis2.description.AxisService;
	import org.apache.axis2.jaxws.handler.PortData;
	import org.apache.axis2.jaxws.i18n.Messages;
	import org.apache.axis2.jaxws.impl.AsyncListenerWrapper;
	import org.apache.axis2.jaxws.impl.AsyncListener;
	import org.apache.axis2.jaxws.param.JAXBParameter;
	import org.apache.axis2.jaxws.param.Parameter;
	import org.apache.axis2.jaxws.param.ParameterFactory;
	import org.apache.axis2.jaxws.param.ParameterUtils;
	import org.apache.axis2.jaxws.util.Constants;
	import org.apache.axis2.jaxws.util.WSDLWrapper;


	public class AxisController {
	private AxisService axisService = null;
	// TODO: This configContext will come from websphere deployment code later
	private ConfigurationContext configContext = null;
	private ServiceClient serviceClient = null;
	private ServiceContext serviceContext = null;
	private JAXWSClientContext clientContext = null;
	private ServiceGroupContext groupContext = null;
	private EndpointReference myEPR;

	public AxisService getAxisService() {
	return axisService;
	}
	public void setAxisService(AxisService axisService) {
	this.axisService = axisService;
	}
	public ConfigurationContext getConfigContext() {
	return configContext;
	}
	public void setConfigContext(ConfigurationContext configContext) {
	this.configContext = configContext;
	}
	public ServiceClient getServiceClient() {
	return serviceClient;
	}
	public void setServiceClient(ServiceClient serviceClient) {
	this.serviceClient = serviceClient;
	}
	public ServiceContext getServiceContext() {
	return serviceContext;
	}
	public void setServiceContext(ServiceContext serviceContext) {
	this.serviceContext = serviceContext;
	}
	public JAXWSClientContext getClientContext() {
	return clientContext;
	}
	public void setClientContext(JAXWSClientContext clientContext) {
	this.clientContext = clientContext;
	}
	public ServiceGroupContext getGroupContext() {
	return groupContext;
	}
	public void setGroupContext(ServiceGroupContext groupContext) {
	this.groupContext = groupContext;
	}
	public PortData getPortInfo(){
	return clientContext.getPort();
	}
	public QName getServiceName(){
	return getPortInfo().getServiceName();
	}
	public QName getPortName(){
	return getPortInfo().getPortName();
	}
	public String getEndpointAddress(){
	return getPortInfo().getEndpointAddress();
	}
	public String getBindingId(){
	return getPortInfo().getBindingID();
	}
	public WSDLWrapper getWSDLContext(){
	return clientContext.getWsdlContext();
	}
	public ExecutorService getExecutor() {
	return clientContext.getExecutor();
	}
	public Mode getServiceMode() {
	return (Mode) clientContext.getServiceMode();
	}
	public URL getWSDLLocation(){
	return clientContext.getWSDLLocation();
	}

	public Object invoke(Parameter param, Map requestContext) throws WebServiceException {
	setupProperties(requestContext);

	try{
	//TODO: This is not the correct way to setup the JAXBContext
	if (clientContext.getJAXBContext() != null) {
	JAXBParameter p = (JAXBParameter) param;
	p.setJAXBContext(clientContext.getJAXBContext());
	}

	serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(getEndpointURL(requestContext)));
	String soapAction = getSOAPAction(requestContext);
	if (soapAction != null) {
	serviceClient.getOptions().setAction(soapAction);
	}
	else {
	//TODO: This should be an addressing exception on the client side
	serviceClient.getOptions().setAction("none");
	}

	//Create the Parameter wrapper for the response based on what the input
	//type was. If it was a JAXBParameter, then set the JAXBContext on it as well
	Parameter response = ParameterFactory.createParameter(param.getValue().getClass());
	if (param instanceof JAXBParameter) {
	JAXBParameter p = (JAXBParameter) response;
	p.setJAXBContext(clientContext.getJAXBContext());
	}
	OMElement axisResponse = null;

	//TODO: Team needs to decide if we are going to use ServiceClient api or go to AxisEngine api directly. ServiceClient requires that we send a OMElement
	//and it creates a SOAPEnvelop by reading the headers that dispatch sets in ServiceClient. This is not a good way for message modeas we will be
	//manuplating client message first to read all the headers and then read the body. we add the headers in ServiceClient then create OMElement from body
	//and send then OMElement in SendReceive operation, which then is converted again to an envelope and header headers are added to it by ServiceClient
	//before sending it to axis enging.
	axisResponse = serviceClient.sendReceive(ServiceClient.ANON_OUT_IN_OP, toOM(param));

	//TODO: If ServiceClient can return the actual sopaEnvelope from MessageContext we can use the message mode and param this way.
	//response.fromEnvelope(mode, axisResponse);
	//return response.getValue();
	return buildResponse(axisResponse, response).getValue();
	}catch(AxisFault e){
	// TODO Add Fault Processing
	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("faultProcessingNotSupported", e.getMessage()), e);

	}
	}

	public void invokeOneWay(Parameter param, Map requestContext) throws WebServiceException{
	setupProperties(requestContext);

	try{
	//TODO: This is not the correct way to setup the JAXBContext
	if (clientContext.getJAXBContext() != null) {
	JAXBParameter p = (JAXBParameter) param;
	p.setJAXBContext(clientContext.getJAXBContext());
	}

	serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference(getEndpointURL(requestContext)));
	String soapAction = getSOAPAction(requestContext);
	if (soapAction != null) {
	serviceClient.getOptions().setAction(soapAction);
	}
	else {
	serviceClient.getOptions().setAction("none");
	}

	serviceClient.fireAndForget(ServiceClient.ANON_OUT_ONLY_OP, toOM(param));
	} catch(AxisFault e) {
	// TODO Add Fault Processing
	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("faultProcessingNotSupported", e.getMessage()), e);

	}
	}

	public Future<?> invokeAsync(Parameter param, AsyncHandler asynchandler, Map requestContext) throws WebServiceException{
	setupProperties(requestContext);

	try{
	//TODO: This is not the correct way to setup the JAXBContext
	if (clientContext.getJAXBContext() != null) {
	JAXBParameter p = (JAXBParameter) param;
	p.setJAXBContext(clientContext.getJAXBContext());
	}

	serviceClient.getOptions().setTo(new EndpointReference(getEndpointURL(requestContext)));
	serviceClient.getOptions().setReplyTo(getMyEPR());

	//TODO: This is a hack. Need a better way to determine the default wsa:Action if
	//a SOAPAction header does not exist.
	String soapAction = getSOAPAction(requestContext);
	if (soapAction != null) {
	serviceClient.getOptions().setAction(soapAction);
	}
	else {
	serviceClient.getOptions().setAction("none");
	}

	AxisCallback callback = new AxisCallback();
	Boolean useAsyncMep = (Boolean) requestContext.get(Constants.USE_ASYNC_MEP);

	if((useAsyncMep != null && useAsyncMep.booleanValue())
	\|\| serviceClient.getOptions().isUseSeparateListener()) {
	serviceClient.getOptions().setUseSeparateListener(true);
	serviceClient.getOptions().setTransportInProtocol("http");
	}

	serviceClient.sendReceiveNonBlocking(ServiceClient.ANON_OUT_IN_OP,
	toOM(param), callback);

	//Create the Parameter wrapper for the response based on what the input
	//type was. If it was a JAXBParameter, then set the JAXBContext on it as well
	Parameter responseParam = ParameterFactory.createParameter(param.getValue().getClass());
	if (param instanceof JAXBParameter) {
	JAXBParameter p = (JAXBParameter) responseParam;
	p.setJAXBContext(clientContext.getJAXBContext());
	}

	AsyncListener asyncProcessor = new AsyncListener(callback);
	asyncProcessor.setMode((Mode) clientContext.getServiceMode());
	//asyncProcessor.setParameter(responseParam);

	AsyncListenerWrapper<?> response = new AsyncListenerWrapper<Object>(asyncProcessor);
	if(asynchandler !=null){
	response.setAsyncHandler(asynchandler);
	}

	try {
	getExecutor().submit(response).get();
	} catch (InterruptedException e) {
	e.printStackTrace();
	throw ExceptionFactory.makeWebServiceException(e);
	} catch (ExecutionException e) {
	e.printStackTrace();
	throw ExceptionFactory.makeWebServiceException(e);
	}

	//TODO: Need to figure out who/when the Listener should be shutdown
	//Do we do it after this request? Or, can we ask the listener to check
	//itself to see if any other responses are outstanding.
	return response;
	}catch(AxisFault e){
	// TODO Add Fault Processing
	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("faultProcessingNotSupported", e.getMessage()), e);
	}
	}

	public Response invokeAsync(Parameter param, Map requestContext)throws WebServiceException{
	AsyncListenerWrapper<Object> response= (AsyncListenerWrapper<Object>)invokeAsync(param, null, requestContext);
	return response;
	}

	private String getEndpointURL(Map requestContext){
	return (String) requestContext.get(BindingProvider.ENDPOINT_ADDRESS_PROPERTY);
	}

	private String getSOAPAction(Map requestContext){
	Boolean useSoapAction = (Boolean)requestContext.get(BindingProvider.SOAPACTION_USE_PROPERTY);
	if(useSoapAction!=null && useSoapAction.booleanValue()){
	return (String)requestContext.get(BindingProvider.SOAPACTION_URI_PROPERTY);
	}
	return null;
	}

	private OMElement toOM(Parameter param){
	/*TODO: This is a a hack.... I am getting the Header of the message and setting serviceClent header, then
	* extract body of message as OM and ServiceCleint will create the envelope.
	* I am doing this because ServiceClient wants to form the envelope and send it to AxisEngine.
	* I would like to return param.toEnvelope() but ServiceClient will try to build envelope on top of envelope.
	* Let just go directly to AxisEngine forget about ServiceClient... can I?
	*/
	SOAPEnvelope env = ParameterUtils.toEnvelope((Mode) clientContext.getServiceMode(),
	serviceClient.getOptions().getSoapVersionURI(),
	param);
	SOAPBody body= env.getBody();
	SOAPHeader soapHeader = env.getHeader();
	addHeadersToServiceClient(soapHeader);
	return body.getFirstElement();
	}

	private void addHeadersToServiceClient(SOAPHeader soapHeader){
	if(soapHeader!=null){
	for(Iterator headers = soapHeader.getChildElements(); headers.hasNext();){
	OMElement header = (OMElement)headers.next();
	serviceClient.addHeader(header);
	}
	}
	}

	private Parameter buildResponse(OMElement element, Parameter xmlResponse){
	//Create empty SoapResponse first
	Parameter soapResponse = xmlResponse;

	/* get xmlResponse param from ServiceClient OM response, By the way ServiceClient always retuns an
	* OMElement xml string not Soap Env or Body.
	* It does something like msgCtx.getEnvelope().getBody.getChild() --> i.e OMElement under the body.
	* So we now have to go thru the pain of recreating the envelope. This is a performance issue...
	*/
	xmlResponse.fromOM(element);
	/*I will convert param toEnvelope since ServiceClient always send xml string.
	* toEnvelope() in Parameter is coded just to handle this.
	*/
	SOAPEnvelope env =xmlResponse.toEnvelope(null,serviceClient.getOptions().getSoapVersionURI());

	//TODO:(NLG) Need to figure out why we have to cast to (Mode) here.
	soapResponse.fromEnvelope((Mode) clientContext.getServiceMode(), env);

	return soapResponse;
	}

	/*
	* Returns the EPR that should be used for in-bound async responses
	*/
	private EndpointReference getMyEPR() {
	if (myEPR != null) {
	return myEPR;
	}
	else {
	try {
	//TODO:(NLG) This should not be hard coded to HTTP and should allow
	//for other transports to be used.
	myEPR = serviceClient.getMyEPR("http");
	} catch (AxisFault e) {
	e.printStackTrace();
	}
	return myEPR;
	}
	}


	/*
	* TODO: This is a first pass at filtering the properties that are set on the
	* RequestContext. Right now it's called during the invoke, but needs to be
	* moved over to when the property is set. This should not be in the path
	* of performance.
	*/
	private void setupProperties(Map<String, Object> requestCtx) {
	for (Iterator<String> it = requestCtx.keySet().iterator(); it.hasNext(); ) {
	String key = it.next();
	Object value = requestCtx.get(key);

	serviceClient.getOptions().setProperty(key, value);
	}
	}
	}