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

Package org.apache.sandesha2.storage.beanmanagers

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

org.apache.sandesha2.storage.beanmanagers.SenderBeanMgr
Used to manage Sender beans.


    terminateBean.setMessageId(terminateRMMessage.getMessageId());
    terminateBean.setSend(true);
    terminateBean.setReSend(false);


    SenderBeanMgr retramsmitterMgr = storageManager
        .getRetransmitterBeanMgr();


    SequencePropertyBean terminateAdded = new SequencePropertyBean();
    terminateAdded.setName(Sandesha2Constants.SequenceProperties.TERMINATE_ADDED);
    terminateAdded.setSequenceId(outSequenceId);
    terminateAdded.setValue("true");


    seqPropMgr.insert(terminateAdded);


    retramsmitterMgr.insert(terminateBean);


  }

View Full Code Here

        .getRelatesTo().getValue();


    StorageManager storageManager = SandeshaUtil
        .getSandeshaStorageManager(configCtx);


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


    CreateSeqBean createSeqBean = createSeqMgr.retrieve(createSeqMsgId);
    if (createSeqBean == null)
      throw new SandeshaException("Create Sequence entry is not found");


    String internalSequenceId = createSeqBean.getInternalSequenceId();
    if (internalSequenceId == null || "".equals(internalSequenceId))
      throw new SandeshaException("TempSequenceId has is not set");


    //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);


    //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)
        throw new SandeshaException(
            "No offered sequence. But an accept was received");


      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);


      sequencePropMgr.insert(acksToBean);


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


      NextMsgBeanMgr nextMsgMgr = storageManager.getNextMsgBeanMgr();
      nextMsgMgr.insert(nextMsgBean);
    }


    SenderBean target = new SenderBean();
    target.setInternalSequenceId(internalSequenceId);


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


      //updating the application message
      String key = tempBean.getKey();
      MessageContext applicationMsg = SandeshaUtil
          .getStoredMessageContext(key);


      RMMsgContext applicaionRMMsg = MsgInitializer
          .initializeMessage(applicationMsg);


      Sequence sequencePart = (Sequence) applicaionRMMsg
          .getMessagePart(Sandesha2Constants.MessageParts.SEQUENCE);
      if (sequencePart == null)
        throw new SandeshaException("Sequence part is null");


      Identifier identifier = new Identifier(factory);
      identifier.setIndentifer(newOutSequenceId);


      sequencePart.setIdentifier(identifier);


      AckRequested ackRequestedPart = (AckRequested) applicaionRMMsg
          .getMessagePart(Sandesha2Constants.MessageParts.ACK_REQUEST);
      if (ackRequestedPart != null) {
        Identifier id1 = new Identifier(factory);
        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);
    }


    createSeqResponseRMMsgCtx.getMessageContext().getOperationContext()
        .setProperty(org.apache.axis2.Constants.RESPONSE_WRITTEN,
            "false");

