Package org.apache.sandesha2.storage.beanmanagers

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


    SequenceAcknowledgement sequenceAck = new SequenceAcknowledgement(rmNamespaceValue);
    Identifier id = new Identifier(rmNamespaceValue);
    id.setIndentifer(sequenceId);
    sequenceAck.setIdentifier(id);

    SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();

    SequencePropertyBean seqBean = seqPropMgr.retrieve(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.SERVER_COMPLETED_MESSAGES);
    String msgNoList = (String) seqBean.getValue();

    ArrayList ackRangeArrayList = SandeshaUtil.getAckRangeArrayList(msgNoList, factory, rmNamespaceValue);
    Iterator iterator = ackRangeArrayList.iterator();
    while (iterator.hasNext()) {
      AcknowledgementRange ackRange = (AcknowledgementRange) iterator.next();
      sequenceAck.addAcknowledgementRanges(ackRange);
    }

    SequencePropertyBean sequenceClosedBean = seqPropMgr.retrieve(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.SEQUENCE_CLOSED);

    if (sequenceClosedBean != null && Sandesha2Constants.VALUE_TRUE.equals(sequenceClosedBean.getValue())) {
      // sequence is closed. so add the 'Final' part.
      if (SpecSpecificConstants.isAckFinalAllowed(rmVersion)) {
View Full Code Here


   */
  public static void updateLastActivatedTime(String sequencePropertyKey, StorageManager storageManager)
      throws SandeshaException {
    // Transaction lastActivatedTransaction =
    // storageManager.getTransaction();
    SequencePropertyBeanMgr sequencePropertyBeanMgr = storageManager.getSequencePropertyBeanMgr();

    SequencePropertyBean lastActivatedBean = sequencePropertyBeanMgr.retrieve(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.LAST_ACTIVATED_TIME);

    boolean added = false;

    if (lastActivatedBean == null) {
      added = true;
      lastActivatedBean = new SequencePropertyBean();
      lastActivatedBean.setSequencePropertyKey(sequencePropertyKey);
      lastActivatedBean.setName(Sandesha2Constants.SequenceProperties.LAST_ACTIVATED_TIME);
    }

    long currentTime = System.currentTimeMillis();
    lastActivatedBean.setValue(Long.toString(currentTime));

    if (added)
      sequencePropertyBeanMgr.insert(lastActivatedBean);
    else
      sequencePropertyBeanMgr.update(lastActivatedBean);

  }
View Full Code Here

  }

  public static long getLastActivatedTime(String propertyKey, StorageManager storageManager) throws SandeshaException {

    SequencePropertyBeanMgr seqPropBeanMgr = storageManager.getSequencePropertyBeanMgr();

    SequencePropertyBean lastActivatedBean = seqPropBeanMgr.retrieve(propertyKey,
        Sandesha2Constants.SequenceProperties.LAST_ACTIVATED_TIME);

    long lastActivatedTime = -1;

    if (lastActivatedBean != null) {
View Full Code Here

  }

  public static long getOutGoingSequenceAckedMessageCount(String sequencePropertyKey, StorageManager storageManager)
      throws SandeshaException {
    // / Transaction transaction = storageManager.getTransaction();
    SequencePropertyBeanMgr seqPropBeanMgr = storageManager.getSequencePropertyBeanMgr();

    SequencePropertyBean ackedMsgBean = seqPropBeanMgr.retrieve(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.NO_OF_OUTGOING_MSGS_ACKED);
    if (ackedMsgBean == null)
      return 0; // No acknowledgement has been received yet.

    long noOfMessagesAcked = Long.parseLong(ackedMsgBean.getValue());
View Full Code Here

  }

  public static boolean isOutGoingSequenceCompleted(String internalSequenceID, StorageManager storageManager)
      throws SandeshaException {
    // / Transaction transaction = storageManager.getTransaction();
    SequencePropertyBeanMgr seqPropBeanMgr = storageManager.getSequencePropertyBeanMgr();

    SequencePropertyBean findSeqIDBean = new SequencePropertyBean();
    findSeqIDBean.setValue(internalSequenceID);
    findSeqIDBean.setName(Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID);
    Collection seqIDBeans = seqPropBeanMgr.find(findSeqIDBean);

    if (seqIDBeans.size() == 0) {
      String message = SandeshaMessageHelper.getMessage(SandeshaMessageKeys.noSequenceEstablished);
      log.debug(message);
      throw new SandeshaException(message);
    }

    if (seqIDBeans.size() > 1) {
      String message = SandeshaMessageHelper.getMessage(
          SandeshaMessageKeys.cannotGenerateReportNonUniqueSequence, internalSequenceID);
      log.debug(message);
      throw new SandeshaException(message);
    }

    SequencePropertyBean seqIDBean = (SequencePropertyBean) seqIDBeans.iterator().next();
    String sequenceID = seqIDBean.getSequencePropertyKey();

    SequencePropertyBean terminateAddedBean = seqPropBeanMgr.retrieve(sequenceID,
        Sandesha2Constants.SequenceProperties.TERMINATE_ADDED);
    if (terminateAddedBean == null)
      return false;

    if ("true".equals(terminateAddedBean.getValue()))
View Full Code Here

  public static boolean isIncomingSequenceCompleted(String sequenceID, StorageManager storageManager)
      throws SandeshaException {

    // / Transaction transaction = storageManager.getTransaction();
    SequencePropertyBeanMgr seqPropBeanMgr = storageManager.getSequencePropertyBeanMgr();

    SequencePropertyBean terminateReceivedBean = seqPropBeanMgr.retrieve(sequenceID,
        Sandesha2Constants.SequenceProperties.TERMINATE_RECEIVED);
    boolean complete = false;

    if (terminateReceivedBean != null && "true".equals(terminateReceivedBean.getValue()))
      complete = true;
View Full Code Here

    StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configCtx, configCtx
        .getAxisConfiguration());

    SenderBeanMgr senderBeanMgr = storageManager.getSenderBeanMgr();
    SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();

    String outSequenceId = sequenceAck.getIdentifier().getIdentifier();
    if (outSequenceId == null || "".equals(outSequenceId)) {
      String message = SandeshaMessageHelper.getMessage(SandeshaMessageKeys.outSeqIDIsNull);
      log.debug(message);
      throw new SandeshaException(message);
    }
   
    String internalSequenceId = SandeshaUtil.getSequenceProperty(outSequenceId,
        Sandesha2Constants.SequenceProperties.INTERNAL_SEQUENCE_ID, storageManager);

    //here we cannot get the property key using the usual SandeshaUtil.getSequencePropertyKey function,
    //because this can be a applicationMessage, which piggybacks the acknowledgement.
    String sequencePropertyKey = internalSequenceId;

    // Check that the sender of this Ack holds the correct token
    SequencePropertyBean tokenBean = seqPropMgr.retrieve(outSequenceId, Sandesha2Constants.SequenceProperties.SECURITY_TOKEN);
    if(tokenBean != null) {
      SecurityManager secManager = SandeshaUtil.getSecurityManager(configCtx);
      SecurityToken token = secManager.recoverSecurityToken(tokenBean.getValue());
     
      secManager.checkProofOfPossession(token, soapHeader, msgCtx);
    }
   
    Iterator ackRangeIterator = sequenceAck.getAcknowledgementRanges().iterator();
    Iterator nackIterator = sequenceAck.getNackList().iterator();

    FaultManager faultManager = new FaultManager();
    SandeshaException fault = faultManager
        .checkForUnknownSequence(rmMsgCtx, outSequenceId, storageManager);
    if(fault == null) {
      fault = faultManager.checkForInvalidAcknowledgement(rmMsgCtx, storageManager);
    }
    if (fault != null) {
      throw fault;
    }

    // updating the last activated time of the sequence.
    SequenceManager.updateLastActivatedTime(sequencePropertyKey, storageManager);

    SenderBean input = new SenderBean();
    input.setSend(true);
    input.setReSend(true);
    Collection retransmitterEntriesOfSequence = senderBeanMgr.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 = getSenderEntry(retransmitterEntriesOfSequence, messageNo);
        if (retransmitterBean != null) {
          senderBeanMgr.delete(retransmitterBean.getMessageID());

          // removing the application message from the storage.
          String storageKey = retransmitterBean.getMessageContextRefKey();
          storageManager.removeMessageContext(storageKey);
        }

        ackedMessagesList.add(new Long(messageNo));
      }
    }

    while (nackIterator.hasNext()) {
      Nack nack = (Nack) nackIterator.next();
      long msgNo = nack.getNackNumber();

      // TODO - Process Nack
    }
   
    //adding a MakeConnection for the response sequence if needed.
    String offeredSequenceId = SandeshaUtil.getSequenceProperty(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.OFFERED_SEQUENCE, storageManager);
    if (offeredSequenceId!=null) {

      RMDBeanMgr rmdBeanMgr = storageManager.getRMDBeanMgr();
      RMDBean rmdBean = rmdBeanMgr.retrieve(outSequenceId);
     
      if (rmdBean!=null && rmdBean.isPollingMode())
        SandeshaUtil.shedulePollingRequest(offeredSequenceId, configCtx);
     
    }
   
    // setting acked message date.
    // TODO add details specific to each message.
    long noOfMsgsAcked = getNoOfMessagesAcked(sequenceAck.getAcknowledgementRanges().iterator());
    SequencePropertyBean noOfMsgsAckedBean = seqPropMgr.retrieve(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.NO_OF_OUTGOING_MSGS_ACKED);
    boolean added = false;

    if (noOfMsgsAckedBean == null) {
      added = true;
      noOfMsgsAckedBean = new SequencePropertyBean();
      noOfMsgsAckedBean.setSequencePropertyKey(sequencePropertyKey);
      noOfMsgsAckedBean.setName(Sandesha2Constants.SequenceProperties.NO_OF_OUTGOING_MSGS_ACKED);
    }

    noOfMsgsAckedBean.setValue(Long.toString(noOfMsgsAcked));

    if (added)
      seqPropMgr.insert(noOfMsgsAckedBean);
    else
      seqPropMgr.update(noOfMsgsAckedBean);

    // setting the completed_messages list. This gives all the messages of
    // the sequence that were acked.
    SequencePropertyBean allCompletedMsgsBean = seqPropMgr.retrieve(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.CLIENT_COMPLETED_MESSAGES);
    if (allCompletedMsgsBean == null) {
      allCompletedMsgsBean = new SequencePropertyBean();
      allCompletedMsgsBean.setSequencePropertyKey(sequencePropertyKey);
      allCompletedMsgsBean.setName(Sandesha2Constants.SequenceProperties.CLIENT_COMPLETED_MESSAGES);

      seqPropMgr.insert(allCompletedMsgsBean);
    }

    String str = ackedMessagesList.toString();
    allCompletedMsgsBean.setValue(str);

    seqPropMgr.update(allCompletedMsgsBean);

    String lastOutMsgNoStr = SandeshaUtil.getSequenceProperty(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.LAST_OUT_MESSAGE_NO, storageManager);
    if (lastOutMsgNoStr != null) {
      long highestOutMsgNo = 0;
View Full Code Here

    if (log.isDebugEnabled())
      log.debug("Enter: AcknowledgementManager::generateAckMessage");

    MessageContext referenceMsg = referenceRMMessage.getMessageContext();

    SequencePropertyBeanMgr seqPropMgr = storageManager.getSequencePropertyBeanMgr();

    // Setting the ack depending on AcksTo.
    SequencePropertyBean acksToBean = seqPropMgr.retrieve(sequencePropertyKey,
        Sandesha2Constants.SequenceProperties.ACKS_TO_EPR);

    EndpointReference acksTo = new EndpointReference(acksToBean.getValue());
    String acksToStr = acksTo.getAddress();
View Full Code Here

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

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

    sequencePropMgr.insert(outSequenceBean);
    sequencePropMgr.insert(internalSequenceBean);
   
    // Store the security token under the new sequence id
    if(tokenData != null) {
      SequencePropertyBean newToken = new SequencePropertyBean(newOutSequenceId,
          Sandesha2Constants.SequenceProperties.SECURITY_TOKEN, tokenData);
      sequencePropMgr.insert(newToken);
    }

    // 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(sequencePropertyKey,
          Sandesha2Constants.SequenceProperties.OFFERED_SEQUENCE);

      // TODO this should be detected in the Fault manager.
      if (offeredSequenceBean == null) {
        String message = SandeshaMessageHelper.getMessage(SandeshaMessageKeys.accptButNoSequenceOffered);
        log.debug(message);
        throw new SandeshaException(message);
      }

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

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

      sequencePropMgr.insert(acksToBean);

      RMDBean rmdBean = new RMDBean();
      rmdBean.setSequenceID(offeredSequenceId);
      rmdBean.setNextMsgNoToProcess(1);
     

      boolean pollingMode = false;
      if (Sandesha2Constants.SPEC_VERSIONS.v1_1.equals(createSeqResponseRMMsgCtx.getRMSpecVersion())) {
        String replyToAddress = SandeshaUtil.getSequenceProperty(sequencePropertyKey,
                Sandesha2Constants.SequenceProperties.REPLY_TO_EPR, storageManager);
        if (replyToAddress!=null) {
          if (AddressingConstants.Submission.WSA_ANONYMOUS_URL.equals(replyToAddress))
            pollingMode = true;
          else if (AddressingConstants.Final.WSA_ANONYMOUS_URL.equals(replyToAddress))
            pollingMode = true;
          else if (replyToAddress.startsWith(Sandesha2Constants.WSRM_ANONYMOUS_URI_PREFIX))
            pollingMode = true;
        }
      }
     
      //Storing the referenceMessage of the sending side sequence as the reference message
      //of the receiving side as well.
      //This can be used when creating new outgoing messages.
     
      String referenceMsgStoreKey = rmsBean.getReferenceMessageStoreKey();
      MessageContext referenceMsg = storageManager.retrieveMessageContext(referenceMsgStoreKey, configCtx);
     
      String newMessageStoreKey = SandeshaUtil.getUUID();
      storageManager.storeMessageContext(newMessageStoreKey,referenceMsg);
     
      rmdBean.setReferenceMessageKey(newMessageStoreKey);
     
      rmdBean.setPollingMode(pollingMode);
     
      //if PollingMode is true, starting the pollingmanager.
      if (pollingMode)
        SandeshaUtil.startPollingManager(configCtx);
     
      RMDBeanMgr rmdBeanMgr = storageManager.getRMDBeanMgr();
      rmdBeanMgr.insert(rmdBean);

      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.setSequencePropertyKey(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);

      // Store the security token for the offered sequence
      if(tokenData != null) {
        SequencePropertyBean newToken = new SequencePropertyBean(offeredSequenceId,
            Sandesha2Constants.SequenceProperties.SECURITY_TOKEN, tokenData);
        sequencePropMgr.insert(newToken);
      }
    }

    SenderBean target = new SenderBean();
    target.setInternalSequenceID(internalSequenceId);
View Full Code Here

  }

  public static String getSequenceIDFromInternalSequenceID(String internalSequenceID,
      StorageManager storageManager) throws SandeshaException {

    SequencePropertyBeanMgr sequencePropertyBeanMgr = storageManager.getSequencePropertyBeanMgr();

    SequencePropertyBean outSequenceBean = sequencePropertyBeanMgr.retrieve(internalSequenceID,
        Sandesha2Constants.SequenceProperties.OUT_SEQUENCE_ID);

    String sequeunceID = null;
    if (outSequenceBean != null)
      sequeunceID = outSequenceBean.getValue();
View Full Code Here

TOP

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

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.