Package org.apache.sandesha2.storage.beanmanagers

Examples of org.apache.sandesha2.storage.beanmanagers.SenderBeanMgr


    msgContext.setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING,
        Sandesha2Constants.VALUE_FALSE);
   
    terminateBean.setReSend(false);

    SenderBeanMgr retramsmitterMgr = storageManager
        .getRetransmitterBeanMgr();

    retramsmitterMgr.insert(terminateBean);
   
    SequencePropertyBean terminateAdded = new SequencePropertyBean();
    terminateAdded.setName(Sandesha2Constants.SequenceProperties.TERMINATE_ADDED);
    terminateAdded.setSequenceID(outSequenceID);
    terminateAdded.setValue("true");
View Full Code Here


 
  private static void cleanSendingSideData (ConfigurationContext configContext,String internalSequenceID, boolean serverSide) throws SandeshaException {
    StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configContext);
   
    SequencePropertyBeanMgr sequencePropertyBeanMgr = storageManager.getSequencePropretyBeanMgr();
    SenderBeanMgr retransmitterBeanMgr = storageManager.getRetransmitterBeanMgr();
    CreateSeqBeanMgr createSeqBeanMgr = storageManager.getCreateSeqBeanMgr();
   
    String outSequenceID = SandeshaUtil.getSequenceProperty(internalSequenceID,Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID,configContext);
   
    if (!serverSide) {
      boolean stopListnerForAsyncAcks = false;
      SequencePropertyBean acksToBean = sequencePropertyBeanMgr.retrieve(internalSequenceID,Sandesha2Constants.SequenceProperties.ACKS_TO_EPR);
       
      String addressingNamespace = SandeshaUtil.getSequenceProperty(internalSequenceID,Sandesha2Constants.SequenceProperties.ADDRESSING_NAMESPACE_VALUE,configContext);
      String anonymousURI = SpecSpecificConstants.getAddressingAnonymousURI(addressingNamespace);
       
      if (acksToBean!=null) {
        String acksTo = acksToBean.getValue();
        if (acksTo!=null && !anonymousURI.equals(acksTo)) {
          stopListnerForAsyncAcks = true;
        }
      }
    }
   
    //removing retransmitterMgr entries
    Collection collection = retransmitterBeanMgr.find(internalSequenceID);
    Iterator iterator = collection.iterator();
    while (iterator.hasNext()) {
      SenderBean retransmitterBean = (SenderBean) iterator.next();
      retransmitterBeanMgr.delete(retransmitterBean.getMessageID());
    }
   
    //removing the createSeqMgrEntry
    CreateSeqBean findCreateSequenceBean = new CreateSeqBean ();
    findCreateSequenceBean.setInternalSequenceID(internalSequenceID);
View Full Code Here

    terminateRMMessage.getMessageContext().setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING,
        Sandesha2Constants.VALUE_FALSE);
   
    terminateBean.setReSend(false);

    SenderBeanMgr retramsmitterMgr = storageManager
        .getRetransmitterBeanMgr();

    retramsmitterMgr.insert(terminateBean);
   
    SequencePropertyBean terminateAdded = new SequencePropertyBean();
    terminateAdded.setName(Sandesha2Constants.SequenceProperties.TERMINATE_ADDED);
    terminateAdded.setSequenceID(outSequenceId);
    terminateAdded.setValue("true");
View Full Code Here

    //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);
      offeredSequenceBean.setSequenceID(internalSequenceId);
      offeredSequenceBean.setValue(offeredSequenceId);

      seqPropMgr.insert(offeredSequenceBean);
    }

    MessageContext createSeqMsg = createSeqRMMessage.getMessageContext();
    createSeqMsg.setRelationships(null); // create seq msg does not relateTo anything

    CreateSeqBean createSeqBean = new CreateSeqBean(internalSequenceId,createSeqMsg.getMessageID(), null);
    createSeqMgr.insert(createSeqBean);

    String addressingNamespaceURI = SandeshaUtil.getSequenceProperty(internalSequenceId,Sandesha2Constants.SequenceProperties.ADDRESSING_NAMESPACE_VALUE,configCtx);
    String anonymousURI = SpecSpecificConstants.getAddressingAnonymousURI(addressingNamespaceURI);
   
    if (createSeqMsg.getReplyTo() == null)
      createSeqMsg.setReplyTo(new EndpointReference(anonymousURI));

    String key = SandeshaUtil.getUUID();   //the key used to store the create sequence message.

    SenderBean createSeqEntry = new SenderBean();
    createSeqEntry.setMessageContextRefKey(key);
    createSeqEntry.setTimeToSend(System.currentTimeMillis());
    createSeqEntry.setMessageID(createSeqRMMessage.getMessageId());
    createSeqEntry.setInternalSequenceID(internalSequenceId);
    // this will be set to true in the sender
    createSeqEntry.setSend(true);

    createSeqMsg.setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING,Sandesha2Constants.VALUE_FALSE);
    createSeqEntry.setMessageType(Sandesha2Constants.MessageTypes.CREATE_SEQ);
    retransmitterMgr.insert(createSeqEntry);
   
    storageManager.storeMessageContext(key,createSeqMsg);   //storing the message.
   

    // message will be stored in the Sandesha2TransportSender   