View Full Code Here

              "Can't continue the Sender. Context is null");


        StorageManager storageManager = SandeshaUtil
            .getSandeshaStorageManager(context);


        SenderBeanMgr mgr = storageManager
            .getRetransmitterBeanMgr();
        Collection coll = mgr.findMsgsToSend();
        Iterator iter = coll.iterator();


        while (iter.hasNext()) {


          SenderBean bean = (SenderBean) iter.next();
          String key = (String) bean.getKey();
          MessageContext msgCtx = SandeshaUtil
              .getStoredMessageContext(key);


          try {
            RMMsgContext rmMsgCtx = MsgInitializer
                .initializeMessage(msgCtx);


            updateMessage(msgCtx);


            ServiceContext serviceContext = msgCtx
                .getServiceContext();
            Object debug = null;
            if (serviceContext != null) {
              debug = msgCtx
                  .getProperty(Sandesha2ClientAPI.SANDESHA_DEBUG_MODE);
              if (debug != null && "on".equals(debug)) {
                System.out
                    .println("DEBUG: Sender is sending a '"
                        + SandeshaUtil
                            .getMessageTypeString(rmMsgCtx
                                .getMessageType())
                        + "' message.");
              }
            }


            if (rmMsgCtx.getMessageType() == Sandesha2Constants.MessageTypes.APPLICATION) {
              //piggybacking if an ack if available for the same
              // sequence.
              AcknowledgementManager
                  .piggybackAckIfPresent(rmMsgCtx);
            }


            try {
              new AxisEngine(context).send(msgCtx);
            } catch (Exception e) {
              //Exception is sending. retry later
              System.out
                  .println("Exception thrown in sending...");
              e.printStackTrace();
            }


            MessageRetransmissionAdjuster retransmitterAdjuster = new MessageRetransmissionAdjuster();
            retransmitterAdjuster.adjustRetransmittion(bean);


            mgr.update(bean);


            if (!msgCtx.isServerSide())
              checkForSyncResponses(msgCtx);
            
            
            if (rmMsgCtx.getMessageType()==Sandesha2Constants.MessageTypes.TERMINATE_SEQ) {
              //terminate sending side.
              TerminateSequence terminateSequence = (TerminateSequence) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.TERMINATE_SEQ);
              String sequenceID = terminateSequence.getIdentifier().getIdentifier();
              ConfigurationContext configContext = msgCtx.getConfigurationContext();
              
              TerminateManager.terminateSendingSide(configContext,sequenceID);
            }


          } catch (AxisFault e1) {
            e1.printStackTrace();
          } catch (Exception e3) {
            e3.printStackTrace();
          }


          //changing the values of the sent bean.
          //bean.setLastSentTime(System.currentTimeMillis());
          //bean.setSentCount(bean.getSentCount() + 1);


          //update if resend=true otherwise delete. (reSend=false
          // means
          // send only once).
          if (bean.isReSend())
            mgr.update(bean);
          else
            mgr.delete(bean.getMessageId());


        }
      } catch (SandeshaException e) {
        e.printStackTrace();
        return;

View Full Code Here


    if (createSeqMsg.getReplyTo() == null)
      createSeqMsg.setReplyTo(new EndpointReference(
          Sandesha2Constants.WSA.NS_URI_ANONYMOUS));


    SenderBeanMgr retransmitterMgr = storageManager
        .getRetransmitterBeanMgr();


    String key = SandeshaUtil.storeMessageContext(createSeqRMMessage
        .getMessageContext());
    SenderBean createSeqEntry = new SenderBean();
    createSeqEntry.setKey(key);
    createSeqEntry.setTimeToSend(System.currentTimeMillis());
    createSeqEntry.setMessageId(createSeqRMMessage.getMessageId());
    createSeqEntry.setSend(true);
    retransmitterMgr.insert(createSeqEntry);
  }

View Full Code Here

    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)
      throw new SandeshaException("To is null");


    EndpointReference toEPR = (EndpointReference) toBean.getValue();
    EndpointReference replyToEPR = null;


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


    if (toEPR == null || toEPR.getAddress() == null
        || toEPR.getAddress() == "")
      throw new SandeshaException("To Property has an invalid value");


    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);


    Sequence sequence = new Sequence(factory);


    MessageNumber msgNumber = new MessageNumber(factory);
    msgNumber.setMessageNumber(messageNumber);
    sequence.setMessageNumber(msgNumber);


    boolean lastMessage = false;
    //setting last message
    if (msg.isServerSide()) {
      //server side
      String incomingSeqId = internalSequenceId;
      MessageContext requestMsg = null;


      try {
        requestMsg = msg.getOperationContext().getMessageContext(
            WSDLConstants.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)
        throw new SandeshaException("Request Sequence is null");


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


        //saving the last message no.
        SequencePropertyBean lastOutMsgBean = new SequencePropertyBean(
            internalSequenceId,
            Sandesha2Constants.SequenceProperties.LAST_OUT_MESSAGE,
            new Long(messageNumber));
        sequencePropertyMgr.insert(lastOutMsgBean);
      }


    } else {
      //client side


      OperationContext operationContext = msg.getOperationContext();
      if (operationContext != null) {
        Object obj = msg.getProperty(Sandesha2ClientAPI.LAST_MESSAGE);
        if (obj != null && "true".equals(obj)) {
          lastMessage = true;
          sequence.setLastMessage(new LastMessage(factory));
          //saving the last message no.
          SequencePropertyBean lastOutMsgBean = new SequencePropertyBean(
              internalSequenceId,
              Sandesha2Constants.SequenceProperties.LAST_OUT_MESSAGE,
              new Long(messageNumber));
          sequencePropertyMgr.insert(lastOutMsgBean);
        }
      }
    }


    AckRequested ackRequested = null;


    boolean addAckRequested = false;
    if (!lastMessage)
      addAckRequested = true;


    //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);
    id1.setIndentifer(identifierStr);
    sequence.setIdentifier(id1);
    rmMsg.setMessagePart(Sandesha2Constants.MessageParts.SEQUENCE, sequence);


    if (addAckRequested) {
      ackRequested = new AckRequested(factory);
      Identifier id2 = new Identifier(factory);
      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();
    String key = SandeshaUtil
        .storeMessageContext(rmMsg.getMessageContext());
    appMsgEntry.setKey(key);
    appMsgEntry.setTimeToSend(System.currentTimeMillis());
    appMsgEntry.setMessageId(rmMsg.getMessageId());
    appMsgEntry.setMessageNumber(messageNumber);
    if (outSequenceBean == null || outSequenceBean.getValue() == null) {
      appMsgEntry.setSend(false);
    } else {
      appMsgEntry.setSend(true);


    }
    appMsgEntry.setInternalSequenceId(internalSequenceId);
    retransmitterMgr.insert(appMsgEntry);
  }

