Package org.apache.sandesha2.wsrm

Examples of org.apache.sandesha2.wsrm.CreateSequence


      MessageContext createSequenceMessage) throws SandeshaException {

    RMMsgContext createSequenceRMMsg = MsgInitializer
        .initializeMessage(createSequenceMessage);

    CreateSequence createSequence = (CreateSequence) createSequenceRMMsg
        .getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ);
    if (createSequence == null)
      throw new SandeshaException(
          "Passed message does not have a CreateSequence part");
View Full Code Here


      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();
View Full Code Here

   
    //generating a new create sequeuce message.
    RMMsgContext createSeqRMMessage = RMMsgCreator.createCreateSeqMsg(applicationRMMsg, internalSequenceId, acksTo);
   
    createSeqRMMessage.setFlow(MessageContext.OUT_FLOW);
    CreateSequence createSequencePart = (CreateSequence) createSeqRMMessage.getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ);

    //retrieving the storage manager.
    StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configCtx);
    SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropretyBeanMgr();
    CreateSeqBeanMgr createSeqMgr = storageManager.getCreateSeqBeanMgr();
    SenderBeanMgr retransmitterMgr = storageManager.getRetransmitterBeanMgr();
   
    SequenceOffer offer = createSequencePart.getSequenceOffer();
    if (offer != null) {
      String offeredSequenceId = offer.getIdentifer().getIdentifier();

      SequencePropertyBean offeredSequenceBean = new SequencePropertyBean();
      offeredSequenceBean.setName(Sandesha2Constants.SequenceProperties.OFFERED_SEQUENCE);
View Full Code Here

      throw new AxisFault(message);
    }

    EndpointReference replyTo = createSequenceMsg.getReplyTo();

    CreateSequence createSequence = (CreateSequence) createSequenceMsg
        .getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ);
    if (createSequence == null) {
      String message = "Create Sequence Part is null";
      log.debug(message);
      throw new AxisFault(message);
    }

    EndpointReference acksTo = createSequence.getAcksTo().getAddress()
        .getEpr();

    if (acksTo == null) {
      String message = "AcksTo is null";
      log.debug(message);
      throw new AxisFault(message);
    }

    StorageManager storageManager = null;
    ConfigurationContext configurationContext = createSequenceMsg.getMessageContext()
                  .getConfigurationContext();
    try {
      storageManager = SandeshaUtil
          .getSandeshaStorageManager(configurationContext);
    } catch (SandeshaException e) {
      e.printStackTrace();
    }

    SequencePropertyBeanMgr seqPropMgr = storageManager
        .getSequencePropretyBeanMgr();

    SequencePropertyBean receivedMsgBean = new SequencePropertyBean(
        sequenceId, Sandesha2Constants.SequenceProperties.SERVER_COMPLETED_MESSAGES, "");
   
   
    //setting the addressing version
    String addressingNamespaceValue = createSequenceMsg.getAddressingNamespaceValue();
    SequencePropertyBean addressingNamespaceBean = new SequencePropertyBean (
        sequenceId,Sandesha2Constants.SequenceProperties.ADDRESSING_NAMESPACE_VALUE,addressingNamespaceValue);
    seqPropMgr.insert(addressingNamespaceBean);
   
    String anonymousURI = SpecSpecificConstants.getAddressingAnonymousURI(addressingNamespaceValue);
   
    //If no replyTo value. Send responses as sync.
    SequencePropertyBean toBean = null;
    if (replyTo!=null) {
      toBean = new SequencePropertyBean(sequenceId,
        Sandesha2Constants.SequenceProperties.TO_EPR, replyTo.getAddress());
    }else {
      toBean = new SequencePropertyBean(sequenceId,
          Sandesha2Constants.SequenceProperties.TO_EPR, anonymousURI);
    }
   
    SequencePropertyBean replyToBean = new SequencePropertyBean(sequenceId,
        Sandesha2Constants.SequenceProperties.REPLY_TO_EPR, to.getAddress());
    SequencePropertyBean acksToBean = new SequencePropertyBean(sequenceId,
        Sandesha2Constants.SequenceProperties.ACKS_TO_EPR, acksTo.getAddress());

   
    seqPropMgr.insert(receivedMsgBean);
    seqPropMgr.insert(replyToBean);
    seqPropMgr.insert(acksToBean);
   
    if (toBean!=null)
      seqPropMgr.insert(toBean);

    NextMsgBeanMgr nextMsgMgr = storageManager.getNextMsgBeanMgr();
    nextMsgMgr.insert(new NextMsgBean(sequenceId, 1)); // 1 will be the next
   
    // message to invoke. This will apply for only in-order invocations.

    SandeshaUtil.startSenderForTheSequence(configurationContext,sequenceId);
   
    //stting the RM SPEC version for this sequence.
    String createSequenceMsgAction = createSequenceMsg.getWSAAction();
    if (createSequenceMsgAction==null)
        throw new SandeshaException ("Create sequence message does not have the WSA:Action value");
   
    String messageRMNamespace = createSequence.getNamespaceValue();
   
    String specVersion = null;
    if (Sandesha2Constants.SPEC_2005_02.NS_URI.equals(messageRMNamespace)) {
      specVersion = Sandesha2Constants.SPEC_VERSIONS.v1_0;
    }else if (Sandesha2Constants.SPEC_2005_10.NS_URI.equals(messageRMNamespace)) {
View Full Code Here

   
    String rmNamespaceValue = SpecSpecificConstants.getRMNamespaceValue(rmVersion);
   
    String addressingNamespaceValue = SandeshaUtil.getSequenceProperty(internalSequenceId,Sandesha2Constants.SequenceProperties.ADDRESSING_NAMESPACE_VALUE,context);
   
    CreateSequence createSequencePart = new CreateSequence(factory,rmNamespaceValue,addressingNamespaceValue);

    // Adding sequence offer - if present
    OperationContext operationcontext = applicationMsgContext
        .getOperationContext();
    if (operationcontext != null) {
      String offeredSequence = (String) applicationMsgContext
          .getProperty(SandeshaClientConstants.OFFERED_SEQUENCE_ID);
      if (offeredSequence != null && !"".equals(offeredSequence)) {
        SequenceOffer offerPart = new SequenceOffer(factory,rmNamespaceValue);
        Identifier identifier = new Identifier(factory,rmNamespaceValue);
        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 = new EndpointReference(toBean.getValue());
    EndpointReference replyToEPR = null;
    EndpointReference acksToEPR = null;

    String anonymousURI = SpecSpecificConstants.getAddressingAnonymousURI(addressingNamespaceValue);
   
    if (acksTo == null || "".equals(acksTo))
      acksTo = anonymousURI;

    acksToEPR = new EndpointReference(acksTo);

    if (replyToBean != null && replyToBean.getValue() != null)
      replyToEPR = new EndpointReference(replyToBean.getValue());

    if(createSeqRMMsg.getTo()==null)
      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, addressingNamespaceValue), factory,rmNamespaceValue,addressingNamespaceValue));

    createSeqRMMsg.setMessagePart(
        Sandesha2Constants.MessageParts.CREATE_SEQ, createSequencePart);