View Full Code Here

    ConfigurationContext configurationContext = rmMsg.getMessageContext().getConfigurationContext();

    //retrieving storage manager
    StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(msg.getConfigurationContext());
    SequencePropertyBeanMgr sequencePropertyMgr = storageManager.getSequencePropretyBeanMgr();
    SenderBeanMgr retransmitterMgr = storageManager.getRetransmitterBeanMgr();

    SequencePropertyBean toBean = sequencePropertyMgr.retrieve(
        internalSequenceId,Sandesha2Constants.SequenceProperties.TO_EPR);
    SequencePropertyBean replyToBean = sequencePropertyMgr.retrieve(
        internalSequenceId,Sandesha2Constants.SequenceProperties.REPLY_TO_EPR);

    // again - looks weird in the client side - but consistent
    SequencePropertyBean outSequenceBean = sequencePropertyMgr.retrieve(
        internalSequenceId,Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID);

    if (toBean == null) {
      String message = "To is null";
      log.debug(message);
      throw new SandeshaException(message);
    }

    EndpointReference toEPR = new EndpointReference(toBean.getValue());
   
    EndpointReference replyToEPR = null;
    if (replyToBean != null) {
      replyToEPR = new EndpointReference(replyToBean.getValue());
    }

    if (toEPR == null || toEPR.getAddress() == null || toEPR.getAddress() == "") {
      String message = "To Property has an invalid value";
      log.debug(message);
      throw new SandeshaException(message);
    }

    String newToStr = null;
    if (msg.isServerSide()) {
      try {
        MessageContext requestMsg = msg.getOperationContext().getMessageContext(
                OperationContextFactory.MESSAGE_LABEL_IN_VALUE);
        if (requestMsg != null) {
          newToStr = requestMsg.getReplyTo().getAddress();
        }
      } catch (AxisFault e) {
        throw new SandeshaException(e.getMessage());
      }
    }

    if (newToStr != null)
      rmMsg.setTo(new EndpointReference(newToStr));
    else
      rmMsg.setTo(toEPR);

    if (replyToEPR != null)
      rmMsg.setReplyTo(replyToEPR);

    String rmVersion = SandeshaUtil.getRMVersion(internalSequenceId,configurationContext);
    if (rmVersion==null)
      throw new SandeshaException ("Cant find the rmVersion of the given message");
   
    String rmNamespaceValue = SpecSpecificConstants.getRMNamespaceValue(rmVersion);
   
    Sequence sequence = new Sequence(factory,rmNamespaceValue);
    MessageNumber msgNumber = new MessageNumber(factory,rmNamespaceValue);
    msgNumber.setMessageNumber(messageNumber);
    sequence.setMessageNumber(msgNumber);

    boolean lastMessage = false;
    // setting last message
    if (msg.isServerSide()) {
      MessageContext requestMsg = null;

      try {
        requestMsg = msg.getOperationContext().getMessageContext(OperationContextFactory.MESSAGE_LABEL_IN_VALUE);
      } catch (AxisFault e) {
        throw new SandeshaException(e.getMessage());
      }

      RMMsgContext reqRMMsgCtx = MsgInitializer.initializeMessage(requestMsg);
      Sequence requestSequence = (Sequence) reqRMMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.SEQUENCE);
      if (requestSequence == null) {
        String message = "Request Sequence is null";
        log.debug(message);
        throw new SandeshaException(message);
      }

      if (requestSequence.getLastMessage() != null) {
        lastMessage = true;
        sequence.setLastMessage(new LastMessage(factory,rmNamespaceValue));

      }

    } else {
      // client side

      OperationContext operationContext = msg.getOperationContext();
      if (operationContext != null) {
        Object obj = msg.getProperty(SandeshaClientConstants.LAST_MESSAGE);
        if (obj != null && "true".equals(obj)) {
          lastMessage = true;
         
          SequencePropertyBean specVersionBean = sequencePropertyMgr.retrieve(internalSequenceId,Sandesha2Constants.SequenceProperties.RM_SPEC_VERSION);
          if (specVersionBean==null)
            throw new SandeshaException ("Spec version bean is not set");
         
          String specVersion = specVersionBean.getValue();
          if (SpecSpecificConstants.isLastMessageIndicatorRequired(specVersion))
            sequence.setLastMessage(new LastMessage(factory,rmNamespaceValue));
        }
      }
    }

    AckRequested ackRequested = null;

    boolean addAckRequested = false;
    //if (!lastMessage)