View Full Code Here

        
        // Get the sequence id for this sequence.
        String sequenceId = SandeshaClient.getSequenceID(serviceClient);
        
        // Get the SenderBeanManager
        SenderBeanMgr senderManager = storageManager.getSenderBeanMgr();
            
        // Check that there are no sender beans inside the SenderBeanMgr.
        SenderBean senderBean = new SenderBean();
        senderBean.setSequenceID(sequenceId);
        senderBean.setSend(true);
        senderBean.setReSend(false);
        
        // Find any sender beans for the to address.
        List beans = senderManager.find(senderBean);
        assertTrue("SenderBeans found when the list should be empty", beans.isEmpty());
        
        SequenceReport sequenceReport = SandeshaClient.getOutgoingSequenceReport(serviceClient);
        
        assertNotNull(sequenceReport.getSequenceID());

View Full Code Here


    msgContext.setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING, Sandesha2Constants.VALUE_FALSE);


    terminateBean.setReSend(false);


    SenderBeanMgr senderBeanMgr = storageManager.getSenderBeanMgr();


    senderBeanMgr.insert(terminateBean);


    SequencePropertyBean terminateAdded = new SequencePropertyBean();
    terminateAdded.setName(Sandesha2Constants.SequenceProperties.TERMINATE_ADDED);
    terminateAdded.setSequencePropertyKey(outSequenceID);
    terminateAdded.setValue("true");

