if (operationContext != null) {
operationContext.setProperty(SandeshaClientConstants.SANDESHA_LISTENER, faultCallback);
}
}
StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configContext, configContext
.getAxisConfiguration());
boolean serverSide = msgContext.isServerSide();
// setting message Id if null
if (msgContext.getMessageID() == null)
msgContext.setMessageID(SandeshaUtil.getUUID());
// find internal sequence id
String internalSequenceId = null;
String storageKey = SandeshaUtil.getUUID(); // the key which will be
// used to store this
// message.
/*
* Internal sequence id is the one used to refer to the sequence (since
* actual sequence id is not available when first msg arrives) server
* side - a derivation of the sequenceId of the incoming sequence client
* side - a derivation of wsaTo & SeequenceKey
*/
boolean lastMessage = false;
if (serverSide) {
if (inboundSequence == null || "".equals(inboundSequence)) {
String message = SandeshaMessageHelper.getMessage(SandeshaMessageKeys.incomingSequenceNotValidID, inboundSequence);
log.debug(message);
throw new SandeshaException(message);
}
internalSequenceId = SandeshaUtil.getOutgoingSideInternalSequenceID(inboundSequence);
} else {
// set the internal sequence id for the client side.
EndpointReference toEPR = msgContext.getTo();
if (toEPR == null || toEPR.getAddress() == null || "".equals(toEPR.getAddress())) {
String message = SandeshaMessageHelper.getMessage(SandeshaMessageKeys.toEPRNotValid, null);
log.debug(message);
throw new SandeshaException(message);
}
String to = toEPR.getAddress();
String sequenceKey = (String) msgContext.getProperty(SandeshaClientConstants.SEQUENCE_KEY);
internalSequenceId = SandeshaUtil.getInternalSequenceID(to, sequenceKey);
String lastAppMessage = (String) msgContext.getProperty(SandeshaClientConstants.LAST_MESSAGE);
if (lastAppMessage != null && "true".equals(lastAppMessage))
lastMessage = true;
}
if (internalSequenceId!=null)
rmMsgCtx.setProperty(Sandesha2Constants.MessageContextProperties.INTERNAL_SEQUENCE_ID,internalSequenceId);
/*
* checking weather the user has given the messageNumber (most of the
* cases this will not be the case where the system will generate the
* message numbers
*/
// User should set it as a long object.
Long messageNumberLng = (Long) msgContext.getProperty(SandeshaClientConstants.MESSAGE_NUMBER);
long givenMessageNumber = -1;
if (messageNumberLng != null) {
givenMessageNumber = messageNumberLng.longValue();
if (givenMessageNumber <= 0) {
throw new SandeshaException(SandeshaMessageHelper.getMessage(
SandeshaMessageKeys.msgNumberMustBeLargerThanZero, Long.toString(givenMessageNumber)));
}
}
// A dummy message is a one which will not be processed as a actual
// application message.
// The RM handlers will simply let these go.
String dummyMessageString = (String) msgContext.getOptions().getProperty(SandeshaClientConstants.DUMMY_MESSAGE);
boolean dummyMessage = false;
if (dummyMessageString != null && Sandesha2Constants.VALUE_TRUE.equals(dummyMessageString))
dummyMessage = true;
RMSBean rmsBean = SandeshaUtil.getRMSBeanFromInternalSequenceId(storageManager, internalSequenceId);
//see if the sequence is closed
if(rmsBean != null && rmsBean.isSequenceClosedClient()){
throw new SandeshaException(SandeshaMessageHelper.getMessage(SandeshaMessageKeys.cannotSendMsgAsSequenceClosed, internalSequenceId));
}
//see if the sequence is terminated
if(rmsBean != null && rmsBean.isTerminateAdded()) {
throw new SandeshaException(SandeshaMessageHelper.getMessage(SandeshaMessageKeys.cannotSendMsgAsSequenceTerminated, internalSequenceId));
}
//see if the sequence is timed out
if(rmsBean != null && rmsBean.isTimedOut()){
throw new SandeshaException(SandeshaMessageHelper.getMessage(SandeshaMessageKeys.cannotSendMsgAsSequenceTimedout, internalSequenceId));
}
// If the call application is a 2-way MEP, and uses a anonymous replyTo, and the
// RM 1.1 spec level, then we must have MakeConnection enabled. We check that here,
// before we start creating a new Sequence.
if(!serverSide) {
AxisOperation op = msgContext.getAxisOperation();
int mep = WSDLConstants.MEP_CONSTANT_INVALID;
if(op != null) {
mep = op.getAxisSpecifMEPConstant();
}
if(mep == WSDLConstants.MEP_CONSTANT_OUT_IN) {
String specVersion = null;
if(rmsBean == null) {
specVersion = SequenceManager.getSpecVersion(msgContext, storageManager);
} else {
specVersion = rmsBean.getRMVersion();
}
if(specVersion == Sandesha2Constants.SPEC_VERSIONS.v1_1) {
SandeshaPolicyBean policy = SandeshaUtil.getPropertyBean(configContext.getAxisConfiguration());
if(!policy.isEnableMakeConnection()) {
String message = SandeshaMessageHelper.getMessage(SandeshaMessageKeys.makeConnectionDisabled);
throw new SandeshaException(message);
}
}
}
}
//setting the reference msg store key.
if (rmsBean!=null && rmsBean.getReferenceMessageStoreKey()==null) {
//setting this application message as the reference, if it hsnt already been set.
String referenceMsgKey = SandeshaUtil.getUUID();
storageManager.storeMessageContext(referenceMsgKey, msgContext);
rmsBean.setReferenceMessageStoreKey(referenceMsgKey);
}
String outSequenceID = null;
if (rmsBean == null) {
// SENDING THE CREATE SEQUENCE.
synchronized (RMSBeanMgr.class) {
// There is a timing window where 2 sending threads can hit this point
// at the same time and both will create an RMSBean to the same endpoint
// with the same internal sequenceid
// Check that someone hasn't created the bean
rmsBean = SandeshaUtil.getRMSBeanFromInternalSequenceId(storageManager, internalSequenceId);
// if first message - setup the sending side sequence - both for the
// server and the client sides.
if (rmsBean == null) {
rmsBean = SequenceManager.setupNewClientSequence(msgContext, internalSequenceId, storageManager);
rmsBean = addCreateSequenceMessage(rmMsgCtx, rmsBean, storageManager);
}
}
} else {
outSequenceID = rmsBean.getSequenceID();
}
// the message number that was last used.
long systemMessageNumber = rmsBean.getNextMessageNumber();
// The number given by the user has to be larger than the last stored
// number.
if (givenMessageNumber > 0 && givenMessageNumber <= systemMessageNumber) {
String message = SandeshaMessageHelper.getMessage(SandeshaMessageKeys.msgNumberNotLargerThanLastMsg, Long
.toString(givenMessageNumber));
throw new SandeshaException(message);
}
// Finding the correct message number.
long messageNumber = -1;
if (givenMessageNumber > 0) // if given message number is valid use it.
// (this is larger than the last stored due
// to the last check)
messageNumber = givenMessageNumber;
else if (systemMessageNumber > 0) { // if system message number is valid
// use it.
messageNumber = systemMessageNumber + 1;
} else { // This is the first message (systemMessageNumber = -1)
messageNumber = 1;
}
if (serverSide) {
// Deciding whether this is the last message. We assume it is if it relates to
// a message which arrived with the LastMessage flag on it.
RMDBean rmdBean = SandeshaUtil.getRMDBeanFromSequenceId(storageManager, inboundSequence);
// Get the last in message
String lastRequestId = rmdBean.getLastInMessageId();
RelatesTo relatesTo = msgContext.getRelatesTo();
if(relatesTo != null && lastRequestId != null &&
lastRequestId.equals(relatesTo.getValue())) {
lastMessage = true;
}
//or a constant property may call it as the last msg
Boolean inboundLast = (Boolean) msgContext.getProperty(Sandesha2Constants.MessageContextProperties.INBOUND_LAST_MESSAGE);
if (inboundLast!=null && inboundLast.booleanValue())
lastMessage = true;
}
if (lastMessage)
rmsBean.setLastOutMessage(messageNumber);
// set this as the response highest message.
rmsBean.setHighestOutMessageNumber(messageNumber);
// saving the used message number, and the expected reply count
boolean startPolling = false;
if (!dummyMessage) {
rmsBean.setNextMessageNumber(messageNumber);
// Identify the MEP associated with the message.
AxisOperation op = msgContext.getAxisOperation();
int mep = WSDLConstants.MEP_CONSTANT_INVALID;
if(op != null) {
mep = op.getAxisSpecifMEPConstant();
}
if(mep == WSDLConstants.MEP_CONSTANT_OUT_IN) {
// We only match up requests and replies when we are doing sync interactions
EndpointReference replyTo = msgContext.getReplyTo();
if(replyTo == null || replyTo.hasAnonymousAddress()) {
long expectedReplies = rmsBean.getExpectedReplies();
rmsBean.setExpectedReplies(expectedReplies + 1);
}
// If we support the RM anonymous URI then rewrite the ws-a anon to use the RM equivalent.
//(do should be done only for WSRM 1.1)
if (Sandesha2Constants.SPEC_VERSIONS.v1_1.equals(rmMsgCtx.getRMSpecVersion())) {
String oldAddress = (replyTo == null) ? null : replyTo.getAddress();
EndpointReference newReplyTo = SandeshaUtil.rewriteEPR(rmsBean, msgContext
.getReplyTo(), configContext);
String newAddress = (newReplyTo == null) ? null : newReplyTo.getAddress();
if (newAddress != null && !newAddress.equals(oldAddress)) {
// We have rewritten the replyTo. If this is the first message that we have needed to
// rewrite then we should set the sequence up for polling, and once we have saved the
// changes to the sequence then we can start the polling thread.
msgContext.setReplyTo(newReplyTo);
if (!rmsBean.isPollingMode()) {
rmsBean.setPollingMode(true);
startPolling = true;
}
}
}
}
}
RelatesTo relatesTo = msgContext.getRelatesTo();
if(relatesTo != null) {
rmsBean.setHighestOutRelatesTo(relatesTo.getValue());
}
// setting async ack endpoint for the server side. (if present)
if (serverSide) {
if (rmsBean.getToEPR() != null) {
msgContext.setProperty(SandeshaClientConstants.AcksTo, rmsBean.getToEPR());
}
}
// Update the rmsBean
storageManager.getRMSBeanMgr().update(rmsBean);
if(startPolling) {
SandeshaUtil.startWorkersForSequence(msgContext.getConfigurationContext(), rmsBean);
}