//    addAckRequested = true;   //TODO decide the policy to add the ackRequested tag

    // setting the Sequnece id.
    // Set send = true/false depending on the availability of the out
    // sequence id.
    String identifierStr = null;
    if (outSequenceBean == null || outSequenceBean.getValue() == null) {
      identifierStr = Sandesha2Constants.TEMP_SEQUENCE_ID;

    } else {
      identifierStr = (String) outSequenceBean.getValue();
    }

    Identifier id1 = new Identifier(factory,rmNamespaceValue);
    id1.setIndentifer(identifierStr);
    sequence.setIdentifier(id1);
    rmMsg.setMessagePart(Sandesha2Constants.MessageParts.SEQUENCE,sequence);

    if (addAckRequested) {
      ackRequested = new AckRequested(factory,rmNamespaceValue);
      Identifier id2 = new Identifier(factory,rmNamespaceValue);
      id2.setIndentifer(identifierStr);
      ackRequested.setIdentifier(id2);
      rmMsg.setMessagePart(Sandesha2Constants.MessageParts.ACK_REQUEST,
          ackRequested);
    }

    try {
      rmMsg.addSOAPEnvelope();
    } catch (AxisFault e1) {
      throw new SandeshaException(e1.getMessage());
    }

    //Retransmitter bean entry for the application message
    SenderBean appMsgEntry = new SenderBean();
   
    appMsgEntry.setMessageContextRefKey(storageKey);

    appMsgEntry.setTimeToSend(System.currentTimeMillis());
    appMsgEntry.setMessageID(rmMsg.getMessageId());
    appMsgEntry.setMessageNumber(messageNumber);
    appMsgEntry.setMessageType(Sandesha2Constants.MessageTypes.APPLICATION);
    if (outSequenceBean == null || outSequenceBean.getValue() == null) {
      appMsgEntry.setSend(false);
    } else {
      appMsgEntry.setSend(true);
      // Send will be set to true at the sender.
      msg.setProperty(Sandesha2Constants.SET_SEND_TO_TRUE,
          Sandesha2Constants.VALUE_TRUE);
    }

    appMsgEntry.setInternalSequenceID(internalSequenceId);
    storageManager.storeMessageContext(storageKey,msg);
    retransmitterMgr.insert(appMsgEntry);
    msg.setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING,Sandesha2Constants.VALUE_FALSE);

    // changing the sender. This will set send to true.
    TransportSender sender = msg.getTransportOut().getSender();
