/*
* Copyright 2004,2006 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.axis2.description;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.soap.SOAPBody;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axiom.soap.SOAPFault;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.OperationClient;
import org.apache.axis2.client.Options;
import org.apache.axis2.client.async.AsyncResult;
import org.apache.axis2.client.async.Callback;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.context.OperationContext;
import org.apache.axis2.context.ServiceContext;
import org.apache.axis2.engine.AxisEngine;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.transport.TransportUtils;
import org.apache.axis2.util.CallbackReceiver;
import org.apache.axis2.util.UUIDGenerator;
import org.apache.axis2.wsdl.WSDLConstants;
import javax.xml.namespace.QName;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class OutInAxisOperation extends InOutAxisOperation {
public OutInAxisOperation() {
super();
setMessageExchangePattern(WSDL20_2004Constants.MEP_URI_OUT_IN);
}
public OutInAxisOperation(QName name) {
super(name);
setMessageExchangePattern(WSDL20_2004Constants.MEP_URI_OUT_IN);
}
public void addMessageContext(MessageContext msgContext,
OperationContext opContext) throws AxisFault {
HashMap mep = opContext.getMessageContexts();
MessageContext immsgContext = (MessageContext) mep
.get(MESSAGE_LABEL_IN_VALUE);
MessageContext outmsgContext = (MessageContext) mep
.get(MESSAGE_LABEL_OUT_VALUE);
if ((immsgContext != null) && (outmsgContext != null)) {
throw new AxisFault(Messages.getMessage("mepcompleted"));
}
if (outmsgContext == null) {
mep.put(MESSAGE_LABEL_OUT_VALUE, msgContext);
} else {
mep.put(MESSAGE_LABEL_IN_VALUE, msgContext);
opContext.setComplete(true);
}
}
/**
* Returns a MEP client for an Out-IN operation. This client can be used to
* interact with a server which is offering an In-Out operation. To use the
* client, you must call addMessageContext() with a message context and then
* call execute() to execute the client.
*
* @param sc The service context for this client to live within. Cannot be
* null.
* @param options Options to use as defaults for this client. If any options are
* set specifically on the client then those override options
* here.
*/
public OperationClient createClient(ServiceContext sc, Options options) {
return new OutInAxisOperationClient(this, sc, options);
}
}
/**
* MEP client for moi.
*/
class OutInAxisOperationClient implements OperationClient {
private AxisOperation axisOp;
protected ServiceContext sc;
protected Options options;
protected OperationContext oc;
protected Callback callback;
/*
* indicates whether the MEP execution has completed (and hence ready for
* resetting)
*/
boolean completed;
OutInAxisOperationClient(OutInAxisOperation axisOp, ServiceContext sc,
Options options) {
this.axisOp = axisOp;
this.sc = sc;
this.options = options;
this.completed = false;
this.oc = new OperationContext(axisOp);
this.oc.setParent(this.sc);
}
/**
* Sets the options that should be used for this particular client. This
* resets the entire set of options to use the new options - so you'd lose
* any option cascading that may have been set up.
*
* @param options the options
*/
public void setOptions(Options options) {
this.options = options;
}
/**
* Returns the options used by this client. If you want to set a single
* option, then the right way is to call getOptions() and set specific
* options.
*
* @return Returns the options, which will never be null.
*/
public Options getOptions() {
return options;
}
/**
* Adds message context to operation context , so that it will handle the
* logic correctly if the OperationContext is null then new one will be
* created , and Operation Context will become null when some one calls reset().
*
* @param mc
* @throws AxisFault
*/
public void addMessageContext(MessageContext mc) throws AxisFault {
mc.setServiceContext(sc);
if (mc.getMessageID() == null) {
setMessageID(mc);
}
axisOp.registerOperationContext(mc, oc);
}
/**
* Returns the message context for a given message label.
*
* @param messageLabel :
* label of the message and that can be either "Out" or "In" and
* nothing else
* @return Returns MessageContext.
* @throws AxisFault
*/
public MessageContext getMessageContext(String messageLabel)
throws AxisFault {
return oc.getMessageContext(messageLabel);
}
public void setCallback(Callback callback) {
this.callback = callback;
}
/**
* Create a message ID for the given message context if needed. If user gives an option with
* MessageID then just copy that into MessageContext , and with that there can be multiple
* message with same MessageID unless user call setOption for each invocation.
* <p/>
* If user want to give message ID then the better way is to set the message ID in the option and
* call setOption for each invocation then the right thing will happen.
* <p/>
* If user does not give a message ID then the new one will be created and set that into Message
* Context.
*
* @param mc the message context whose id is to be set
*/
private void setMessageID(MessageContext mc) {
// now its the time to put the parameters set by the user in to the
// correct places and to the
// if there is no message id still, set a new one.
String messageId = options.getMessageId();
if (messageId == null || "".equals(messageId)) {
messageId = UUIDGenerator.getUUID();
}
mc.setMessageID(messageId);
}
/**
* Executes the MEP. What this does depends on the specific MEP client. The
* basic idea is to have the MEP client execute and do something with the
* messages that have been added to it so far. For example, if its an Out-In
* MEP, then if the Out message has been set, then executing the client asks
* it to send the message and get the In message, possibly using a different
* thread.
*
* @param block Indicates whether execution should block or return ASAP. What
* block means is of course a function of the specific MEP
* client. IGNORED BY THIS MEP CLIENT.
* @throws AxisFault if something goes wrong during the execution of the MEP.
*/
public void execute(boolean block) throws AxisFault {
if (completed) {
throw new AxisFault(Messages.getMessage("mepiscomplted"));
}
ConfigurationContext cc = sc.getConfigurationContext();
// copy interesting info from options to message context.
MessageContext mc = oc
.getMessageContext(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
if (mc == null) {
throw new AxisFault(Messages.getMessage("outmsgctxnull"));
}
//setting AxisMessage
mc.setAxisMessage(axisOp.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE));
if (mc.getSoapAction() == null || "".equals(mc.getSoapAction())) {
mc.setSoapAction(options.getAction());
}
mc.setOptions(options);
// do Target Resolution
cc.getAxisConfiguration().getTargetResolverChain().resolveTarget(mc);
// if the transport to use for sending is not specified, try to find it
// from the URL
TransportOutDescription transportOut = options.getTransportOut();
if (transportOut == null) {
EndpointReference toEPR = (options.getTo() != null) ? options
.getTo() : mc.getTo();
transportOut = ClientUtils.inferOutTransport(cc
.getAxisConfiguration(), toEPR, mc);
}
mc.setTransportOut(transportOut);
if (options.getTransportIn() == null && mc.getTransportIn() == null) {
mc.setTransportIn(ClientUtils.inferInTransport(cc
.getAxisConfiguration(), options, mc));
} else if (mc.getTransportIn() == null) {
mc.setTransportIn(options.getTransportIn());
}
addReferenceParameters(mc);
if (options.isUseSeparateListener()) {
CallbackReceiver callbackReceiver = (CallbackReceiver) axisOp
.getMessageReceiver();
callbackReceiver.addCallback(mc.getMessageID(), callback);
/**
* If USE_CUSTOM_LISTENER is set to 'true' the replyTo value will not be replaced and Axis2 will not
* start its internal listner. Some other enntity (e.g. a module) should take care of obtaining the
* response message.
*/
Boolean useCustomListener = (Boolean) options.getProperty(Constants.Configuration.USE_CUSTOM_LISTENER);
if (useCustomListener==null || !useCustomListener.booleanValue()) {
EndpointReference replyToFromTransport = mc.getConfigurationContext().getListenerManager().
getEPRforService(sc.getAxisService().getName(), axisOp.getName().getLocalPart(), mc
.getTransportIn().getName()
.getLocalPart());
if (mc.getReplyTo() == null) {
mc.setReplyTo(replyToFromTransport);
} else {
mc.getReplyTo().setAddress(replyToFromTransport.getAddress());
}
}
//if we don't do this , this guy will wait till it gets HTTP 202 in the HTTP case
mc.setProperty(MessageContext.TRANSPORT_NON_BLOCKING, Boolean.TRUE);
AxisEngine engine = new AxisEngine(cc);
mc.getConfigurationContext().registerOperationContext(mc.getMessageID(), oc);
engine.send(mc);
} else {
if (block) {
// Send the SOAP Message and receive a response
MessageContext response = send(mc);
// check for a fault and return the result
if (response != null) {
SOAPEnvelope resEnvelope = response.getEnvelope();
if (resEnvelope.getBody().hasFault()) {
SOAPFault soapFault = resEnvelope.getBody().getFault();
//we need to call engine.receiveFault
AxisEngine engine = new AxisEngine(mc.getConfigurationContext());
engine.receiveFault(response);
if (options.isExceptionToBeThrownOnSOAPFault()) {
// does the SOAPFault has a detail element for Excpetion
throw new AxisFault(soapFault.getCode(), soapFault.getReason(),
soapFault.getNode(), soapFault.getRole(), soapFault.getDetail());
}
}
}
completed = true;
} else {
sc.getConfigurationContext().getThreadPool().execute(
new NonBlockingInvocationWorker(callback, mc));
}
}
}
private void addReferenceParameters(MessageContext msgctx) {
EndpointReference to = msgctx.getTo();
if (options.isManageSession()) {
EndpointReference tepr = sc.getTargetEPR();
if (tepr != null) {
Map map = tepr.getAllReferenceParameters();
if (map != null) {
Iterator valuse = map.values().iterator();
while (valuse.hasNext()) {
Object refparaelement = valuse.next();
if (refparaelement instanceof OMElement) {
to.addReferenceParameter((OMElement) refparaelement);
}
}
}
}
}
}
/**
* @param msgctx
* @return Returns MessageContext.
* @throws AxisFault Sends the message using a two way transport and waits for a response
*/
protected MessageContext send(MessageContext msgctx) throws AxisFault {
AxisEngine engine = new AxisEngine(msgctx.getConfigurationContext());
// create the responseMessageContext
MessageContext responseMessageContext = new MessageContext();
// This is a hack - Needs to change
responseMessageContext.setOptions(options);
responseMessageContext.setServerSide(false);
responseMessageContext.setMessageID(msgctx.getMessageID());
addMessageContext(responseMessageContext);
responseMessageContext.setServiceContext(msgctx.getServiceContext());
responseMessageContext.setAxisMessage(
axisOp.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE));
//sending the message
engine.send(msgctx);
responseMessageContext.setDoingREST(msgctx.isDoingREST());
responseMessageContext.setProperty(MessageContext.TRANSPORT_IN, msgctx
.getProperty(MessageContext.TRANSPORT_IN));
responseMessageContext.setTransportIn(msgctx.getTransportIn());
responseMessageContext.setTransportOut(msgctx.getTransportOut());
// Options object reused above so soapAction needs to be removed so
// that soapAction+wsa:Action on response don't conflict
responseMessageContext.setSoapAction("");
if (responseMessageContext.getEnvelope() == null) {
// If request is REST we assume the responseMessageContext is REST, so
// set the variable
SOAPEnvelope resenvelope = TransportUtils.createSOAPMessage(
responseMessageContext, msgctx.getEnvelope().getNamespace()
.getNamespaceURI());
if (resenvelope != null) {
responseMessageContext.setEnvelope(resenvelope);
engine = new AxisEngine(msgctx.getConfigurationContext());
engine.receive(responseMessageContext);
if (responseMessageContext.getReplyTo() != null) {
sc.setTargetEPR(responseMessageContext.getReplyTo());
}
} else {
throw new AxisFault(Messages
.getMessage("blockingInvocationExpectsResponse"));
}
}
return responseMessageContext;
}
/**
* Resets the MEP client to a clean status after the MEP has completed. This
* is how you can reuse a MEP client. NOTE: this does not reset the options;
* only the internal state so the client can be used again.
*
* @throws AxisFault if reset is called before the MEP client has completed an
* interaction.
*/
public void reset() throws AxisFault {
if (!completed) {
throw new AxisFault(Messages.getMessage("cannotreset"));
}
oc = null;
completed = false;
}
public void complete(MessageContext msgCtxt) throws AxisFault {
TransportOutDescription trsout = msgCtxt.getTransportOut();
if (trsout != null) {
trsout.getSender().cleanup(msgCtxt);
}
}
public OperationContext getOperationContext() {
return oc;
}
/**
* This class is the workhorse for a non-blocking invocation that uses a two
* way transport.
*/
private class NonBlockingInvocationWorker implements Runnable {
private Callback callback;
private MessageContext msgctx;
public NonBlockingInvocationWorker(Callback callback,
MessageContext msgctx) {
this.callback = callback;
this.msgctx = msgctx;
}
public void run() {
try {
// send the request and wait for response
MessageContext response = send(msgctx);
// call the callback
if (response != null) {
SOAPEnvelope resenvelope = response.getEnvelope();
SOAPBody body = resenvelope.getBody();
if (body.hasFault()) {
Exception ex = body.getFault().getException();
if (ex != null) {
callback.onError(ex);
} else {
callback.onError(new Exception(body.getFault()
.getReason().getText()));
}
} else {
AsyncResult asyncResult = new AsyncResult(response);
callback.onComplete(asyncResult);
}
}
} catch (Exception e) {
callback.onError(e);
} finally {
callback.setComplete(true);
}
}
}
}