View Full Code Here

        makeConnectionSenderBean.setSequenceID(sequenceId);
        EndpointReference to = makeConnectionRMMessage.getTo();
        if (to!=null)
          makeConnectionSenderBean.setToAddress(to.getAddress());


        SenderBeanMgr senderBeanMgr = storageManager.getSenderBeanMgr();
        
        //this message should not be sent until it is qualified. I.e. till it is sent through the Sandesha2TransportSender.
        makeConnectionRMMessage.setProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING, Sandesha2Constants.VALUE_FALSE);
        
        senderBeanMgr.insert(makeConnectionSenderBean);
        
        SandeshaUtil.executeAndStore(makeConnectionRMMessage, makeConnectionMsgStoreKey);
      } catch (SandeshaStorageException e) {
        e.printStackTrace();
      } catch (SandeshaException e) {

View Full Code Here

    
    Transaction transaction = null;
    
    try {
      StorageManager storageManager = SandeshaUtil.getSandeshaStorageManager(configurationContext, configurationContext.getAxisConfiguration());
      SenderBeanMgr senderBeanMgr = storageManager.getSenderBeanMgr();
      
      transaction = storageManager.getTransaction();


      SenderBean senderBean = senderBeanMgr.retrieve(messageId);
      if (senderBean==null) {
        //the work is not present. May be invalid now. So should return.
        if (log.isDebugEnabled())
          log.debug(SandeshaMessageHelper.getMessage(SandeshaMessageKeys.workNotPresent,workId));
        return;
      }
      String key = senderBean.getMessageContextRefKey();
      MessageContext msgCtx = storageManager.retrieveMessageContext(key, configurationContext);
      msgCtx.setProperty(Sandesha2Constants.WITHIN_TRANSACTION, Sandesha2Constants.VALUE_TRUE);


      RMMsgContext rmMsgCtx = MsgInitializer.initializeMessage(msgCtx);


      boolean continueSending = MessageRetransmissionAdjuster.adjustRetransmittion(rmMsgCtx, senderBean, configurationContext,
          storageManager);
      if (!continueSending) {
        return;
      }


      // sender will not send the message if following property is
      // set and not true.
      // But it will set if it is not set (null)


      // This is used to make sure that the mesage get passed the
      // Sandesha2TransportSender.


      String qualifiedForSending = (String) msgCtx.getProperty(Sandesha2Constants.QUALIFIED_FOR_SENDING);
      if (qualifiedForSending != null && !qualifiedForSending.equals(Sandesha2Constants.VALUE_TRUE)) {
        return;
      }


      if (msgCtx == null) {
        if (log.isDebugEnabled())
          log.debug(SandeshaMessageHelper.getMessage(SandeshaMessageKeys.sendHasUnavailableMsgEntry));
        return;      
      }


      // operation is the lowest level Sandesha2 should be attached
      ArrayList msgsNotToSend = SandeshaUtil.getPropertyBean(msgCtx.getAxisOperation()).getMsgTypesToDrop();


      if (msgsNotToSend != null && msgsNotToSend.contains(new Integer(rmMsgCtx.getMessageType()))) {
        return;  
      }


      updateMessage(msgCtx);


      int messageType = senderBean.getMessageType();
      
//      if (messageType == Sandesha2Constants.MessageTypes.APPLICATION) {
//        Sequence sequence = (Sequence) rmMsgCtx.getMessagePart(Sandesha2Constants.MessageParts.SEQUENCE);
//        String sequenceID = sequence.getIdentifier().getIdentifier();
//      }


//      if (AcknowledgementManager.ackRequired (rmMsgCtx)) {
//        RMMsgCreator.addAckMessage(rmMsgCtx);
      
      //} else 
        
      if (isAckPiggybackableMsgType(messageType)) { // checking weather this message can carry piggybacked acks
        // piggybacking if an ack if available for the same
        // sequence.
        // TODO do piggybacking based on wsa:To
          
        AcknowledgementManager.piggybackAcksIfPresent(rmMsgCtx, storageManager);
      }


      // sending the message
      
      //if a different TransportOutDesc hs already been set, it will be used instead
      //of the one from te MessageContext.
      
      if (transportOut!=null)
        msgCtx.setTransportOut(transportOut);
      


      boolean successfullySent = false;


      // have to commit the transaction before sending. This may
      // get changed when WS-AT is available.
      transaction.commit();
      msgCtx.setProperty(Sandesha2Constants.WITHIN_TRANSACTION,
          Sandesha2Constants.VALUE_FALSE);


      try {


        // had to fully build the SOAP envelope to support
        // retransmissions.
        // Otherwise a 'parserAlreadyAccessed' exception could
        // get thrown in retransmissions.
        // But this has a performance reduction.
        msgCtx.getEnvelope().build();


        ArrayList retransmittablePhases = (ArrayList) msgCtx.getProperty(Sandesha2Constants.RETRANSMITTABLE_PHASES);
        if (retransmittablePhases!=null) {
          msgCtx.setExecutionChain(retransmittablePhases);
        } else {
          ArrayList emptyExecutionChain = new ArrayList ();
          msgCtx.setExecutionChain(emptyExecutionChain);
        }
        
        msgCtx.setCurrentHandlerIndex(0);
        msgCtx.setCurrentPhaseIndex(0);
        msgCtx.setPaused(false);
      
        AxisEngine engine = new AxisEngine (msgCtx.getConfigurationContext());
        engine.resumeSend(msgCtx);
        
        successfullySent = true;
      } catch (Exception e) {
        String message = SandeshaMessageHelper.getMessage(
            SandeshaMessageKeys.sendMsgError, e.toString());
        
        if (log.isErrorEnabled())
          log.error(message, e);
      } finally {
        transaction = storageManager.getTransaction();
        msgCtx.setProperty(Sandesha2Constants.WITHIN_TRANSACTION,
            Sandesha2Constants.VALUE_TRUE);
      }


      // update or delete only if the object is still present.
      SenderBean bean1 = senderBeanMgr
          .retrieve(senderBean.getMessageID());
      if (bean1 != null) {
        if (senderBean.isReSend()) {
          bean1.setSentCount(senderBean.getSentCount());
          bean1.setTimeToSend(senderBean.getTimeToSend());
          senderBeanMgr.update(bean1);
        } else {
          senderBeanMgr.delete(bean1.getMessageID());


          // removing the message from the storage.
          String messageStoredKey = bean1.getMessageContextRefKey();
          storageManager.removeMessageContext(messageStoredKey);
        }

View Full Code Here

        }


        // TODO make sure this locks on reads.
        transaction = storageManager.getTransaction();


        SenderBeanMgr senderBeanMgr = storageManager.getSenderBeanMgr();
        SenderBean senderBean = senderBeanMgr.getNextMsgToSend();
        if (senderBean == null) {
          if (log.isDebugEnabled()) {
            String message = SandeshaMessageHelper
                .getMessage(SandeshaMessageKeys.senderBeanNotFound);
            log.debug(message);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

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

org.apache.axiom.om.OMElement

org.apache.axiom.soap.SOAPEnvelope

org.apache.axiom.soap.SOAPFactory

org.apache.axiom.soap.SOAPHeader

org.apache.axis2.addressing.EndpointReference

org.apache.axis2.AxisFault

org.apache.axis2.client.MessageSender

org.apache.axis2.client.Options

org.apache.axis2.context.AbstractContext

org.apache.axis2.context.ConfigurationContext

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.