View Full Code Here

      }
    } else {

      Transaction asyncAckTransaction = storageManager.getTransaction();

      SenderBeanMgr retransmitterBeanMgr = storageManager
          .getRetransmitterBeanMgr();

      String key = SandeshaUtil.getUUID();
     
      //dumping to the storage will be done be Sandesha2 Transport Sender
      //storageManager.storeMessageContext(key,ackMsgCtx);
     
      SenderBean ackBean = new SenderBean();
      ackBean.setMessageContextRefKey(key);
      ackBean.setMessageID(ackMsgCtx.getMessageID());
      ackBean.setReSend(false);
      ackBean.setSequenceID(sequenceID);
     
      //this will be set to true in the sender.
      ackBean.setSend(true);
     
      ackMsgCtx.setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING,
          Sandesha2Constants.VALUE_FALSE);
     
      ackBean.setMessageType(Sandesha2Constants.MessageTypes.ACK);
     
      //the internalSequenceId value of the retransmitter Table for the
      // messages related to an incoming
      //sequence is the actual sequence ID

      //operation is the lowest level, Sandesha2 can be engaged.
      SandeshaPropertyBean propertyBean = SandeshaUtil.getPropertyBean(msgContext.getAxisOperation());
     
     
      long ackInterval = propertyBean.getAcknowledgementInaterval();
     
      //Ack will be sent as stand alone, only after the retransmitter
      // interval.
      long timeToSend = System.currentTimeMillis() + ackInterval;

      //removing old acks.
      SenderBean findBean = new SenderBean();
      findBean.setMessageType(Sandesha2Constants.MessageTypes.ACK);
     
      //this will be set to true in the sandesha2TransportSender.
      findBean.setSend(true);
      findBean.setReSend(false);
      Collection coll = retransmitterBeanMgr.find(findBean);
      Iterator it = coll.iterator();

      if (it.hasNext()) {
        SenderBean oldAckBean = (SenderBean) it.next();
        timeToSend = oldAckBean.getTimeToSend();    //If there is an old ack. This ack will be sent in the old timeToSend.
        retransmitterBeanMgr.delete(oldAckBean.getMessageID());
      }
     
      ackBean.setTimeToSend(timeToSend);

      storageManager.storeMessageContext(key,ackMsgCtx);
     
      //inserting the new ack.
      retransmitterBeanMgr.insert(ackBean);

      asyncAckTransaction.commit();

      //passing the message through sandesha2sender
View Full Code Here

    rmMsgCtx.addSOAPEnvelope();

    StorageManager storageManager = SandeshaUtil
        .getSandeshaStorageManager(rmMsgCtx.getMessageContext()
            .getConfigurationContext());
    SenderBeanMgr retransmitterMgr = storageManager
        .getRetransmitterBeanMgr();
    SequencePropertyBeanMgr seqPropMgr = storageManager
        .getSequencePropretyBeanMgr();



    Iterator ackRangeIterator = sequenceAck.getAcknowledgementRanges()
        .iterator();

    Iterator nackIterator = sequenceAck.getNackList().iterator();
    String outSequenceId = sequenceAck.getIdentifier().getIdentifier();
    if (outSequenceId == null || "".equals(outSequenceId)) {
      String message = "OutSequenceId is null";
      log.debug(message);
      throw new SandeshaException(message);
    }

    FaultManager faultManager = new FaultManager();
    RMMsgContext faultMessageContext = faultManager.checkForUnknownSequence(rmMsgCtx,outSequenceId);
    if (faultMessageContext != null) {
      ConfigurationContext configurationContext = msgCtx.getConfigurationContext();
      AxisEngine engine = new AxisEngine(configurationContext);
     
      try {
        engine.sendFault(faultMessageContext.getMessageContext());
      } catch (AxisFault e) {
        throw new SandeshaException ("Could not send the fault message",e);
      }
     
      return;
    }
   
    faultMessageContext = faultManager.checkForInvalidAcknowledgement(rmMsgCtx);
    if (faultMessageContext != null) {
      ConfigurationContext configurationContext = msgCtx.getConfigurationContext();
      AxisEngine engine = new AxisEngine(configurationContext);
     
      try {
        engine.sendFault(faultMessageContext.getMessageContext());
      } catch (AxisFault e) {
        throw new SandeshaException ("Could not send the fault message",e);
      }
     
      return;
    }
   
        String internalSequenceID = SandeshaUtil.getSequenceProperty(outSequenceId,Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID,configCtx);
   
        //updating the last activated time of the sequence.
    Transaction lastUpdatedTimeTransaction = storageManager.getTransaction();
    SequenceManager.updateLastActivatedTime(internalSequenceID,rmMsgCtx.getMessageContext().getConfigurationContext());
    lastUpdatedTimeTransaction.commit();
   
    //Starting transaction
    Transaction ackTransaction = storageManager.getTransaction();

    SequencePropertyBean internalSequenceBean = seqPropMgr.retrieve(
        outSequenceId, Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID);

    if (internalSequenceBean == null || internalSequenceBean.getValue() == null) {
      String message = "TempSequenceId is not set correctly";
      log.debug(message);
      throw new SandeshaException(message);
    }

    String internalSequenceId = (String) internalSequenceBean.getValue();

    //Following happens in the SandeshaGlobal handler
    rmMsgCtx.getMessageContext()
        .setProperty(Sandesha2Constants.ACK_PROCSSED, "true");

    //Removing relatesTo - Some v1_0 endpoints tend to set relatesTo value for ack messages.
    //Because of this dispatching may go wrong. So we set relatesTo value to null for ackMessages.
    //(this happens in the SandeshaGlobal handler). Do this only if this is a standalone ACK.
