/** Auto generated method signature */
public void setEmp(com.pa.SetEmp setEmp3) throws java.rmi.RemoteException {
org.apache.axis2.context.MessageContext _messageContext = null;
org.apache.axis2.client.OperationClient _operationClient =
_serviceClient.createClient(_operations[0].getName());
_operationClient.getOptions().setAction("urn:setEmp");
_operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
addPropertyToOperationClient(
_operationClient,
org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,
"&");
org.apache.axiom.soap.SOAPEnvelope env = null;
_messageContext = new org.apache.axis2.context.MessageContext();
// Style is Doc.
env =
toEnvelope(
getFactory(_operationClient.getOptions().getSoapVersionURI()),
setEmp3,
optimizeContent(new javax.xml.namespace.QName("http://pa.com", "setEmp")),
new javax.xml.namespace.QName("http://pa.com", "setEmp"));
// adding SOAP soap_headers
_serviceClient.addHeadersToEnvelope(env);
// create message context with that soap envelope
_messageContext.setEnvelope(env);
// add the message contxt to the operation client
_operationClient.addMessageContext(_messageContext);
_operationClient.execute(true);
if (_messageContext.getTransportOut() != null) {
_messageContext.getTransportOut().getSender().cleanup(_messageContext);
}
return;
}
/**
* Auto generated method signature
*
* @see com.pa.SecondFileService#getEmp
* @param getEmp4
*/
public com.pa.GetEmpResponse getEmp(com.pa.GetEmp getEmp4) throws java.rmi.RemoteException {
org.apache.axis2.context.MessageContext _messageContext = null;
try {
org.apache.axis2.client.OperationClient _operationClient =
_serviceClient.createClient(_operations[1].getName());
_operationClient.getOptions().setAction("urn:getEmp");
_operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
addPropertyToOperationClient(
_operationClient,
org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,
"&");
// create a message context
_messageContext = new org.apache.axis2.context.MessageContext();
// create SOAP envelope with that payload
org.apache.axiom.soap.SOAPEnvelope env = null;
env =
toEnvelope(
getFactory(_operationClient.getOptions().getSoapVersionURI()),
getEmp4,
optimizeContent(new javax.xml.namespace.QName("http://pa.com", "getEmp")),
new javax.xml.namespace.QName("http://pa.com", "getEmp"));
// adding SOAP soap_headers
_serviceClient.addHeadersToEnvelope(env);
// set the message context with that soap envelope
_messageContext.setEnvelope(env);
// add the message contxt to the operation client
_operationClient.addMessageContext(_messageContext);
// execute the operation client
_operationClient.execute(true);
org.apache.axis2.context.MessageContext _returnMessageContext =
_operationClient.getMessageContext(
org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
java.lang.Object object =
fromOM(
_returnEnv.getBody().getFirstElement(),
com.pa.GetEmpResponse.class,
getEnvelopeNamespaces(_returnEnv));
return (com.pa.GetEmpResponse) object;
} catch (org.apache.axis2.AxisFault f) {
org.apache.axiom.om.OMElement faultElt = f.getDetail();
if (faultElt != null) {
if (faultExceptionNameMap.containsKey(
new org.apache.axis2.client.FaultMapKey(faultElt.getQName(), "getEmp"))) {
// make the fault by reflection
try {
java.lang.String exceptionClassName =
(java.lang.String)
faultExceptionClassNameMap.get(
new org.apache.axis2.client.FaultMapKey(faultElt.getQName(), "getEmp"));
java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName);
java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class);
java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage());
// message class
java.lang.String messageClassName =
(java.lang.String)
faultMessageMap.get(
new org.apache.axis2.client.FaultMapKey(faultElt.getQName(), "getEmp"));
java.lang.Class messageClass = java.lang.Class.forName(messageClassName);
java.lang.Object messageObject = fromOM(faultElt, messageClass, null);
java.lang.reflect.Method m =
exceptionClass.getMethod("setFaultMessage", new java.lang.Class[] {messageClass});
m.invoke(ex, new java.lang.Object[] {messageObject});
throw new java.rmi.RemoteException(ex.getMessage(), ex);
} catch (java.lang.ClassCastException e) {
// we cannot intantiate the class - throw the original Axis fault
throw f;
} catch (java.lang.ClassNotFoundException e) {
// we cannot intantiate the class - throw the original Axis fault
throw f;
} catch (java.lang.NoSuchMethodException e) {
// we cannot intantiate the class - throw the original Axis fault
throw f;
} catch (java.lang.reflect.InvocationTargetException e) {
// we cannot intantiate the class - throw the original Axis fault
throw f;
} catch (java.lang.IllegalAccessException e) {
// we cannot intantiate the class - throw the original Axis fault
throw f;
} catch (java.lang.InstantiationException e) {
// we cannot intantiate the class - throw the original Axis fault
throw f;
}
} else {
throw f;
}
} else {
throw f;
}
} finally {
if (_messageContext.getTransportOut() != null) {
_messageContext.getTransportOut().getSender().cleanup(_messageContext);
}
}
}
/**
* Handle the response or error (during a failed send) message received for an outgoing request
*
* @param messageID Request message ID
* @param response the Axis2 MessageContext that has been received and has to be handled
* @param synapseOutMsgCtx the corresponding (outgoing) Synapse MessageContext for the above Axis2
* MC, that holds Synapse specific information such as the error handler stack and local
* properties etc.
* @throws AxisFault if the message cannot be processed
*/
private void handleMessage(
String messageID,
MessageContext response,
org.apache.synapse.MessageContext synapseOutMsgCtx,
AsyncCallback callback)
throws AxisFault {
// apply the tenant information to the out message context
TenantInfoConfigurator configurator =
synapseOutMsgCtx.getEnvironment().getTenantInfoConfigurator();
if (configurator != null) {
configurator.applyTenantInfo(synapseOutMsgCtx);
}
Object o = response.getProperty(SynapseConstants.SENDING_FAULT);
if (o != null && Boolean.TRUE.equals(o)) {
StatisticsReporter.reportFaultForAll(
synapseOutMsgCtx, ErrorLogFactory.createErrorLog(response));
// there is a sending fault. propagate the fault to fault handlers.
Stack faultStack = synapseOutMsgCtx.getFaultStack();
if (faultStack != null && !faultStack.isEmpty()) {
// if we have access to the full synapseOutMsgCtx.getEnvelope(), then let
// it flow with the error details. Else, replace its envelope with the
// fault envelope
try {
synapseOutMsgCtx.getEnvelope().build();
} catch (OMException x) {
synapseOutMsgCtx.setEnvelope(response.getEnvelope());
}
Exception e = (Exception) response.getProperty(SynapseConstants.ERROR_EXCEPTION);
synapseOutMsgCtx.setProperty(SynapseConstants.SENDING_FAULT, Boolean.TRUE);
synapseOutMsgCtx.setProperty(
SynapseConstants.ERROR_CODE, response.getProperty(SynapseConstants.ERROR_CODE));
synapseOutMsgCtx.setProperty(
SynapseConstants.ERROR_MESSAGE, response.getProperty(SynapseConstants.ERROR_MESSAGE));
synapseOutMsgCtx.setProperty(
SynapseConstants.ERROR_DETAIL, response.getProperty(SynapseConstants.ERROR_DETAIL));
synapseOutMsgCtx.setProperty(SynapseConstants.ERROR_EXCEPTION, e);
if (log.isDebugEnabled()) {
log.debug(
"[Failed Request Message ID : "
+ messageID
+ "]"
+ " [New to be Retried Request Message ID : "
+ synapseOutMsgCtx.getMessageID()
+ "]");
}
int errorCode = (Integer) response.getProperty(SynapseConstants.ERROR_CODE);
// If a timeout has occured and the timeout action of the callback is to discard the message
if (errorCode == SynapseConstants.NHTTP_CONNECTION_TIMEOUT
&& callback.getTimeOutAction() == SynapseConstants.DISCARD) {
// Do not execute any fault sequences. Discard message
if (log.isWarnEnabled()) {
log.warn(
"Synapse timed out for the request with Message ID : "
+ messageID
+ ". Ignoring fault handlers since the timeout action is DISCARD");
}
faultStack.removeAllElements();
} else {
((FaultHandler) faultStack.pop()).handleFault(synapseOutMsgCtx, null);
}
}
} else {
// there can always be only one instance of an Endpoint in the faultStack of a message
// if the send was successful, so remove it before we proceed any further
Stack faultStack = synapseOutMsgCtx.getFaultStack();
Endpoint successfulEndpoint = null;
if (faultStack != null && !faultStack.isEmpty() && faultStack.peek() instanceof Endpoint) {
successfulEndpoint = (Endpoint) faultStack.pop();
}
if (log.isDebugEnabled()) {
log.debug("Synapse received an asynchronous response message");
log.debug(
"Received To: " + (response.getTo() != null ? response.getTo().getAddress() : "null"));
log.debug(
"SOAPAction: "
+ (response.getSoapAction() != null ? response.getSoapAction() : "null"));
log.debug(
"WSA-Action: " + (response.getWSAAction() != null ? response.getWSAAction() : "null"));
String[] cids = response.getAttachmentMap().getAllContentIDs();
if (cids != null && cids.length > 0) {
for (String cid : cids) {
log.debug("Attachment : " + cid);
}
}
log.debug("Body : \n" + response.getEnvelope());
}
MessageContext axisOutMsgCtx =
((Axis2MessageContext) synapseOutMsgCtx).getAxis2MessageContext();
// Processes 'Accept-Encoding'
ResponseAcceptEncodingProcessor.process(response, axisOutMsgCtx);
response.setServiceContext(null);
response.setOperationContext(axisOutMsgCtx.getOperationContext());
response.setAxisMessage(
axisOutMsgCtx.getAxisOperation().getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE));
// set properties on response
response.setServerSide(true);
response.setProperty(SynapseConstants.ISRESPONSE_PROPERTY, Boolean.TRUE);
response.setProperty(
MessageContext.TRANSPORT_OUT, axisOutMsgCtx.getProperty(MessageContext.TRANSPORT_OUT));
response.setProperty(
org.apache.axis2.Constants.OUT_TRANSPORT_INFO,
axisOutMsgCtx.getProperty(org.apache.axis2.Constants.OUT_TRANSPORT_INFO));
response.setTransportIn(axisOutMsgCtx.getTransportIn());
response.setTransportOut(axisOutMsgCtx.getTransportOut());
// If request is REST assume that the response is REST too
response.setDoingREST(axisOutMsgCtx.isDoingREST());
if (axisOutMsgCtx.isDoingMTOM()) {
response.setDoingMTOM(true);
response.setProperty(
org.apache.axis2.Constants.Configuration.ENABLE_MTOM,
org.apache.axis2.Constants.VALUE_TRUE);
}
if (axisOutMsgCtx.isDoingSwA()) {
response.setDoingSwA(true);
response.setProperty(
org.apache.axis2.Constants.Configuration.ENABLE_SWA,
org.apache.axis2.Constants.VALUE_TRUE);
}
// when axis2 receives a soap message without addressing headers it users
// DISABLE_ADDRESSING_FOR_OUT_MESSAGES property to keep it and hence avoid addressing
// headers on the response. this causes a problem for synapse if the original message
// it receivs (from client) has addressing and the synaspse service invocation has not
// engage addressing. in this case when synapse receives the response from the server
// addessing In handler dissable addressing since that response does not have addressing
// headers. synapse sends the response to its orignal client using the same message
// context. Then this response does not have addressing headers since it already
// disable. to avoid this we need to set the DISABLE_ADDRESSING_FOR_OUT_MESSAGES
// property state to original state.
if (axisOutMsgCtx.getProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES)
!= null) {
response.setProperty(
AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES,
axisOutMsgCtx.getProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES));
} else {
response.removeProperty(AddressingConstants.DISABLE_ADDRESSING_FOR_OUT_MESSAGES);
}
Object messageType =
axisOutMsgCtx.getProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE);
if (!HTTPConstants.MEDIA_TYPE_X_WWW_FORM.equals(messageType)) {
// copy the message type property that's used by the out message to the
// response message
response.setProperty(org.apache.axis2.Constants.Configuration.MESSAGE_TYPE, messageType);
}
// compare original received message (axisOutMsgCtx) soap version with the response
// if they are different change to original version
if (axisOutMsgCtx.isSOAP11() != response.isSOAP11()) {
if (axisOutMsgCtx.isSOAP11()) {
SOAPUtils.convertSOAP12toSOAP11(response);
} else {
SOAPUtils.convertSOAP11toSOAP12(response);
}
}
if (axisOutMsgCtx.getMessageID() != null) {
response.setRelationships(new RelatesTo[] {new RelatesTo(axisOutMsgCtx.getMessageID())});
}
response.setReplyTo(axisOutMsgCtx.getReplyTo());
response.setFaultTo(axisOutMsgCtx.getFaultTo());
if (axisOutMsgCtx.isPropertyTrue(NhttpConstants.IGNORE_SC_ACCEPTED)) {
response.setProperty(NhttpConstants.FORCE_SC_ACCEPTED, Constants.VALUE_TRUE);
}
// create the synapse message context for the response
Axis2MessageContext synapseInMessageContext =
new Axis2MessageContext(
response, synapseOutMsgCtx.getConfiguration(), synapseOutMsgCtx.getEnvironment());
synapseInMessageContext.setResponse(true);
Object obj = synapseOutMsgCtx.getProperty(SynapseConstants.FORCE_ERROR_PROPERTY);
String errorOnSOAPFault = (String) obj;
if (Constants.VALUE_TRUE.equals(errorOnSOAPFault) && successfulEndpoint != null) {
if (log.isDebugEnabled()) {
log.debug("FORCE_ERROR_ON_SOAP_FAULT is true, checking for SOAPFault");
}
try {
RelayUtils.buildMessage(
((Axis2MessageContext) synapseInMessageContext).getAxis2MessageContext(), true);
} catch (Exception e) {
// handleException("Error while building message", e, synapseInMessageContext);
}
if ((synapseInMessageContext.getEnvelope() != null)
&& synapseInMessageContext.getEnvelope().hasFault()) {
if (log.isDebugEnabled()) {
log.debug(
"SOAPFault found in response message, forcing endpoint "
+ successfulEndpoint.getName()
+ " to fail");
}
// setup new pipe configuration..if failure happens (this will be setup as the source
// writer and during the TargetContext
// clean up operation the writer will be reset and pull to the buffer
MessageContext axis2OUTMC =
((Axis2MessageContext) synapseOutMsgCtx).getAxis2MessageContext();
NHttpServerConnection conn =
(NHttpServerConnection) axis2OUTMC.getProperty("pass-through.Source-Connection");
if (conn != null) {
SourceConfiguration sourceConfiguration =
(SourceConfiguration) axis2OUTMC.getProperty("PASS_THROUGH_SOURCE_CONFIGURATION");
Pipe pipe =
new Pipe(
conn,
sourceConfiguration.getBufferFactory().getBuffer(),
"source",
sourceConfiguration);
axis2OUTMC.setProperty(PassThroughConstants.PASS_THROUGH_PIPE, pipe);
}
StatisticsReporter.reportFaultForAll(
synapseOutMsgCtx, ErrorLogFactory.createErrorLog(response));
synapseOutMsgCtx.setProperty(SynapseConstants.SENDING_FAULT, Boolean.TRUE);
synapseOutMsgCtx.setProperty(
SynapseConstants.ERROR_CODE, SynapseConstants.ENDPOINT_CUSTOM_ERROR);
((FaultHandler) successfulEndpoint).handleFault(synapseOutMsgCtx, null);
return;
} else {
successfulEndpoint.onSuccess();
}
} else if (successfulEndpoint != null) {
successfulEndpoint.onSuccess();
}
synapseInMessageContext.setTo(
new EndpointReference(AddressingConstants.Final.WSA_ANONYMOUS_URL));
synapseInMessageContext.setTracingState(synapseOutMsgCtx.getTracingState());
// set the properties of the original MC to the new MC
for (Object key : synapseOutMsgCtx.getPropertyKeySet()) {
synapseInMessageContext.setProperty(
(String) key, synapseOutMsgCtx.getProperty((String) key));
}
// Copy SequenceCallStack from original MC to the new MC
if (synapseOutMsgCtx.isContinuationEnabled()) {
// Set the message direction
if (!synapseOutMsgCtx.isResponse()) {
synapseInMessageContext.setResponse(false);
}
Stack<ContinuationState> seqContinuationStates =
synapseOutMsgCtx.getContinuationStateStack();
for (int i = 0; i < seqContinuationStates.size(); i++) {
synapseInMessageContext.pushContinuationState(seqContinuationStates.get(i));
}
}
// If this response is related to session affinity endpoints -Server initiated session
Dispatcher dispatcher =
(Dispatcher)
synapseOutMsgCtx.getProperty(SynapseConstants.PROP_SAL_ENDPOINT_CURRENT_DISPATCHER);
if (dispatcher != null && dispatcher.isServerInitiatedSession()) {
dispatcher.updateSession(synapseInMessageContext);
}
StatisticsReporter.reportForAllOnResponseReceived(synapseInMessageContext);
// send the response message through the synapse mediation flow
try {
synapseOutMsgCtx.getEnvironment().injectMessage(synapseInMessageContext);
} catch (SynapseException syne) {
Stack stack = synapseInMessageContext.getFaultStack();
if (stack != null && !stack.isEmpty()) {
((FaultHandler) stack.pop()).handleFault(synapseInMessageContext, syne);
} else {
log.error(
"Synapse encountered an exception, "
+ "No error handlers found - [Message Dropped]\n"
+ syne.getMessage());
}
}
}
}
public CadConsultaCadastro2Stub.ConsultaCadastro2Result consultaCadastro2(
final CadConsultaCadastro2Stub.NfeDadosMsg nfeDadosMsg,
final CadConsultaCadastro2Stub.NfeCabecMsgE nfeCabecMsg)
throws java.rmi.RemoteException {
org.apache.axis2.context.MessageContext _messageContext = null;
try {
final org.apache.axis2.client.OperationClient _operationClient =
this._serviceClient.createClient(this._operations[0].getName());
_operationClient
.getOptions()
.setAction(
"http://www.portalfiscal.inf.br/nfe/wsdl/CadConsultaCadastro2/consultaCadastro2");
_operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true);
this.addPropertyToOperationClient(
_operationClient,
org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,
"&");
// create a message context
_messageContext = new org.apache.axis2.context.MessageContext();
// create SOAP envelope with that payload
org.apache.axiom.soap.SOAPEnvelope env = null;
env =
this.toEnvelope(
Stub.getFactory(_operationClient.getOptions().getSoapVersionURI()),
nfeDadosMsg,
this.optimizeContent(
new javax.xml.namespace.QName(
"http://www.portalfiscal.inf.br/nfe/wsdl/CadConsultaCadastro2",
"consultaCadastro2")),
new javax.xml.namespace.QName(
"http://www.portalfiscal.inf.br/nfe/wsdl/CadConsultaCadastro2",
"consultaCadastro2"));
env.build();
// add the children only if the parameter is not null
if (nfeCabecMsg != null) {
final org.apache.axiom.om.OMElement omElementnfeCabecMsg =
this.toOM(
nfeCabecMsg,
this.optimizeContent(
new javax.xml.namespace.QName(
"http://www.portalfiscal.inf.br/nfe/wsdl/CadConsultaCadastro2",
"consultaCadastro2")));
this.addHeader(omElementnfeCabecMsg, env);
}
// adding SOAP soap_headers
this._serviceClient.addHeadersToEnvelope(env);
// set the message context with that soap envelope
_messageContext.setEnvelope(env);
// add the message contxt to the operation client
_operationClient.addMessageContext(_messageContext);
// execute the operation client
_operationClient.execute(true);
final org.apache.axis2.context.MessageContext _returnMessageContext =
_operationClient.getMessageContext(
org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE);
final org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope();
final java.lang.Object object =
this.fromOM(
_returnEnv.getBody().getFirstElement(),
CadConsultaCadastro2Stub.ConsultaCadastro2Result.class,
this.getEnvelopeNamespaces(_returnEnv));
return (CadConsultaCadastro2Stub.ConsultaCadastro2Result) object;
} catch (final org.apache.axis2.AxisFault f) {
final org.apache.axiom.om.OMElement faultElt = f.getDetail();
if (faultElt != null) {
if (this.faultExceptionNameMap.containsKey(
new org.apache.axis2.client.FaultMapKey(faultElt.getQName(), "consultaCadastro2"))) {
// make the fault by reflection
try {
final java.lang.String exceptionClassName =
(java.lang.String)
this.faultExceptionClassNameMap.get(
new org.apache.axis2.client.FaultMapKey(
faultElt.getQName(), "consultaCadastro2"));
final Class<?> exceptionClass = java.lang.Class.forName(exceptionClassName);
final Constructor<?> constructor = exceptionClass.getConstructor(String.class);
final java.lang.Exception ex =
(java.lang.Exception) constructor.newInstance(f.getMessage());
// message class
final java.lang.String messageClassName =
(java.lang.String)
this.faultMessageMap.get(
new org.apache.axis2.client.FaultMapKey(
faultElt.getQName(), "consultaCadastro2"));
final Class<?> messageClass = java.lang.Class.forName(messageClassName);
final java.lang.Object messageObject = this.fromOM(faultElt, messageClass, null);
final java.lang.reflect.Method m =
exceptionClass.getMethod("setFaultMessage", messageClass);
m.invoke(ex, messageObject);
throw new java.rmi.RemoteException(ex.getMessage(), ex);
} catch (final ClassCastException
| InstantiationException
| IllegalAccessException
| java.lang.reflect.InvocationTargetException
| NoSuchMethodException
| ClassNotFoundException e) {
// we cannot intantiate the class - throw the original Axis fault
throw f;
}
} else {
throw f;
}
} else {
throw f;
}
} finally {
if (_messageContext.getTransportOut() != null) {
_messageContext.getTransportOut().getSender().cleanup(_messageContext);
}
}
}
public void executeImpl(boolean block) throws AxisFault {
// if the MEP is completed, throw a fault
if (completed) {
throw new AxisFault(Messages.getMessage("mepiscomplted"));
}
// if the OUT message is not set on the operation context, throw a fault
MessageContext outMsgCtx = oc.getMessageContext(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
if (outMsgCtx == null) {
throw new AxisFault(Messages.getMessage("outmsgctxnull"));
}
ConfigurationContext cfgCtx = sc.getConfigurationContext();
// set ClientOptions to the current outgoing message
outMsgCtx.setOptions(options);
// do Target Resolution
TargetResolver tr = cfgCtx.getAxisConfiguration().getTargetResolverChain();
if (tr != null) {
tr.resolveTarget(outMsgCtx);
}
// 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() : outMsgCtx.getTo();
transportOut =
ClientUtils.inferOutTransport(cfgCtx.getAxisConfiguration(), toEPR, outMsgCtx);
}
outMsgCtx.setTransportOut(transportOut);
if (options.getTransportIn() == null && outMsgCtx.getTransportIn() == null) {
outMsgCtx.setTransportIn(
ClientUtils.inferInTransport(cfgCtx.getAxisConfiguration(), options, outMsgCtx));
} else if (outMsgCtx.getTransportIn() == null) {
outMsgCtx.setTransportIn(options.getTransportIn());
}
// add reference parameters to To EPR
addReferenceParameters(outMsgCtx);
if (options.isUseSeparateListener()) {
options.setTransportIn(
outMsgCtx
.getConfigurationContext()
.getAxisConfiguration()
.getTransportIn(Constants.TRANSPORT_HTTP));
SynapseCallbackReceiver callbackReceiver =
(SynapseCallbackReceiver) axisOp.getMessageReceiver();
((Axis2MessageContext) ((AsyncCallback) axisCallback).getSynapseOutMsgCtx())
.getAxis2MessageContext()
.setProperty(NhttpConstants.IGNORE_SC_ACCEPTED, Constants.VALUE_TRUE);
callbackReceiver.addCallback(outMsgCtx.getMessageID(), axisCallback);
EndpointReference replyToFromTransport =
outMsgCtx
.getConfigurationContext()
.getListenerManager()
.getEPRforService(
sc.getAxisService().getName(),
axisOp.getName().getLocalPart(),
outMsgCtx.getTransportOut().getName());
if (outMsgCtx.getReplyTo() == null) {
outMsgCtx.setReplyTo(replyToFromTransport);
} else {
outMsgCtx.getReplyTo().setAddress(replyToFromTransport.getAddress());
}
outMsgCtx.getConfigurationContext().registerOperationContext(outMsgCtx.getMessageID(), oc);
AxisEngine.send(outMsgCtx);
// Options object reused so soapAction needs to be removed so
// that soapAction+wsa:Action on response don't conflict
options.setAction("");
} else {
SynapseCallbackReceiver callbackReceiver =
(SynapseCallbackReceiver) axisOp.getMessageReceiver();
callbackReceiver.addCallback(outMsgCtx.getMessageID(), axisCallback);
send(outMsgCtx);
}
}
private void send(MessageContext msgctx) throws AxisFault {
// create the responseMessageContext and set that its related to the current outgoing
// message, so that it could be tied back to the original request even if the response
// envelope does not contain addressing headers
MessageContext responseMessageContext = new MessageContext();
responseMessageContext.setMessageID(msgctx.getMessageID());
responseMessageContext.setProperty(
SynapseConstants.RELATES_TO_FOR_POX, msgctx.getMessageID());
responseMessageContext.setOptions(options);
responseMessageContext.setServerSide(true);
addMessageContext(responseMessageContext);
responseMessageContext.setProperty("synapse.send", "true");
AxisEngine.send(msgctx);
// did the engine receive a immediate synchronous response?
// e.g. sometimes the transport sender may listen for a syncronous reply
if (msgctx.getProperty(MessageContext.TRANSPORT_IN) != null) {
responseMessageContext.setOperationContext(msgctx.getOperationContext());
responseMessageContext.setAxisMessage(
msgctx
.getOperationContext()
.getAxisOperation()
.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE));
responseMessageContext.setAxisService(msgctx.getAxisService());
responseMessageContext.setProperty(
MessageContext.TRANSPORT_OUT, msgctx.getProperty(MessageContext.TRANSPORT_OUT));
responseMessageContext.setProperty(
org.apache.axis2.Constants.OUT_TRANSPORT_INFO,
msgctx.getProperty(org.apache.axis2.Constants.OUT_TRANSPORT_INFO));
responseMessageContext.setProperty(
org.apache.synapse.SynapseConstants.ISRESPONSE_PROPERTY, Boolean.TRUE);
responseMessageContext.setTransportIn(msgctx.getTransportIn());
responseMessageContext.setTransportOut(msgctx.getTransportOut());
// If request is REST assume that the responseMessageContext is REST too
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
Options options = responseMessageContext.getOptions();
if (options != null) {
RelatesTo relatesTo = options.getRelatesTo();
if (relatesTo != null) {
relatesTo.setValue(msgctx.getMessageID());
} else {
options.addRelatesTo(new RelatesTo(msgctx.getMessageID()));
}
}
SOAPEnvelope resenvelope = TransportUtils.createSOAPMessage(responseMessageContext);
if (resenvelope != null) {
responseMessageContext.setEnvelope(resenvelope);
AxisEngine.receive(responseMessageContext);
if (responseMessageContext.getReplyTo() != null) {
sc.setTargetEPR(responseMessageContext.getReplyTo());
}
complete(msgctx);
} else {
throw new AxisFault(Messages.getMessage("blockingInvocationExpectsResponse"));
}
}
}
}
