| /* |
| * 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.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import javax.xml.namespace.QName; |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.addressing.EndpointReference; |
| import org.apache.axis2.context.ConfigurationContext; |
| import org.apache.axis2.context.MessageContext; |
| import org.apache.axis2.context.OperationContext; |
| import org.apache.axis2.description.AxisOperation; |
| import org.apache.axis2.description.AxisOperationFactory; |
| import org.apache.axis2.om.OMElement; |
| import org.apache.axis2.soap.SOAP11Constants; |
| import org.apache.axis2.soap.SOAP12Constants; |
| import org.apache.axis2.soap.SOAPEnvelope; |
| import org.apache.axis2.soap.SOAPFactory; |
| import org.apache.axis2.soap.SOAPHeader; |
| import org.apache.axis2.util.Utils; |
| import org.apache.sandesha2.Sandesha2Constants; |
| import org.apache.sandesha2.FaultData; |
| import org.apache.sandesha2.RMMsgContext; |
| import org.apache.sandesha2.SOAPFaultEnvelopeCreator; |
| import org.apache.sandesha2.SandeshaException; |
| import org.apache.sandesha2.storage.StorageManager; |
| import org.apache.sandesha2.storage.beanmanagers.NextMsgBeanMgr; |
| import org.apache.sandesha2.storage.beanmanagers.SequencePropertyBeanMgr; |
| import org.apache.sandesha2.storage.beans.NextMsgBean; |
| import org.apache.sandesha2.storage.beans.SequencePropertyBean; |
| import org.apache.sandesha2.wsrm.AcknowledgementRange; |
| import org.apache.sandesha2.wsrm.CreateSequence; |
| 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; |
| |
| /** |
| * Has logic to check for possible RM related faults and create it. |
| * |
| * @author Chamikara Jayalath <chamikaramj@gmail.com> |
| * @author Sanka Samaranayaka <ssanka@gmail.com> |
| */ |
| |
| public class FaultManager { |
| |
| public FaultManager() { |
| } |
| |
| public RMMsgContext checkForPossibleFaults(MessageContext msgCtx) |
| throws SandeshaException { |
| |
| //Cannot initialize message before checking for MsgNoRoleover - since |
| // initialization will give an exception |
| //for rolled over messages. |
| |
| SOAPEnvelope envelope = msgCtx.getEnvelope(); |
| if (envelope == null) |
| throw new SandeshaException("SOAP Envelope is null"); |
| |
| RMMsgContext faultMessageContext = null; |
| |
| SOAPHeader header = envelope.getHeader(); |
| if (header != null) { |
| OMElement sequenceHeaderBlock = header |
| .getFirstChildWithName(new QName(Sandesha2Constants.WSRM.NS_URI_RM, |
| Sandesha2Constants.WSRM.SEQUENCE)); |
| if (sequenceHeaderBlock != null) { |
| faultMessageContext = checkForMessageNumberRoleover(msgCtx); |
| if (faultMessageContext != null) |
| return faultMessageContext; |
| } |
| } |
| |
| RMMsgContext rmMsgCtx = MsgInitializer.initializeMessage(msgCtx); |
| int msgType = rmMsgCtx.getMessageType(); |
| |
| if (msgType == Sandesha2Constants.MessageTypes.APPLICATION |
| || msgType == Sandesha2Constants.MessageTypes.TERMINATE_SEQ) { |
| faultMessageContext = checkForUnknownSequence(msgCtx); |
| if (faultMessageContext != null) |
| return faultMessageContext; |
| |
| } |
| |
| if (msgType == Sandesha2Constants.MessageTypes.CREATE_SEQ) { |
| faultMessageContext = checkForCreateSequenceRefused(msgCtx); |
| if (faultMessageContext != null) |
| return faultMessageContext; |
| } |
| |
| if (msgType == Sandesha2Constants.MessageTypes.ACK) { |
| faultMessageContext = checkForInvalidAcknowledgement(msgCtx); |
| if (faultMessageContext != null) |
| return faultMessageContext; |
| } |
| |
| if (msgType == Sandesha2Constants.MessageTypes.APPLICATION) { |
| faultMessageContext = checkForLastMsgNumberExceeded(msgCtx); |
| if (faultMessageContext != null) |
| return faultMessageContext; |
| } |
| |
| return faultMessageContext; |
| |
| } |
| |
| /** |
| * Check weather the CreateSequence should be refused and generate the fault if it should. |
| * |
| * @param messageContext |
| * @return |
| * @throws SandeshaException |
| */ |
| private RMMsgContext checkForCreateSequenceRefused( |
| MessageContext messageContext) throws SandeshaException { |
| |
| RMMsgContext rmMsgCtx = MsgInitializer |
| .initializeMessage(messageContext); |
| |
| CreateSequence createSequence = (CreateSequence) rmMsgCtx |
| .getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ); |
| if (createSequence == null) |
| throw new SandeshaException( |
| "CreateSequence message does not have a CreateSequence part"); |
| |
| ConfigurationContext context = messageContext.getConfigurationContext(); |
| StorageManager storageManager = (StorageManager) SandeshaUtil |
| .getSandeshaStorageManager(context); |
| if (storageManager == null) |
| throw new SandeshaException("Storage Manager is null"); |
| |
| boolean refuseSequence = false; |
| String reason = ""; |
| |
| SequenceOffer offer = createSequence.getSequenceOffer(); |
| if (offer != null) { |
| String offeredSequenceId = offer.getIdentifer().getIdentifier(); |
| if (offeredSequenceId == null || "".equals(offeredSequenceId)) { |
| refuseSequence = true; |
| reason = "Offered sequenceId is invalid"; |
| } else { |
| NextMsgBeanMgr nextMsgBeanMgr = storageManager |
| .getNextMsgBeanMgr(); |
| Collection collection = nextMsgBeanMgr.retrieveAll(); |
| Iterator it = collection.iterator(); |
| while (it.hasNext()) { |
| |
| //checking weather a incoming sequence with the given id |
| // exists. |
| NextMsgBean nextMsgBean = (NextMsgBean) it.next(); |
| String sequenceId = nextMsgBean.getSequenceId(); |
| if (sequenceId.equals(offeredSequenceId)) { |
| refuseSequence = true; |
| reason = "A sequence with offered sequenceId, already axists"; |
| } |
| |
| //checking weather an outgoing sequence with the given id |
| // exists. |
| SequencePropertyBeanMgr sequencePropertyBeanMgr = storageManager |
| .getSequencePropretyBeanMgr(); |
| SequencePropertyBean sequencePropertyBean = sequencePropertyBeanMgr |
| .retrieve( |
| sequenceId, |
| Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID); |
| if (sequencePropertyBean != null) { |
| String outSequenceId = (String) sequencePropertyBean |
| .getValue(); |
| if (outSequenceId != null |
| && outSequenceId.equals(offeredSequenceId)) { |
| refuseSequence = true; |
| reason = "A sequence with offered sequenceId, already axists"; |
| } |
| |
| } |
| } |
| } |
| } |
| |
| //TODO - if (securityTokenReference is present RefuseCreateSequence) |
| |
| if (refuseSequence) { |
| |
| FaultData data = new FaultData(); |
| data |
| .setType(Sandesha2Constants.SOAPFaults.FaultType.CREATE_SEQUENCE_REFUSED); |
| |
| int SOAPVersion = SandeshaUtil.getSOAPVersion(rmMsgCtx |
| .getSOAPEnvelope()); |
| if (SOAPVersion == Sandesha2Constants.SOAPVersion.v1_1) |
| data.setCode(SOAP11Constants.FAULT_CODE_SENDER); |
| else |
| data.setCode(SOAP12Constants.FAULT_CODE_SENDER); |
| |
| data |
| .setSubcode(Sandesha2Constants.SOAPFaults.Subcodes.CREATE_SEQUENCE_REFUSED); |
| data.setReason(reason); |
| return getFault(rmMsgCtx, data); |
| } |
| |
| return null; |
| |
| } |
| |
| /** |
| * Check weather the LastMessage number has been exceeded and generate the fault if it is. |
| * |
| * @param msgCtx |
| * @return |
| */ |
| private RMMsgContext checkForLastMsgNumberExceeded(MessageContext msgCtx) { |
| return null; |
| } |
| |
| private RMMsgContext checkForMessageNumberRoleover( |
| MessageContext messageContext) { |
| return null; |
| } |
| |
| /** |
| * Check whether a Sequence message (a) belongs to a unknown sequence |
| * (generates an UnknownSequence fault) (b) message number exceeds a |
| * predifined limit ( genenrates a Message Number Rollover fault) |
| * |
| * @param msgCtx |
| * @return @throws |
| * SandeshaException |
| */ |
| public RMMsgContext checkForUnknownSequence(MessageContext messageContext) |
| throws SandeshaException { |
| |
| RMMsgContext rmMsgCtx = MsgInitializer |
| .initializeMessage(messageContext); |
| String sequenceId = null; |
| |
| if (rmMsgCtx.getMessageType() == Sandesha2Constants.MessageTypes.APPLICATION) { |
| Sequence sequence = (Sequence) rmMsgCtx |
| .getMessagePart(Sandesha2Constants.MessageParts.SEQUENCE); |
| if (sequence == null) |
| throw new SandeshaException( |
| "Sequence part not found in the application message"); |
| |
| sequenceId = sequence.getIdentifier().getIdentifier(); |
| |
| } else if (rmMsgCtx.getMessageType() == Sandesha2Constants.MessageTypes.ACK) { |
| SequenceAcknowledgement sequenceAcknowledgement = (SequenceAcknowledgement) rmMsgCtx |
| .getMessagePart(Sandesha2Constants.MessageParts.SEQ_ACKNOWLEDGEMENT); |
| sequenceId = sequenceAcknowledgement.getIdentifier() |
| .getIdentifier(); |
| } else if (rmMsgCtx.getMessageType() == Sandesha2Constants.MessageTypes.TERMINATE_SEQ) { |
| TerminateSequence terminateSequence = (TerminateSequence) rmMsgCtx |
| .getMessagePart(Sandesha2Constants.MessageParts.TERMINATE_SEQ); |
| sequenceId = terminateSequence.getIdentifier().getIdentifier(); |
| } else { |
| //sequenceId not found. |
| return null; |
| } |
| |
| StorageManager storageManager = SandeshaUtil |
| .getSandeshaStorageManager(messageContext.getConfigurationContext()); |
| |
| NextMsgBeanMgr mgr = storageManager.getNextMsgBeanMgr(); |
| SOAPEnvelope envelope = messageContext.getEnvelope(); |
| |
| Collection coll = mgr.retrieveAll(); |
| Iterator it = coll.iterator(); |
| |
| boolean validSequence = false; |
| |
| while (it.hasNext()) { |
| NextMsgBean nextMsgBean = (NextMsgBean) it.next(); |
| String tempId = nextMsgBean.getSequenceId(); |
| if (tempId.equals(sequenceId)) { |
| validSequence = true; |
| break; |
| } |
| } |
| |
| if (!validSequence) { |
| //Return an UnknownSequence error |
| int SOAPVersion = SandeshaUtil.getSOAPVersion(envelope); |
| |
| FaultData data = new FaultData(); |
| if (SOAPVersion == Sandesha2Constants.SOAPVersion.v1_1) |
| data.setCode(SOAP11Constants.FAULT_CODE_SENDER); |
| else |
| data.setCode(SOAP12Constants.FAULT_CODE_SENDER); |
| |
| data.setSubcode(Sandesha2Constants.SOAPFaults.Subcodes.UNKNOWN_SEQUENCE); |
| |
| SOAPFactory factory = SOAPAbstractFactory |
| .getSOAPFactory(SOAPVersion); |
| Identifier identifier = new Identifier(factory); |
| identifier.setIndentifer(sequenceId); |
| OMElement identifierOMElem = identifier.getOMElement(); |
| data.setDetail(identifierOMElem); |
| data |
| .setReason("The value of wsrm:Identifier is not a known Sequence identifier"); |
| |
| return getFault(rmMsgCtx, data); |
| |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Check weather the Acknowledgement is invalid and generate a fault if it is. |
| * |
| * @param msgCtx |
| * @return @throws |
| * SandeshaException |
| */ |
| public RMMsgContext checkForInvalidAcknowledgement(MessageContext msgCtx) |
| throws SandeshaException { |
| |
| //check lower<=upper |
| //TODO acked for not-send message |
| RMMsgContext rmMsgContext = new RMMsgContext(); |
| if (rmMsgContext.getMessageType() != Sandesha2Constants.MessageTypes.ACK) |
| return null; |
| |
| SequenceAcknowledgement sequenceAcknowledgement = (SequenceAcknowledgement) rmMsgContext |
| .getMessagePart(Sandesha2Constants.MessageParts.SEQ_ACKNOWLEDGEMENT); |
| List sequenceAckList = sequenceAcknowledgement |
| .getAcknowledgementRanges(); |
| Iterator it = sequenceAckList.iterator(); |
| |
| while (it.hasNext()) { |
| AcknowledgementRange acknowledgementRange = (AcknowledgementRange) it |
| .next(); |
| long upper = acknowledgementRange.getUpperValue(); |
| long lower = acknowledgementRange.getLowerValue(); |
| |
| if (lower > upper) { |
| //Invalid ack |
| FaultData data = new FaultData(); |
| int SOAPVersion = SandeshaUtil.getSOAPVersion(msgCtx |
| .getEnvelope()); |
| if (SOAPVersion == Sandesha2Constants.SOAPVersion.v1_1) |
| data.setCode(SOAP11Constants.FAULT_CODE_SENDER); |
| else |
| data.setCode(SOAP12Constants.FAULT_CODE_SENDER); |
| |
| data.setSubcode(Sandesha2Constants.SOAPFaults.Subcodes.INVALID_ACKNOWLEDGEMENT); |
| data.setSubcode("The SequenceAcknowledgement is invalid. Lower value is larger than upper value"); |
| data.setDetail(sequenceAcknowledgement.getOMElement()); |
| |
| return getFault(rmMsgContext, data); |
| } |
| } |
| |
| return null; |
| } |
| |
| |
| /** |
| * Returns a RMMessageContext for the fault message. Data for generating the fault is given in the data parameter. |
| * |
| * @param referenceRMMsgContext |
| * @param data |
| * @return |
| * @throws SandeshaException |
| */ |
| public RMMsgContext getFault(RMMsgContext referenceRMMsgContext, |
| FaultData data) throws SandeshaException { |
| |
| try { |
| |
| MessageContext referenceMessage = referenceRMMsgContext |
| .getMessageContext(); |
| MessageContext faultMsgContext = Utils |
| .createOutMessageContext(referenceMessage); |
| |
| StorageManager storageManager = SandeshaUtil |
| .getSandeshaStorageManager(referenceMessage |
| .getConfigurationContext()); |
| |
| //setting contexts. |
| faultMsgContext.setAxisServiceGroup(referenceMessage |
| .getAxisServiceGroup()); |
| faultMsgContext.setAxisService(referenceMessage.getAxisService()); |
| faultMsgContext.setAxisServiceGroup(referenceMessage |
| .getAxisServiceGroup()); |
| faultMsgContext.setServiceGroupContext(referenceMessage |
| .getServiceGroupContext()); |
| faultMsgContext.setServiceGroupContextId(referenceMessage |
| .getServiceGroupContextId()); |
| faultMsgContext.setServiceContext(referenceMessage |
| .getServiceContext()); |
| faultMsgContext.setServiceContextID(referenceMessage |
| .getServiceContextID()); |
| |
| AxisOperation operation = AxisOperationFactory |
| .getAxisOperation(AxisOperationFactory.MEP_CONSTANT_OUT_ONLY); |
| |
| OperationContext operationContext = new OperationContext(operation); |
| |
| faultMsgContext.setAxisOperation(operation); |
| faultMsgContext.setOperationContext(operationContext); |
| |
| String acksToStr = null; |
| if (referenceRMMsgContext.getMessageType() == Sandesha2Constants.MessageTypes.CREATE_SEQ) { |
| CreateSequence createSequence = (CreateSequence) referenceRMMsgContext |
| .getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ); |
| acksToStr = createSequence.getAcksTo().getAddress().getEpr() |
| .getAddress(); |
| } else { |
| SequencePropertyBeanMgr seqPropMgr = storageManager |
| .getSequencePropretyBeanMgr(); |
| String sequenceId = data.getSequenceId(); |
| SequencePropertyBean acksToBean = seqPropMgr.retrieve( |
| sequenceId, Sandesha2Constants.SequenceProperties.ACKS_TO_EPR); |
| if (acksToBean != null) { |
| EndpointReference epr = (EndpointReference) acksToBean |
| .getValue(); |
| if (epr != null) |
| acksToStr = epr.getAddress(); |
| } |
| } |
| |
| if (acksToStr != null |
| && !acksToStr.equals(Sandesha2Constants.WSA.NS_URI_ANONYMOUS)) { |
| faultMsgContext.setTo(new EndpointReference(acksToStr)); |
| } |
| |
| int SOAPVersion = SandeshaUtil.getSOAPVersion(referenceMessage |
| .getEnvelope()); |
| |
| SOAPFaultEnvelopeCreator.addSOAPFaultEnvelope(faultMsgContext, |
| SOAPVersion, data); |
| |
| RMMsgContext faultRMMsgCtx = MsgInitializer |
| .initializeMessage(faultMsgContext); |
| |
| return faultRMMsgCtx; |
| |
| } catch (AxisFault e) { |
| throw new SandeshaException(e.getMessage()); |
| } |
| |
| } |
| } |