View Full Code Here

    ConfigurationContext configurationContext = createSeqMessage.getMessageContext().getConfigurationContext();
   
    IOMRMElement messagePart = createSeqMessage
        .getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ);
    CreateSequence cs = (CreateSequence) messagePart;

    String rmVersion = SandeshaUtil.getRMVersion(newSequenceID,configurationContext);
    if (rmVersion==null)
      throw new SandeshaException ("Cant find the rmVersion of the given message");
   
    String rmNamespaceValue = SpecSpecificConstants.getRMNamespaceValue(rmVersion);   
    String addressingNamespaceValue = SandeshaUtil.getSequenceProperty(newSequenceID,Sandesha2Constants.SequenceProperties.ADDRESSING_NAMESPACE_VALUE,configurationContext);
   
    CreateSequenceResponse response = new CreateSequenceResponse(factory,rmNamespaceValue,addressingNamespaceValue);

    Identifier identifier = new Identifier(factory,rmNamespaceValue);
    identifier.setIndentifer(newSequenceID);

    response.setIdentifier(identifier);

    SequenceOffer offer = cs.getSequenceOffer();
    if (offer != null) {
      String outSequenceId = offer.getIdentifer().getIdentifier();

      if (outSequenceId != null && !"".equals(outSequenceId)) {
View Full Code Here

    StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configContext);
    SequencePropertyBeanMgr sequencePropertyBeanMgr = storageManager.getSequencePropretyBeanMgr();
   
    String sequenceID = null;
   
    CreateSequence createSequence = (CreateSequence) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ);
    CreateSequenceResponse createSequenceResponse = (CreateSequenceResponse) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.CREATE_SEQ_RESPONSE);
    TerminateSequence terminateSequence = (TerminateSequence) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.TERMINATE_SEQ);
    TerminateSequenceResponse terminateSequenceResponse = (TerminateSequenceResponse) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.TERMINATE_SEQ_RESPONSE);
    SequenceAcknowledgement sequenceAcknowledgement = (SequenceAcknowledgement) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.SEQ_ACKNOWLEDGEMENT);
    Sequence sequence = (Sequence) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.SEQUENCE);
