/*
* Copyright 1999-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.sandesha2.util;
import java.util.ArrayList;
import java.util.Iterator;
import javax.xml.namespace.QName;
import org.apache.axis2.AxisFault;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.addressing.MessageInformationHeaders;
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.description.AxisOperation;
import org.apache.axis2.description.AxisOperationFactory;
import org.apache.axis2.description.Flow;
import org.apache.axis2.soap.SOAPEnvelope;
import org.apache.axis2.soap.SOAPFactory;
import org.apache.sandesha2.Sandesha2ClientAPI;
import org.apache.sandesha2.Sandesha2Constants;
import org.apache.sandesha2.RMMsgContext;
import org.apache.sandesha2.SandeshaException;
import org.apache.sandesha2.policy.RMPolicyBean;
import org.apache.sandesha2.storage.StorageManager;
import org.apache.sandesha2.storage.beanmanagers.SequencePropertyBeanMgr;
import org.apache.sandesha2.storage.beans.SequencePropertyBean;
import org.apache.sandesha2.wsrm.Accept;
import org.apache.sandesha2.wsrm.AcknowledgementRange;
import org.apache.sandesha2.wsrm.AcksTo;
import org.apache.sandesha2.wsrm.Address;
import org.apache.sandesha2.wsrm.CreateSequence;
import org.apache.sandesha2.wsrm.CreateSequenceResponse;
import org.apache.sandesha2.wsrm.IOMRMElement;
import org.apache.sandesha2.wsrm.Identifier;
import org.apache.sandesha2.wsrm.Sequence;
import org.apache.sandesha2.wsrm.SequenceAcknowledgement;
import org.apache.sandesha2.wsrm.SequenceOffer;
import org.apache.sandesha2.wsrm.TerminateSequence;
/**
* Used to create new RM messages.
* @author Chamikara Jayalath <chamikaramj@gmail.com>
*/
public class RMMsgCreator {
private static void setUpMessage(MessageContext rmMsgCtx) {
//Seting RMPolicyBean
if (rmMsgCtx.getProperty(Sandesha2Constants.WSP.RM_POLICY_BEAN)==null)
rmMsgCtx.setProperty(Sandesha2Constants.WSP.RM_POLICY_BEAN, PropertyManager.getInstance().getRMPolicyBean());
}
/**
* Create a new CreateSeqnence message.
*
* @param applicationRMMsg
* @param internalSequenceId
* @param acksTo
* @return
* @throws SandeshaException
*/
public static RMMsgContext createCreateSeqMsg(
RMMsgContext applicationRMMsg, String internalSequenceId, String acksTo)
throws SandeshaException {
MessageContext applicationMsgContext = applicationRMMsg
.getMessageContext();
if (applicationMsgContext == null)
throw new SandeshaException("Application message is null");
ConfigurationContext context = applicationMsgContext.getConfigurationContext();
if (context == null)
throw new SandeshaException("Configuration Context is null");
SOAPFactory factory = SOAPAbstractFactory.getSOAPFactory(SandeshaUtil
.getSOAPVersion(applicationMsgContext.getEnvelope()));
StorageManager storageManager = SandeshaUtil
.getSandeshaStorageManager(context);
SequencePropertyBeanMgr seqPropMgr = storageManager
.getSequencePropretyBeanMgr();
MessageContext createSeqmsgContext;
try {
//creating by copying common contents. (this will not set contexts
// except for configCtx).
AxisOperation createSequenceOperation = AxisOperationFactory
.getAxisOperation(AxisOperation.MEP_CONSTANT_OUT_IN);
createSeqmsgContext = SandeshaUtil.createNewRelatedMessageContext(
applicationRMMsg, createSequenceOperation);
OperationContext createSeqOpCtx = createSeqmsgContext
.getOperationContext();
String createSeqMsgId = SandeshaUtil.getUUID();
createSeqmsgContext.setMessageID(createSeqMsgId);
context.registerOperationContext(createSeqMsgId, createSeqOpCtx);
} catch (AxisFault e) {
throw new SandeshaException(e.getMessage());
}
setUpMessage(createSeqmsgContext);
AxisOperation appMsgOperationDesc = applicationMsgContext
.getAxisOperation();
AxisOperation createSeqOperation = createSeqmsgContext
.getAxisOperation();
createSeqOperation.setName(new QName("CreateSequenceOperation"));
if (appMsgOperationDesc != null) {
createSeqOperation.setPhasesOutFlow(appMsgOperationDesc
.getPhasesOutFlow());
createSeqOperation.setPhasesOutFaultFlow(appMsgOperationDesc
.getPhasesOutFaultFlow());
createSeqOperation.setPhasesInFaultFlow(appMsgOperationDesc
.getPhasesInFaultFlow());
createSeqOperation.setRemainingPhasesInFlow(appMsgOperationDesc
.getRemainingPhasesInFlow());
}
createSeqmsgContext.setAxisOperation(createSeqOperation);
createSeqmsgContext.setTo(applicationRMMsg.getTo());
createSeqmsgContext.setReplyTo(applicationRMMsg.getReplyTo());
RMMsgContext createSeqRMMsg = new RMMsgContext(createSeqmsgContext);
CreateSequence createSequencePart = new CreateSequence(factory);
//Adding sequence offer - if present
OperationContext operationcontext = applicationMsgContext
.getOperationContext();
if (operationcontext != null) {
String offeredSequence = (String) applicationMsgContext
.getProperty(Sandesha2ClientAPI.OFFERED_SEQUENCE_ID);
if (offeredSequence != null && !"".equals(offeredSequence)) {
SequenceOffer offerPart = new SequenceOffer(factory);
Identifier identifier = new Identifier(factory);
identifier.setIndentifer(offeredSequence);
offerPart.setIdentifier(identifier);
createSequencePart.setSequenceOffer(offerPart);
}
}
SequencePropertyBean replyToBean = seqPropMgr.retrieve(internalSequenceId,
Sandesha2Constants.SequenceProperties.REPLY_TO_EPR);
SequencePropertyBean toBean = seqPropMgr.retrieve(internalSequenceId,
Sandesha2Constants.SequenceProperties.TO_EPR);
if (toBean == null || toBean.getValue() == null)
throw new SandeshaException("To EPR is not set.");
EndpointReference toEPR = (EndpointReference) toBean.getValue();
EndpointReference replyToEPR = null;
EndpointReference acksToEPR = null;
if (acksTo == null || "".equals(acksTo))
acksTo = Sandesha2Constants.WSA.NS_URI_ANONYMOUS;
acksToEPR = new EndpointReference(acksTo);
if (replyToBean != null && replyToBean.getValue() != null)
replyToEPR = (EndpointReference) replyToBean.getValue();
createSeqRMMsg.setTo(toEPR);
//ReplyTo will be set only if not null.
if (replyToEPR != null)
createSeqRMMsg.setReplyTo(replyToEPR);
createSequencePart.setAcksTo(new AcksTo(
new Address(acksToEPR, factory), factory));
createSeqRMMsg.setMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ,
createSequencePart);
try {
createSeqRMMsg.addSOAPEnvelope();
} catch (AxisFault e1) {
throw new SandeshaException(e1.getMessage());
}
createSeqRMMsg.setAction(Sandesha2Constants.WSRM.Actions.ACTION_CREATE_SEQUENCE);
createSeqRMMsg
.setSOAPAction(Sandesha2Constants.WSRM.Actions.SOAP_ACTION_CREATE_SEQUENCE);
return createSeqRMMsg;
}
/**
* Creates a new TerminateSequence message.
*
* @param referenceRMMessage
* @param sequenceId
* @return
* @throws SandeshaException
*/
public static RMMsgContext createTerminateSequenceMessage(
RMMsgContext referenceRMMessage, String sequenceId)
throws SandeshaException {
MessageContext referenceMessage = referenceRMMessage
.getMessageContext();
if (referenceMessage == null)
throw new SandeshaException("MessageContext is null");
AxisOperation terminateOperation = null;
try {
terminateOperation = AxisOperationFactory
.getAxisOperation(AxisOperationFactory.MEP_CONSTANT_OUT_ONLY);
} catch (AxisFault e1) {
throw new SandeshaException(e1.getMessage());
}
if (terminateOperation == null)
throw new SandeshaException("Terminate Operation was null");
MessageContext terminateMessage = SandeshaUtil
.createNewRelatedMessageContext(referenceRMMessage,
terminateOperation);
RMMsgContext terminateRMMessage = MsgInitializer
.initializeMessage(terminateMessage);
if (terminateMessage == null)
throw new SandeshaException("MessageContext is null");
setUpMessage(terminateMessage);
SOAPFactory factory = SOAPAbstractFactory.getSOAPFactory(SandeshaUtil
.getSOAPVersion(referenceMessage.getEnvelope()));
terminateMessage.setMessageID(SandeshaUtil.getUUID());
ConfigurationContext configCtx = referenceMessage.getConfigurationContext();
if (configCtx == null)
throw new SandeshaException("Configuration Context is null");
AxisOperation referenceMsgOperation = referenceMessage
.getAxisOperation();
if (referenceMsgOperation != null) {
ArrayList outPhases = referenceMsgOperation.getPhasesOutFlow();
if (outPhases != null) {
terminateOperation.setPhasesOutFlow(outPhases);
terminateOperation.setPhasesOutFaultFlow(outPhases);
}
}
SOAPEnvelope envelope = factory.getDefaultEnvelope();
terminateRMMessage.setSOAPEnvelop(envelope);
TerminateSequence terminateSequencePart = new TerminateSequence(factory);
Identifier identifier = new Identifier(factory);
identifier.setIndentifer(sequenceId);
terminateSequencePart.setIdentifier(identifier);
terminateRMMessage.setMessagePart(Sandesha2Constants.MessageParts.TERMINATE_SEQ,
terminateSequencePart);
return terminateRMMessage;
}
/**
* Create a new CreateSequenceResponse message.
*
* @param createSeqMessage
* @param outMessage
* @param newSequenceID
* @return
* @throws AxisFault
*/
public static RMMsgContext createCreateSeqResponseMsg(
RMMsgContext createSeqMessage, MessageContext outMessage,
String newSequenceID) throws AxisFault {
SOAPFactory factory = SOAPAbstractFactory.getSOAPFactory(SandeshaUtil
.getSOAPVersion(createSeqMessage.getSOAPEnvelope()));
IOMRMElement messagePart = createSeqMessage
.getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ);
CreateSequence cs = (CreateSequence) messagePart;
CreateSequenceResponse response = new CreateSequenceResponse(factory);
Identifier identifier = new Identifier(factory);
identifier.setIndentifer(newSequenceID);
response.setIdentifier(identifier);
SequenceOffer offer = cs.getSequenceOffer();
if (offer != null) {
String outSequenceId = offer.getIdentifer().getIdentifier();
if (outSequenceId != null && !"".equals(outSequenceId)) {
Accept accept = new Accept(factory);
EndpointReference acksToEPR = createSeqMessage.getTo();
AcksTo acksTo = new AcksTo(factory);
Address address = new Address(factory);
address.setEpr(acksToEPR);
acksTo.setAddress(address);
accept.setAcksTo(acksTo);
response.setAccept(accept);
}
}
SOAPEnvelope envelope = factory.getDefaultEnvelope();
response.toOMElement(envelope.getBody());
outMessage
.setWSAAction(Sandesha2Constants.WSRM.Actions.ACTION_CREATE_SEQUENCE_RESPONSE);
outMessage
.setSoapAction(Sandesha2Constants.WSRM.Actions.SOAP_ACTION_CREATE_SEQUENCE_RESPONSE);
String newMessageId = SandeshaUtil.getUUID();
outMessage.setMessageID(newMessageId);
outMessage.setEnvelope(envelope);
setUpMessage(outMessage);
RMMsgContext createSeqResponse = null;
try {
createSeqResponse = MsgInitializer.initializeMessage(outMessage);
} catch (SandeshaException ex) {
throw new AxisFault("Cant initialize the message");
}
return createSeqResponse;
}
/**
* Adds an ack message to the given application message.
*
* @param applicationMsg
* @param sequenceId
* @throws SandeshaException
*/
public static void addAckMessage(RMMsgContext applicationMsg,
String sequenceId) throws SandeshaException {
SOAPFactory factory = SOAPAbstractFactory.getSOAPFactory(SandeshaUtil
.getSOAPVersion(applicationMsg.getSOAPEnvelope()));
SOAPEnvelope envelope = applicationMsg.getSOAPEnvelope();
if (envelope == null) {
SOAPEnvelope newEnvelope = factory.getDefaultEnvelope();
applicationMsg.setSOAPEnvelop(newEnvelope);
}
envelope = applicationMsg.getSOAPEnvelope();
SequenceAcknowledgement sequenceAck = new SequenceAcknowledgement(
factory);
Identifier id = new Identifier(factory);
id.setIndentifer(sequenceId);
sequenceAck.setIdentifier(id);
ConfigurationContext ctx = applicationMsg.getMessageContext()
.getConfigurationContext();
StorageManager storageManager = SandeshaUtil
.getSandeshaStorageManager(ctx);
SequencePropertyBeanMgr seqPropMgr = storageManager
.getSequencePropretyBeanMgr();
SequencePropertyBean seqBean = seqPropMgr.retrieve(sequenceId,
Sandesha2Constants.SequenceProperties.RECEIVED_MESSAGES);
String msgNoList = (String) seqBean.getValue();
ArrayList ackRangeArrayList = SandeshaUtil.getAckRangeArrayList(msgNoList,factory);
Iterator iterator = ackRangeArrayList.iterator();
while (iterator.hasNext()) {
AcknowledgementRange ackRange = (AcknowledgementRange) iterator.next();
sequenceAck.addAcknowledgementRanges(ackRange);
}
sequenceAck.toOMElement(envelope.getHeader());
applicationMsg
.setAction(Sandesha2Constants.WSRM.Actions.ACTION_SEQUENCE_ACKNOWLEDGEMENT);
applicationMsg
.setSOAPAction(Sandesha2Constants.WSRM.Actions.SOAP_ACTION_SEQUENCE_ACKNOWLEDGEMENT);
applicationMsg.setMessageId(SandeshaUtil.getUUID());
}
/**
* Create a new Acknowledgement message.
*
* @param applicationRMMsgCtx
* @return
* @throws SandeshaException
*/
public static RMMsgContext createAckMessage(RMMsgContext applicationRMMsgCtx)
throws SandeshaException {
try {
MessageContext applicationMsgCtx = applicationRMMsgCtx
.getMessageContext();
AxisOperation ackOperation = AxisOperationFactory
.getAxisOperation(AxisOperationFactory.MEP_CONSTANT_OUT_ONLY);
MessageContext ackMsgCtx = SandeshaUtil
.createNewRelatedMessageContext(applicationRMMsgCtx,
ackOperation);
RMMsgContext ackRMMsgCtx = MsgInitializer
.initializeMessage(ackMsgCtx);
setUpMessage(ackMsgCtx);
Sequence reqSequence = (Sequence) applicationRMMsgCtx
.getMessagePart(Sandesha2Constants.MessageParts.SEQUENCE);
if (reqSequence == null)
throw new SandeshaException(
"Sequence part of application message is null");
String sequenceId = reqSequence.getIdentifier().getIdentifier();
addAckMessage(ackRMMsgCtx, sequenceId);
return ackRMMsgCtx;
} catch (AxisFault e) {
throw new SandeshaException(e.getMessage());
}
}
}