/*
* 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.handler;
import org.apache.axis2.AxisFault;
import org.apache.axis2.jaxws.Constants;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.context.factory.MessageContextFactory;
import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.axis2.jaxws.handler.factory.HandlerPostInvokerFactory;
import org.apache.axis2.jaxws.handler.factory.HandlerPreInvokerFactory;
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.message.Protocol;
import org.apache.axis2.jaxws.message.XMLFault;
import org.apache.axis2.jaxws.message.factory.MessageFactory;
import org.apache.axis2.jaxws.message.util.MessageUtils;
import org.apache.axis2.jaxws.message.util.XMLFaultUtils;
import org.apache.axis2.jaxws.registry.FactoryRegistry;
import org.apache.axis2.jaxws.utility.SAAJFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.soap.SOAPBody;
import javax.xml.soap.SOAPConstants;
import javax.xml.soap.SOAPFault;
import javax.xml.soap.SOAPMessage;
import javax.xml.ws.ProtocolException;
import javax.xml.ws.WebServiceException;
import javax.xml.ws.handler.Handler;
import javax.xml.ws.handler.LogicalHandler;
import javax.xml.ws.handler.soap.SOAPHandler;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class HandlerChainProcessor {
private static final Log log = LogFactory.getLog(HandlerChainProcessor.class);
private HandlerPreInvoker handlerPreInvoker = null;
private HandlerPostInvoker handlerPostInvoker = null;
public enum Direction {
IN, OUT
};
// the type of message, not indicative of one-way vs. request-response
public enum MEP {
REQUEST, RESPONSE
};
private javax.xml.ws.handler.MessageContext currentMC; // just a pointer
private LogicalMessageContext logicalMC = null;
private SoapMessageContext soapMC = null;
private MEPContext mepCtx;
// Copy of the handler chain used by HandlerChainProcessor
private List<Handler> handlers = null;
private static final List<Handler> EMPTY_CHAIN = new ArrayList<Handler>(0);
// for tracking purposes -- see trackInternalCall
private static Handler currentHandler = null;
private static String currentMethod = null;
// track start/end of logical and protocol handlers in the list
// The two scenarios are: 1) run logical handlers only, 2) run all handlers
// logical start is always 0
// protocol start is always logicalLength + 1
// list end is always handlers.size()-1
private int logicalLength = 0;
private final static int SUCCESSFUL = 0;
private final static int FAILED = 1;
private final static int PROTOCOL_EXCEPTION = 2;
private final static int OTHER_EXCEPTION = 3;
// save it if Handler.handleMessage throws one in
// HandlerChainProcessor.handleMessage
private RuntimeException savedException;
private Protocol proto; // need to save it incase we have to make a fault message
// we track whether the SOAPHeadersAdapter and SAAJ are both used in a given handler
// method. If the tracker property is set, and both are called in a handler method,
// we throw an exception. This behavior can easily be turned off by a handler method
// by removing or setting to true the Constants.JAXWS_HANDLER_TRACKER property
public enum TRACKER {
SOAP_HEADERS_ADAPTER_CALLED, SAAJ_CALLED
};
private static boolean soap_headers_adapter_called = false;
private static boolean saaj_called = false;
/*
* The HandlerChainProcessor is constructed with the handler chain.
* The handler chain may be null, empty or already sorted.
* It also may be shared. For this reason a copy of chain is made
* so that the sort and other manipulation does not affect the original
* chain.
* @param chain Handler chain
* @param proto Protocol
*/
public HandlerChainProcessor(List<Handler> chain, Protocol proto) {
if (chain != null) {
synchronized (chain) {
if (chain.size() == 0) {
// Use empty chain to avoid excessive garbage collection
this.handlers = EMPTY_CHAIN;
} else {
this.handlers = new CopyOnWriteArrayList<Handler>(chain);
}
}
} else {
handlers = EMPTY_CHAIN;
}
this.proto = proto;
}
/*
* sortChain sorts the local copy of the handlers chain.
* The logical handlers are first followed by the protocol handlers.
* sortChain also keeps track of the start/end of each type of handler.
*/
private void sortChain() throws WebServiceException {
if (handlers.size() == 0) {
logicalLength = 0;
return;
}
ArrayList<Handler> logicalHandlers = new ArrayList<Handler>();
ArrayList<Handler> protocolHandlers = new ArrayList<Handler>();
Iterator handlerIterator = handlers.iterator();
while (handlerIterator.hasNext()) {
// this is a safe cast since the handlerResolver and binding.setHandlerChain
// and InvocationContext.setHandlerChain verifies it before we get here
Handler handler = (Handler)handlerIterator.next();
// JAXWS 9.2.1.2 sort them by Logical, then SOAP
if (LogicalHandler.class.isAssignableFrom(handler.getClass()))
logicalHandlers.add((LogicalHandler) handler);
else if (SOAPHandler.class.isAssignableFrom(handler.getClass()))
// instanceof ProtocolHandler
protocolHandlers.add((SOAPHandler) handler);
else if (Handler.class.isAssignableFrom(handler.getClass())) {
throw ExceptionFactory.makeWebServiceException(Messages
.getMessage("handlerChainErr1", handler.getClass().getName()));
} else {
throw ExceptionFactory.makeWebServiceException(Messages
.getMessage("handlerChainErr2", handler.getClass().getName()));
}
}
logicalLength = logicalHandlers.size();
// JAXWS 9.2.1.2 sort them by Logical, then SOAP
handlers.clear();
handlers.addAll(logicalHandlers);
handlers.addAll(protocolHandlers);
}
/**
* @param mc
* By the time processChain method is called, we already have the sorted chain,
* and now we have the direction, MEP, MessageContext, and if a response is expected. We should
* be able to handle everything from here, no pun intended.
*
* Two things a user of processChain should check when the method completes:
* 1. Has the MessageContext.MESSAGE_OUTBOUND_PROPERTY changed, indicating reversal of message direction
* 2. Has the message been converted to a fault message? (indicated by a flag in the message)
*/
public boolean processChain(MEPContext mepCtx, Direction direction, MEP mep,
boolean expectResponse) {
if (handlers.size() == 0)
return true;
this.mepCtx = mepCtx;
sortChain();
initContext(direction);
boolean result = true;
if (direction == Direction.OUT) { // 9.3.2 outbound
currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
(direction == Direction.OUT));
result = callGenericHandlers(mep, expectResponse, 0, handlers.size() - 1, direction);
} else { // IN case - 9.3.2 inbound
currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
(direction == Direction.OUT));
result = callGenericHandlers(mep, expectResponse, handlers.size() - 1, 0, direction);
}
// message context may have been changed to be response, and message
// converted
// according to the JAXWS spec 9.3.2.1 footnote 2
if ((Boolean) (currentMC.get(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY)) != (direction == Direction.OUT))
return false;
return result;
}
public boolean processChainForClose(MEPContext mepCtx, Direction direction) {
boolean result = true;
if (handlers.size() == 0)
return true;
this.mepCtx = mepCtx;
sortChain();
initContext(direction);
callCloseHandlers(handlers.size() - 1, 0, direction);
return result;
}
/*
* This is the implementation of JAX-WS 2.0 section 9.3.2.1
*/
private boolean callGenericHandlers(MEP mep, boolean expectResponse, int start, int end,
Direction direction) throws RuntimeException {
// if this is a response message, expectResponse should always be false
if (mep == MEP.RESPONSE)
expectResponse = false;
int i = start;
int result = SUCCESSFUL;
// declared and initialized just in case we need them
// in a reverse flow situation
int newStart = 0, newStart_inclusive = 0, newEnd = 0;
Direction newDirection = direction;
if (direction == Direction.OUT) {
while ((i <= end) && (result == SUCCESSFUL)) {
result = handleMessage(((Handler)handlers.get(i)), direction, expectResponse);
newStart = i - 1;
newStart_inclusive = i;
newEnd = 0;
newDirection = Direction.IN;
i++;
if (result == SUCCESSFUL) // don't switch if failed, since we'll be reversing directions
switchContext(direction, i);
}
} else { // IN case
while ((i >= end) && (result == SUCCESSFUL)) {
result = handleMessage(((Handler)handlers.get(i)), direction, expectResponse);
newStart = i + 1;
newStart_inclusive = i;
newEnd = handlers.size() - 1;
newDirection = Direction.OUT;
i--;
if (result == SUCCESSFUL) // don't switch if failed, since we'll be reversing directions
switchContext(direction, i);
}
}
if (newDirection == direction) // we didn't actually process anything, probably due to empty list
return true; // no need to continue
// 9.3.2.3 in all situations, we want to close as many handlers as
// were invoked prior to completion or exception throwing
if (expectResponse) {
if (result == FAILED) {
if (log.isDebugEnabled()) {
log.debug("Handler returned false...Start running the handlers in reverse");
}
// One of that handlers returned false, therefore the handler processing
// is stoped and the transport outbound will be avoided.
// This may be due to an exception or it may be due the customer intentionally
// preventing a message from flowing outbound.
// we should only use callGenericHandlers_avoidRecursion in this case
// the message context is now an outbound message context,
// and should be marked as such so the SOAPHeadersAdapter will
// "install" with the correct property key.
// Get the MessageContext and switch its direction
MessageContext jaxwsMC = mepCtx.getMessageContext();
jaxwsMC.setOutbound(newDirection == Direction.OUT);
SOAPHeadersAdapter.install(jaxwsMC);
callGenericHandlers_avoidRecursion(newStart, newEnd, newDirection);
// Now we need to place the Message (which is the one edited by the handler)
// onto the Axis2 MC. This is necessary because the Axis2 response MC
// will be created from this MC and must have the correct message.
this.placeMessageOnAxis2MessageContext(jaxwsMC);
// Now close the handlers
callCloseHandlers(newStart_inclusive, newEnd, newDirection);
if (log.isDebugEnabled()) {
log.debug("Handler returned false...End running the handlers in reverse");
}
} else if (result == PROTOCOL_EXCEPTION) {
try {
if (log.isDebugEnabled()) {
log.debug("Handler threw ProtocolException...Start running the handlers in reverse");
}
// the message context is now an outbound message context,
// and should be marked as such so the SOAPHeadersAdapter will
// "install" with the correct property key.
// Get the MessageContext and switch its direction
MessageContext jaxwsMC = mepCtx.getMessageContext();
jaxwsMC.setOutbound(newDirection == Direction.OUT);
SOAPHeadersAdapter.install(jaxwsMC);
// Call the handlerFault methods on the handlers and also close the handlers
callGenericHandleFault(newStart, newEnd, newDirection);
// Now we need to place the Message (which is the one edited by the handler)
// onto the Axis2 MC. This is necessary because the Axis2 response MC
// will be created from this MC and must have the correct message.
this.placeMessageOnAxis2MessageContext(jaxwsMC);
// Now close the handlers
callCloseHandlers(newStart_inclusive, newEnd, newDirection);
if (log.isDebugEnabled()) {
log.debug("Handler threw ProtocolException...End running the handlers in reverse");
}
} catch (RuntimeException re) {
callCloseHandlers(newStart_inclusive, newEnd, newDirection);
throw re;
}
} else if (result == OTHER_EXCEPTION) {
if (log.isDebugEnabled()) {
log.debug("Handler threw unanticipated Exception...Start handler closure");
}
callCloseHandlers(newStart_inclusive, newEnd, newDirection);
// savedException initialized in HandlerChainProcessor.handleMessage
if (log.isDebugEnabled()) {
log.debug("Handler threw unanticipated Exception...End handler closure");
}
throw savedException;
}
} else { // everything was successful OR finished processing handlers
/*
* This is a little confusing. There are several cases we should be
* aware of. An incoming request with false expectResponse is
* equivalent to server inbound one-way, for example.
*
* An outgoing response is server outbound, and is always marked
* with a false expectResponse. The problem, however, is that the
* direction for the call to closehandlers will be incorrect. In
* this case, the handlers should be closed in the opposite order of
* the ORIGINAL invocation.
*/
if (mep.equals(MEP.REQUEST)) {
// a request that requires no response is a one-way message
// and we should only close whomever got invoked
callCloseHandlers(newStart_inclusive, newEnd, newDirection);
// As according to the Sun "experts", exceptions raised by
// handlers in one way invocation are discarded. They
// are NOT propagated to the user code.
if (savedException != null) {
log.warn("Exception thrown by a handler in one way invocation",
savedException);
//But do return failure so that we know not to send to server
return false;
}
}
else {
// it's a response, so we can safely assume that
// ALL the handlers were invoked on the request,
// so we need to close ALL of them
if (direction.equals(Direction.IN)) {
callCloseHandlers(handlers.size() - 1, 0, direction);
} else {
callCloseHandlers(0, handlers.size() - 1, direction);
}
if (savedException != null) {
// we have a saved exception, throw it (JAX-WS 9.3.2.1 "Throw
// ProtocolException or any other runtime exception --> No
// response" case.
throw savedException;
}
}
}
// If we've failed before this, we would have already thrown exception
// or returned false, so just return true here ... don't need to check result again.
return true;
}
/**
* Called during reversal and exception processing to place the
* current Message (edited by the Handlers) onto the MessageContext
* @param jaxwsMC
*/
private void placeMessageOnAxis2MessageContext(MessageContext jaxwsMC) {
if (log.isDebugEnabled()) {
log.debug("start placeMessageOnAxis2MessageContext");
}
try {
org.apache.axis2.context.MessageContext mc = jaxwsMC.getAxisMessageContext();
if (mc != null) {
Message message = jaxwsMC.getMessage();
if (message != null) {
if (log.isDebugEnabled()) {
log.debug("Place the (perhaps new or edited) Message on the MessageContext");
}
MessageUtils.putMessageOnMessageContext(message, mc);
} else {
if (log.isDebugEnabled()) {
log.debug("There is no Message. Message is not copied to the Axis2 MessageContext.");
}
}
} else {
if (log.isDebugEnabled()) {
log.debug("Axis2 MessageContext is not available. Message is not copied");
}
}
} catch (AxisFault e) {
throw ExceptionFactory.makeWebServiceException(e);
}
if (log.isDebugEnabled()) {
log.debug("end placeMessageOnAxis2MessageContext");
}
}
/*
* callGenericHandlers_avoidRecursion should ONLY be called from one place.
* TODO: We cannot necessarily assume no false returns and no exceptions will be
* thrown from here even though the handlers we will be calling have all already
* succeeded in callGenericHandlers.
*/
private void callGenericHandlers_avoidRecursion(int start,
int end, Direction direction) {
int i = start;
if (direction == Direction.OUT) {
for (; i <= end; i++) {
switchContext(direction, i);
Handler handler = (Handler) handlers.get(i);
if (log.isDebugEnabled()) {
log.debug("Invoking handleMessage on: " + handler.getClass().getName());
}
callHandleMessageWithTracker(handler);
}
} else { // IN case
for (; i >= end; i--) {
switchContext(direction, i);
Handler handler = (Handler) handlers.get(i);
if (log.isDebugEnabled()) {
log.debug("Invoking handleMessage on: " + handler.getClass().getName());
}
callHandleMessageWithTracker(handler);
}
}
}
/**
* Calls handleMessage on the Handler. If an exception is thrown and a response is expected, the
* MessageContext is updated with the handler information
*
* @returns SUCCESSFUL if successfully, UNSUCCESSFUL if false, EXCEPTION if exception thrown
*/
private int handleMessage(Handler handler, Direction direction,
boolean expectResponse) throws RuntimeException {
try {
if (log.isDebugEnabled()) {
log.debug("Invoking handleMessage on: " + handler.getClass().getName());
}
// The pre and post invokers will likely need more than just the handler message context.
// They may need access to the axis service object or description objects.
currentMC.put(Constants.MEP_CONTEXT, mepCtx);
getPreInvoker().preInvoke(currentMC);
boolean success = callHandleMessageWithTracker(handler);
getPostInvoker().postInvoke(currentMC);
if (success) {
if (log.isDebugEnabled()) {
log.debug("handleMessage() returned true");
}
return SUCCESSFUL;
}
else {
if (log.isDebugEnabled()) {
log.debug("handleMessage() returned false");
}
if (expectResponse)
currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
(direction != Direction.OUT));
return FAILED;
}
}
catch (RuntimeException re) {
// RuntimeException and ProtocolException
if(log.isDebugEnabled()) {
log.debug("An exception was thrown during the handleMessage() invocation");
log.debug("Exception: ", re);
}
savedException = re;
if (expectResponse)
// mark it as reverse direction
currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY,
(direction != Direction.OUT));
if (ProtocolException.class.isAssignableFrom(re.getClass())) {
convertToFaultMessage(mepCtx, re, proto, true);
// just re-initialize the current handler message context since
// that will pick up the now-changed message
return PROTOCOL_EXCEPTION;
}
return OTHER_EXCEPTION;
}
}
/*
* start and end should be INclusive of the handlers that have already been
* invoked on Handler.handleMessage or Handler.handleFault
*/
private void callCloseHandlers(int start, int end,
Direction direction) {
int i = start;
if (direction == Direction.OUT) {
for (; i <= end; i++) {
try {
switchContext(direction, i);
Handler handler = (Handler) handlers.get(i);
if (log.isDebugEnabled()) {
log.debug("Invoking close on: " + handler.getClass().getName());
}
callCloseWithTracker(handler);
// TODO when we close, are we done with the handler instance, and thus
// may call the PreDestroy annotated method? I don't think so, especially
// if we've cached the handler list somewhere.
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("An Exception occurred while calling handler.close()");
log.debug("Exception: " + e.getClass().getName() + ":" + e.getMessage());
}
}
}
} else { // IN case
for (; i >= end; i--) {
try {
switchContext(direction, i);
Handler handler = (Handler) handlers.get(i);
if (log.isDebugEnabled()) {
log.debug("Invoking close on: " + handler.getClass().getName());
}
callCloseWithTracker(handler);
// TODO when we close, are we done with the handler instance, and thus
// may call the PreDestroy annotated method? I don't think so, especially
// if we've cached the handler list somewhere.
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("An Exception occurred while calling handler.close()");
log.debug("Exception: " + e.getClass().getName() + ":" + e.getMessage());
}
}
}
}
}
/*
* processFault is available for a server to use when the endpoint
* throws an exception or a client when it gets a fault response message
*
* In both cases, all of the handlers have run successfully in the
* opposite direction as this call to callHandleFault, and thus
* should be closed.
*/
public void processFault(MEPContext mepCtx, Direction direction) {
// direction.IN = client
// direction.OUT = server
if (handlers.size() == 0)
return;
this.mepCtx = mepCtx;
sortChain();
initContext(direction);
currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY, (direction == Direction.OUT));
try {
if (direction == Direction.OUT) {
callGenericHandleFault(0, handlers.size() - 1, direction);
} else { // IN case
callGenericHandleFault(handlers.size() - 1, 0, direction);
}
} catch (RuntimeException re) {
if (log.isDebugEnabled()) {
log.debug("An exception occurred during handleFault chain processing", re);
}
throw re;
} finally {
// we can close all the Handlers in reverse order
if (direction == Direction.OUT) {
initContext(Direction.IN);
callCloseHandlers(0, handlers.size() - 1, Direction.OUT);
} else { // IN case
initContext(Direction.IN);
callCloseHandlers(handlers.size() - 1, 0, Direction.IN);
}
}
}
/*
* The callGenericHandleFault caller is responsible for closing any invoked
* Handlers. We don't know how far the Handler.handleMessage calls got
* before a failure may have occurred.
*
* Regardless of the Handler.handleFault result, the flow is the same (9.3.2.2)
*/
private void callGenericHandleFault(int start, int end,
Direction direction) throws RuntimeException {
int i = start;
// we may be starting in the middle of the list, and therefore may need to switch contexts
switchContext(direction, i);
if (direction == Direction.OUT) {
for (; i <= end; i++) {
Handler handler = (Handler) handlers.get(i);
if (log.isDebugEnabled()) {
log.debug("Invoking handleFault on: " + handler.getClass().getName());
}
boolean success = callHandleFaultWithTracker(handler);
if (!success)
break;
switchContext(direction, i + 1);
}
} else { // IN case
for (; i >= end; i--) {
Handler handler = (Handler) handlers.get(i);
if (log.isDebugEnabled()) {
log.debug("Invoking handleFault on: " + handler.getClass().getName());
}
boolean success = callHandleFaultWithTracker(handler);
if (!success)
break;
switchContext(direction, i - 1);
}
}
}
public static void convertToFaultMessage(MEPContext mepCtx, Exception e, Protocol protocol) {
convertToFaultMessage(mepCtx, e, protocol, false);
}
/**
* Converts the Exception into an XML Fault Message that is stored on the MEPContext.
* Note that if the forceConversion flag is true, this conversion will always occur.
* If the checkMsg flag is true, this conversion only occurs if the Message is not already
* a Fault (per 9,3,2.1 of the JAX-WS specification)
*
* @param mepCtx MEPContext
* @param e Exception
* @param protocol Protocol
* @param forceConversion If true, the Exception is always converted to a Message
*/
public static void convertToFaultMessage(MEPContext mepCtx,
Exception e,
Protocol protocol,
boolean checkMsg) {
// need to check if message is already a fault message or not,
// probably by way of a flag (isFault) in the MessageContext or Message
if (log.isDebugEnabled()) {
log.debug("start convertToFaultMessge with exception: " + e.getClass().getName());
log.debug(" checkMsg is : " + checkMsg);
}
try {
// According to the 9.3.2.1, The message is converted into a fault only if it is not already a Fault
Message messageFromHandler = null;
if (checkMsg) {
messageFromHandler = mepCtx.getMessageContext().getMessage();
}
if (messageFromHandler != null && messageFromHandler.isFault()) {
if (log.isDebugEnabled()) {
log.debug("The Message is already a SOAPFault. The exception is not converted into a Message");
}
} else if (protocol == Protocol.soap11 || protocol == Protocol.soap12) {
if (log.isDebugEnabled()) {
log.debug("Converting Exception into a Message");
}
String protocolNS = (protocol == Protocol.soap11) ?
SOAPConstants.URI_NS_SOAP_1_1_ENVELOPE :
SOAPConstants.URI_NS_SOAP_1_2_ENVELOPE;
// The following set of instructions is used to avoid
// some unimplemented methods in the Axis2 SAAJ implementation
XMLFault xmlFault = MethodMarshallerUtils.createXMLFaultFromSystemException(e);
javax.xml.soap.MessageFactory mf = SAAJFactory.createMessageFactory(protocolNS);
SOAPMessage message = mf.createMessage();
SOAPBody body = message.getSOAPBody();
SOAPFault soapFault = XMLFaultUtils.createSAAJFault(xmlFault, body);
MessageFactory msgFactory = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class);
Message msg = msgFactory.createFrom(message);
mepCtx.setMessage(msg);
} else {
WebServiceException wse = ExceptionFactory.makeWebServiceException(Messages.getMessage("cFaultMsgErr"));
if (log.isDebugEnabled()) {
log.debug("end convertToFaultMessge due to error ", wse);
}
throw wse;
}
} catch (Exception ex) {
WebServiceException wse =ExceptionFactory.makeWebServiceException(ex);
if (log.isDebugEnabled()) {
log.debug("end convertToFaultMessge due to error ", wse);
}
throw wse;
}
}
private void initContext(Direction direction) {
soapMC = MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
logicalMC = MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
if (direction == Direction.OUT) {
// logical context, then SOAP
if ((logicalLength == 0) && (handlers.size() > 0)) // we only have soap handlers
currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
else
currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
} else {
// SOAP context, then logical
if ((logicalLength == handlers.size()) && (handlers.size() > 0)) // we only have logical handlers
currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
else
currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
}
}
private void switchContext(Direction direction, int index) {
if ((logicalLength == handlers.size()) || (logicalLength == 0))
return; // all handlers must be the same type, so no context switch
if (((direction == Direction.OUT) && (index == logicalLength))
|| ((direction == Direction.IN) && (index == (logicalLength - 1)))) {
//if (currentMC.getClass().isAssignableFrom(LogicalMessageContext.class))
if (currentMC == logicalMC) // object check, not .equals()
currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext());
else
currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext());
}
}
private HandlerPreInvoker getPreInvoker() {
if (handlerPreInvoker == null) {
HandlerPreInvokerFactory preInvokerFactory = (HandlerPreInvokerFactory)FactoryRegistry.getFactory(HandlerPreInvokerFactory.class);
handlerPreInvoker = (HandlerPreInvoker)preInvokerFactory.createHandlerPreInvoker();
}
return handlerPreInvoker;
}
private HandlerPostInvoker getPostInvoker() {
if (handlerPostInvoker == null) {
HandlerPostInvokerFactory postInvokerFactory = (HandlerPostInvokerFactory)FactoryRegistry.getFactory(HandlerPostInvokerFactory.class);
handlerPostInvoker = (HandlerPostInvoker)postInvokerFactory.createHandlerPostInvoker();
}
return handlerPostInvoker;
}
public static void trackInternalCall(org.apache.axis2.jaxws.core.MessageContext mc, TRACKER tracker) {
switch (tracker) {
case SAAJ_CALLED:
saaj_called = true;
break;
case SOAP_HEADERS_ADAPTER_CALLED:
soap_headers_adapter_called = true;
break;
}
Object trackerProp = (mc == null ? null : mc.getProperty(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER));
if ((trackerProp != null) && ((Boolean)trackerProp).booleanValue()) {
if (saaj_called && soap_headers_adapter_called) {
// this means both the SAAJ model and SOAPHeadersAdapter code has been called in such a
// way as to cause data transformation. We want customers to avoid doing this (calling both)
// in a given handler method, so we throw an exception:
if (log.isDebugEnabled()) {
String logString = "JAX-WS Handler implementations should not use the " + org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER
+ " property to retrieve SOAP headers and manipulate the SOAP message using the SAAJ API in the same method "
+ "implementation. The Handler implementation and method doing this is: "
+ currentHandler.getClass().getName() + currentMethod;
log.debug(logString);
}
}
}
}
private boolean callHandleMessageWithTracker(Handler handler) throws RuntimeException {
currentHandler = handler;
currentMethod = "handleMessage";
// turn on the tracker property
currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true);
boolean success = false;
RuntimeException savedEx = null;
try {
success = handler.handleMessage(currentMC);
} catch (RuntimeException t) {
savedEx = t;
}
// turn off the tracker property and reset the static tracker booleans
currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false);
saaj_called = false;
soap_headers_adapter_called = false;
// If the handler changed the SOAPPart or Attachments, then we need
// that the Message gets updated
if (currentMC instanceof SoapMessageContext){
((SoapMessageContext)currentMC).checkAndUpdate();
}
if (savedEx != null) {
throw savedEx;
}
return success;
}
private boolean callHandleFaultWithTracker(Handler handler) {
currentHandler = handler;
currentMethod = "handleFault";
// turn on the tracker property
currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true);
boolean success = false;
RuntimeException savedEx = null;
try {
success = handler.handleFault(currentMC);
} catch (RuntimeException t) {
savedEx = t;
}
// turn off the tracker property and reset the static tracker booleans
currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false);
saaj_called = false;
soap_headers_adapter_called = false;
// If the handler changed the SOAPPart or Attachments, then we need
// that the Message gets updated
if (currentMC instanceof SoapMessageContext){
((SoapMessageContext)currentMC).checkAndUpdate();
}
if (savedEx != null) {
throw savedEx;
}
return success;
}
private void callCloseWithTracker(Handler handler) {
currentHandler = handler;
currentMethod = "close";
// turn on the tracker property
currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true);
RuntimeException savedEx = null;
try {
handler.close(currentMC);
} catch (RuntimeException t) {
savedEx = t;
}
// turn off the tracker property and reset the static tracker booleans
currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false);
saaj_called = false;
soap_headers_adapter_called = false;
if (savedEx != null) {
throw savedEx;
}
}
}