//    if (rmMsgCtx.getMessageType() == Sandesha2Constants.MessageTypes.ACK)
//      rmMsgCtx.setRelatesTo(null);

    SenderBean input = new SenderBean();
    input.setSend(true);
    input.setReSend(true);
    Collection retransmitterEntriesOfSequence = retransmitterMgr
        .find(input);

    ArrayList ackedMessagesList = new ArrayList ();
    while (ackRangeIterator.hasNext()) {
      AcknowledgementRange ackRange = (AcknowledgementRange) ackRangeIterator
          .next();
      long lower = ackRange.getLowerValue();
      long upper = ackRange.getUpperValue();

      for (long messageNo = lower; messageNo <= upper; messageNo++) {
        SenderBean retransmitterBean = getRetransmitterEntry(
            retransmitterEntriesOfSequence, messageNo);
        if (retransmitterBean != null)
          retransmitterMgr.delete(retransmitterBean.getMessageID());
       
        ackedMessagesList.add(new Long (messageNo));
      }
    }
View Full Code Here

      throw new SandeshaException ("Invalid create sequence message. RelatesTo part is not available");
    }
    String createSeqMsgId = relatesTo.getValue();


    SenderBeanMgr retransmitterMgr = storageManager
        .getRetransmitterBeanMgr();
    CreateSeqBeanMgr createSeqMgr = storageManager.getCreateSeqBeanMgr();

    CreateSeqBean createSeqBean = createSeqMgr.retrieve(createSeqMsgId);
    if (createSeqBean == null) {
      String message = "Create Sequence entry is not found";
      log.debug(message);
      throw new SandeshaException(message);
    }

    String internalSequenceId = createSeqBean.getInternalSequenceID();
    if (internalSequenceId == null || "".equals(internalSequenceId)) {
      String message = "TempSequenceId has is not set";
      log.debug(message);
      throw new SandeshaException(message);
    }
   
    createSeqBean.setSequenceID(newOutSequenceId);
    createSeqMgr.update(createSeqBean);

    //deleting the create sequence entry.
    retransmitterMgr.delete(createSeqMsgId);

    //storing new out sequence id
    SequencePropertyBeanMgr sequencePropMgr = storageManager
        .getSequencePropretyBeanMgr();
    SequencePropertyBean outSequenceBean = new SequencePropertyBean(
        internalSequenceId, Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID,
        newOutSequenceId);
    SequencePropertyBean internalSequenceBean = new SequencePropertyBean(
        newOutSequenceId,
        Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID, internalSequenceId);
   
   
    sequencePropMgr.insert(outSequenceBean);
    sequencePropMgr.insert(internalSequenceBean);

    createSeqResponseTransaction.commit();
   
   
    Transaction offerProcessTransaction = storageManager.getTransaction();
   
    //processing for accept (offer has been sent)
    Accept accept = createSeqResponsePart.getAccept();
    if (accept != null) {
      //Find offered sequence from internal sequence id.
      SequencePropertyBean offeredSequenceBean = sequencePropMgr
          .retrieve(internalSequenceId,
              Sandesha2Constants.SequenceProperties.OFFERED_SEQUENCE);

      //TODO this should be detected in the Fault manager.
      if (offeredSequenceBean == null) {
        String message = "No offered sequence entry. But an accept was received";
        log.debug(message);
        throw new SandeshaException(message);
      }

      String offeredSequenceId = (String) offeredSequenceBean.getValue();

      EndpointReference acksToEPR = accept.getAcksTo().getAddress()
          .getEpr();
      SequencePropertyBean acksToBean = new SequencePropertyBean();
      acksToBean.setName(Sandesha2Constants.SequenceProperties.ACKS_TO_EPR);
      acksToBean.setSequenceID(offeredSequenceId);
      acksToBean.setValue(acksToEPR.getAddress());

      sequencePropMgr.insert(acksToBean);

      NextMsgBean nextMsgBean = new NextMsgBean();
      nextMsgBean.setSequenceID(offeredSequenceId);
      nextMsgBean.setNextMsgNoToProcess(1);

      NextMsgBeanMgr nextMsgMgr = storageManager.getNextMsgBeanMgr();
      nextMsgMgr.insert(nextMsgBean);
     
      String rmSpecVersion = createSeqResponseRMMsgCtx.getRMSpecVersion();
     
      SequencePropertyBean specVersionBean = new SequencePropertyBean (
          offeredSequenceId,Sandesha2Constants.SequenceProperties.RM_SPEC_VERSION,rmSpecVersion);
      sequencePropMgr.insert(specVersionBean);
     
      SequencePropertyBean receivedMsgBean = new SequencePropertyBean(
          offeredSequenceId, Sandesha2Constants.SequenceProperties.SERVER_COMPLETED_MESSAGES, "");
      sequencePropMgr.insert(receivedMsgBean);
     
      SequencePropertyBean msgsBean = new SequencePropertyBean();
      msgsBean.setSequenceID(offeredSequenceId);
      msgsBean.setName(Sandesha2Constants.SequenceProperties.CLIENT_COMPLETED_MESSAGES);
      msgsBean.setValue("");
      sequencePropMgr.insert(msgsBean);
     
     
      //setting the addressing version.
      String addressingNamespace = createSeqResponseRMMsgCtx.getAddressingNamespaceValue();
      SequencePropertyBean addressingVersionBean = new SequencePropertyBean (
          offeredSequenceId,Sandesha2Constants.SequenceProperties.ADDRESSING_NAMESPACE_VALUE,addressingNamespace);
      sequencePropMgr.insert(addressingVersionBean);
     
    }

    offerProcessTransaction.commit();
   
    Transaction updateAppMessagesTransaction = storageManager.getTransaction();
   
    SenderBean target = new SenderBean();
    target.setInternalSequenceID(internalSequenceId);
    target.setSend(false);
    target.setReSend(true);

    Iterator iterator = retransmitterMgr.find(target).iterator();
    while (iterator.hasNext()) {
      SenderBean tempBean = (SenderBean) iterator.next();

      //updating the application message
      String key = tempBean.getMessageContextRefKey();
      MessageContext applicationMsg = storageManager.retrieveMessageContext(key,configCtx);

      //TODO make following exception message more understandable to the user (probably some others exceptions messages as well)
      if (applicationMsg==null)
        throw new SandeshaException ("Unavailable application message");
     
      String rmVersion = SandeshaUtil.getRMVersion(internalSequenceId,configCtx);
      if (rmVersion==null)
        throw new SandeshaException ("Cant find the rmVersion of the given message");
     
      String assumedRMNamespace = SpecSpecificConstants.getRMNamespaceValue(rmVersion);
     
      RMMsgContext applicaionRMMsg = MsgInitializer
          .initializeMessage(applicationMsg);

      Sequence sequencePart = (Sequence) applicaionRMMsg
          .getMessagePart(Sandesha2Constants.MessageParts.SEQUENCE);
      if (sequencePart == null) {
        String message = "Sequence part is null";
        log.debug(message);
        throw new SandeshaException(message);
      }
     
      Identifier identifier = new Identifier(factory,assumedRMNamespace);
      identifier.setIndentifer(newOutSequenceId);

      sequencePart.setIdentifier(identifier);

      AckRequested ackRequestedPart = (AckRequested) applicaionRMMsg
          .getMessagePart(Sandesha2Constants.MessageParts.ACK_REQUEST);
      if (ackRequestedPart != null) {
        Identifier id1 = new Identifier(factory,assumedRMNamespace);
        id1.setIndentifer(newOutSequenceId);
        ackRequestedPart.setIdentifier(id1);
      }

      try {
        applicaionRMMsg.addSOAPEnvelope();
      } catch (AxisFault e) {
        throw new SandeshaException(e.getMessage());
      }
     
      //asking to send the application msssage
      tempBean.setSend(true);
      retransmitterMgr.update(tempBean);
     
      //updating the message. this will correct the SOAP envelope string.
      storageManager.updateMessageContext(key,applicationMsg);
    }
