/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* 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.axis.client ;
import javax.xml.namespace.QName;
import javax.xml.rpc.handler.HandlerChain;
import org.apache.axis.AxisEngine;
import org.apache.axis.AxisFault;
import org.apache.axis.Constants;
import org.apache.axis.EngineConfiguration;
import org.apache.axis.Handler;
import org.apache.axis.MessageContext;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.configuration.EngineConfigurationFactoryFinder;
import org.apache.axis.handlers.HandlerInfoChainFactory;
import org.apache.axis.handlers.soap.MustUnderstandChecker;
import org.apache.axis.handlers.soap.SOAPService;
import org.apache.axis.utils.Messages;
import org.apache.commons.logging.Log;
/**
* Provides the equivalent of an "Axis engine" on the client side.
* Subclasses hardcode initialization & setup logic for particular
* client-side transports.
*
* @author Rob Jellinghaus (robj@unrealities.com)
* @author Doug Davis (dug@us.ibm.com)
* @author Glen Daniels (gdaniels@allaire.com)
*/
public class AxisClient extends AxisEngine {
protected static Log log =
LogFactory.getLog(AxisClient.class.getName());
MustUnderstandChecker checker = new MustUnderstandChecker(null);
public AxisClient(EngineConfiguration config) {
super(config);
}
public AxisClient() {
this(EngineConfigurationFactoryFinder.newFactory().
getClientEngineConfig());
}
/**
* @return this instance, as this is the client engine
*/
public AxisEngine getClientEngine () {
return this;
}
/**
* Main routine of the AXIS engine. In short we locate the appropriate
* handler for the desired service and invoke() it.
*
* @param msgContext the <code>MessageContext</code> to invoke relative
* to
* @throws AxisFault if anything goes wrong during invocation
*/
public void invoke(MessageContext msgContext) throws AxisFault {
if (log.isDebugEnabled()) {
log.debug("Enter: AxisClient::invoke");
}
String hName = null;
Handler h = null;
HandlerChain handlerImpl = null;
// save previous context
MessageContext previousContext = getCurrentMessageContext();
try {
// set active context
setCurrentMessageContext(msgContext);
hName = msgContext.getStrProp(MessageContext.ENGINE_HANDLER);
if (log.isDebugEnabled()) {
log.debug("EngineHandler: " + hName);
}
if (hName != null) {
h = getHandler(hName);
if (h != null)
h.invoke(msgContext);
else
throw new AxisFault("Client.error",
Messages.getMessage("noHandler00",
hName),
null, null);
} else {
/* Now we do the 'real' work. The flow is basically: */
/* */
/* Service Specific Request Chain */
/* Global Request Chain */
/* Transport Request Chain - must have a send at the end */
/* Transport Response Chain */
/* Global Response Chain */
/* Service Specific Response Chain */
/* Protocol Specific-Handler/Checker */
/**************************************************************/
SOAPService service = null;
msgContext.setPastPivot(false);
/* Process the Service Specific Request Chain */
/**********************************************/
service = msgContext.getService();
if (service != null) {
h = service.getRequestHandler();
if (h != null)
h.invoke(msgContext);
}
/* Process the Global Request Chain */
/**********************************/
if ((h = getGlobalRequest()) != null)
h.invoke(msgContext);
/* Process the JAX-RPC Handlers - handleRequest.
* Make sure to set the pastPivot to true if this returns a
* false. In that case we do not invoke the transport request
* chain. Also note that if a a false was returned from the
* JAX-RPC handler chain, then the chain still holds the index
* of the handler that returned false. So when we invoke the
* handleResponse method of the chain, it will correctly call
* the handleResponse from that specific handler instance. So
* do not destroy the chain at this point - the chain will be
* destroyed in the finally block.
*/
handlerImpl = getJAXRPChandlerChain(msgContext);
if (handlerImpl != null) {
try {
if (!handlerImpl.handleRequest(msgContext)) {
msgContext.setPastPivot(true);
}
} catch (RuntimeException re) {
handlerImpl.destroy(); // WS4EE 1.1 6.2.2.1 Handler Life Cycle. "RuntimeException" --> destroy handler
throw re;
}
}
/** Process the Transport Specific stuff
*
* NOTE: Somewhere in here there is a handler which actually
* sends the message and receives a response. Generally
* this is the pivot point in the Transport chain. But invoke
* this only if pivot point has not been set to false. This
* can be set to false if any of the JAX-RPC handler's
* handleRequest returned false.
*/
if (!msgContext.getPastPivot()) {
hName = msgContext.getTransportName();
if (hName != null && (h = getTransport(hName)) != null) {
try {
h.invoke(msgContext);
} catch (AxisFault e) {
throw e;
}
} else {
throw new AxisFault(Messages.getMessage("noTransport00",
hName));
}
}
msgContext.setPastPivot(true);
if (!msgContext.isPropertyTrue(Call.ONE_WAY)) {
if ((handlerImpl != null) &&
!msgContext.isPropertyTrue(Call.ONE_WAY)) {
try {
handlerImpl.handleResponse(msgContext);
} catch (RuntimeException ex) {
handlerImpl.destroy(); // WS4EE 1.1 6.2.2.1 Handler Life Cycle. "RuntimeException" --> destroy handler
throw ex;
}
}
/* Process the Global Response Chain */
/***********************************/
if ((h = getGlobalResponse()) != null) {
h.invoke(msgContext);
}
/* Process the Service-Specific Response Chain */
/***********************************************/
if (service != null) {
h = service.getResponseHandler();
if (h != null) {
h.invoke(msgContext);
}
}
// Do SOAP Semantics checks here - this needs to be a call
// to a pluggable object/handler/something
if (msgContext.isPropertyTrue(Call.CHECK_MUST_UNDERSTAND,
true)) {
checker.invoke(msgContext);
}
}
}
} catch (Exception e) {
// Should we even bother catching it ?
if (e instanceof AxisFault) {
throw (AxisFault) e;
} else {
log.debug(Messages.getMessage("exception00"), e);
throw AxisFault.makeFault(e);
}
} finally {
if (handlerImpl != null) {
handlerImpl.destroy();
}
// restore previous state
setCurrentMessageContext(previousContext);
}
if (log.isDebugEnabled()) {
log.debug("Exit: AxisClient::invoke");
}
}
/**
* @param context Stores the Service, port QName and optionnaly a HandlerInfoChainFactory
* @return Returns a HandlerChain if one has been specified
*/
protected HandlerChain getJAXRPChandlerChain(MessageContext context) {
java.util.List chain = null;
HandlerInfoChainFactory hiChainFactory = null;
boolean clientSpecified = false;
Service service = (Service) context.getProperty(Call.WSDL_SERVICE);
if(service == null) {
return null;
}
QName portName = (QName) context.getProperty(Call.WSDL_PORT_NAME);
if(portName == null) {
return null;
}
javax.xml.rpc.handler.HandlerRegistry registry;
registry = service.getHandlerRegistry();
if(registry != null) {
chain = registry.getHandlerChain(portName);
if ((chain != null) && (!chain.isEmpty())) {
hiChainFactory = new HandlerInfoChainFactory(chain);
clientSpecified = true;
}
}
// Otherwise, use the container support
if (!clientSpecified) {
SOAPService soapService = context.getService();
if (soapService != null) {
// A client configuration exists for this service. Check
// to see if there is a HandlerInfoChain configured on it.
hiChainFactory = (HandlerInfoChainFactory)
soapService.getOption(Constants.ATTR_HANDLERINFOCHAIN);
}
}
if (hiChainFactory == null) {
return null;
}
return hiChainFactory.createHandlerChain();
}
}