View Full Code Here

    // generating a new create sequeuce message.
    RMMsgContext createSeqRMMessage = RMMsgCreator.createCreateSeqMsg(rmsBean, applicationRMMsg);
    messageContext = createSeqRMMessage.getMessageContext();
    messageContext.setWSAAction(SpecSpecificConstants.getCreateSequenceAction(Sandesha2Constants.SPEC_VERSIONS.v1_1));

    CreateSequence createSeqResPart = createSeqRMMessage.getCreateSequence();

    createSeqResPart.setAcksTo(
        new AcksTo(new EndpointReference(AddressingConstants.Final.WSA_NONE_URI),
                   SpecSpecificConstants.getRMNamespaceValue(rmsBean.getRMVersion()),
                   AddressingConstants.Final.WSA_NAMESPACE));
   
    // Update the SOAP Envelope of the message
View Full Code Here

   */
  public static RMMsgContext createCreateSeqResponseMsg(RMMsgContext createSeqMessage, RMSequenceBean rmSequenceBean) throws AxisFault {

    if(log.isDebugEnabled()) log.debug("Entry: RMMsgCreator::createCreateSeqResponseMsg " + rmSequenceBean);
   
    CreateSequence cs = createSeqMessage.getCreateSequence();
    String namespace = createSeqMessage.getRMNamespaceValue();

    CreateSequenceResponse response = new CreateSequenceResponse(namespace);
    Identifier identifier = new Identifier(namespace);
    identifier.setIndentifer(rmSequenceBean.getSequenceID());
    response.setIdentifier(identifier);

    SequenceOffer offer = cs.getSequenceOffer();
    if (offer != null) {
      if(log.isDebugEnabled()) log.debug("RMMsgCreator:: " + offer);
      String outSequenceId = offer.getIdentifer().getIdentifier();

      if (outSequenceId != null && !"".equals(outSequenceId)) {

        Accept accept = new Accept(namespace);

        // Putting the To EPR as the AcksTo for the response sequence. We echo back the
        // addressing version that the create used.
        String addressingNamespace = cs.getAddressingNamespaceValue();
        EndpointReference acksToEPR = createSeqMessage.getTo();
        if(acksToEPR != null) {
          acksToEPR = SandeshaUtil.cloneEPR(acksToEPR);
        } else {
          String anon = SpecSpecificConstants.getAddressingAnonymousURI(addressingNamespace);
          acksToEPR = new EndpointReference(anon);
        }
       
        AcksTo acksTo = new AcksTo(acksToEPR, namespace, cs.getAddressingNamespaceValue());
        accept.setAcksTo(acksTo);
        response.setAccept(accept);
      }
    }

View Full Code Here

    // generating a new create sequence message.
    RMMsgContext createSeqRMMessage = RMMsgCreator.createCreateSeqMsg(rmsBean, applicationRMMsg);

    createSeqRMMessage.setFlow(MessageContext.OUT_FLOW);
    CreateSequence createSequencePart = createSeqRMMessage.getCreateSequence();

    SequenceOffer offer = createSequencePart.getSequenceOffer();
    if (offer != null) {
      String offeredSequenceId = offer.getIdentifer().getIdentifier();

      rmsBean.setOfferedSequence(offeredSequenceId);
    }
View Full Code Here

TOP

Related Classes of org.apache.sandesha2.wsrm.CreateSequence

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.