View Full Code Here

      RMMsgContext rmMessageContext) throws SandeshaException {
   
    ConfigurationContext configurationContext = rmMessageContext.getConfigurationContext();
    StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configurationContext);

    SenderBeanMgr retransmitterBeanMgr = storageManager.getRetransmitterBeanMgr();
    SequencePropertyBeanMgr sequencePropertyBeanMgr = storageManager.getSequencePropretyBeanMgr();

    SenderBean findBean = new SenderBean();

    String sequnceID = SandeshaUtil.getSequenceIDFromRMMessage (rmMessageContext);

    findBean.setMessageType(Sandesha2Constants.MessageTypes.ACK);
    findBean.setSend(true);
    findBean.setReSend(false);
   
    String carrietTo = rmMessageContext.getTo().getAddress();
   
    Collection collection = retransmitterBeanMgr.find(findBean);
   
    Iterator it = collection.iterator();

   
    piggybackLoop:
    while (it.hasNext()) {
      SenderBean ackBean = (SenderBean) it.next();

      long timeNow = System.currentTimeMillis();
      if (ackBean.getTimeToSend() > timeNow) {
        //Piggybacking will happen only if the end of ack interval (timeToSend) is not reached.

        MessageContext ackMsgContext = storageManager
        .retrieveMessageContext(ackBean.getMessageContextRefKey(),configurationContext);
       
        //wsa:To has to match for piggybacking.
        String to = ackMsgContext.getTo().getAddress();
        if (!carrietTo.equals(to)) {
          continue piggybackLoop;
        }
       
        String ackSequenceID = ackBean.getSequenceID();
       
        //sequenceID has to match for piggybacking
        if (!ackSequenceID.equals(sequnceID)) {
          continue piggybackLoop;
        }
       
        //deleting the ack entry.
        retransmitterBeanMgr.delete(ackBean.getMessageID());

        //Adding the ack to the application message
        RMMsgContext ackRMMsgContext = MsgInitializer.initializeMessage(ackMsgContext);
        if (ackRMMsgContext.getMessageType() != Sandesha2Constants.MessageTypes.ACK) {
          String message = "Invalid ack message entry";
View Full Code Here

     
    } else {

      Transaction asyncAckTransaction = storageManager.getTransaction();

      SenderBeanMgr retransmitterBeanMgr = storageManager
          .getRetransmitterBeanMgr();

      String key = SandeshaUtil.getUUID();
     
      SenderBean ackBean = new SenderBean();
      ackBean.setMessageContextRefKey(key);
      ackBean.setMessageID(ackMsgCtx.getMessageID());
      ackBean.setReSend(false);
      ackBean.setSequenceID(sequenceID);
     
      //this will be set to true in the sender.
      ackBean.setSend(true);
     
      ackMsgCtx.setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING,
          Sandesha2Constants.VALUE_FALSE);
     
      ackBean.setMessageType(Sandesha2Constants.MessageTypes.ACK);
      long ackInterval = SandeshaUtil.getPropertyBean(referenceMsg.getAxisOperation()).getAcknowledgementInaterval();
     
      //Ack will be sent as stand alone, only after the retransmitter
      // interval.
      long timeToSend = System.currentTimeMillis() + ackInterval;

      //removing old acks.
      SenderBean findBean = new SenderBean();
      findBean.setMessageType(Sandesha2Constants.MessageTypes.ACK);
     
      //this will be set to true in the sandesha2TransportSender.
      findBean.setSend(true);
      findBean.setReSend(false);
      Collection coll = retransmitterBeanMgr.find(findBean);
      Iterator it = coll.iterator();

      if (it.hasNext()) {
        SenderBean oldAckBean = (SenderBean) it.next();
        timeToSend = oldAckBean.getTimeToSend();    //If there is an old ack. This ack will be sent in the old timeToSend.
        retransmitterBeanMgr.delete(oldAckBean.getMessageID());
      }
     
      ackBean.setTimeToSend(timeToSend);
      storageManager.storeMessageContext(key,ackMsgCtx);
     
      //inserting the new ack.
      retransmitterBeanMgr.insert(ackBean);
      asyncAckTransaction.commit();

      //passing the message through sandesha2sender
      ackMsgCtx.setProperty(Sandesha2Constants.ORIGINAL_TRANSPORT_OUT_DESC,ackMsgCtx.getTransportOut());
      ackMsgCtx.setProperty(Sandesha2Constants.SET_SEND_TO_TRUE,Sandesha2Constants.VALUE_TRUE);
View Full Code Here

TOP

Related Classes of org.apache.sandesha2.storage.beanmanagers.SenderBeanMgr

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.