Examples of org.hornetq.core.transaction.Transaction

A HornetQ internal transaction @author Tim Fox @author


         throw new HornetQXAException(XAException.XAER_PROTO, msg);
      }
      else
      {
         Transaction theTx = resourceManager.removeTransaction(xid);
         if (isTrace)
         {
            HornetQServerLogger.LOGGER.trace("xarollback into " + theTx);
         }


         if (theTx == null)
         {
            // checked heuristic committed transactions
            if (resourceManager.getHeuristicCommittedTransactions().contains(xid))
            {
               throw new HornetQXAException(XAException.XA_HEURCOM,
                                            "transaction has ben heuristically committed: " + xid);
            }
            // checked heuristic rolled back transactions
            else if (resourceManager.getHeuristicRolledbackTransactions().contains(xid))
            {
               throw new HornetQXAException(XAException.XA_HEURRB,
                                            "transaction has ben heuristically rolled back: " + xid);
            }
            else
            {
               if (isTrace)
               {
                  HornetQServerLogger.LOGGER.trace("xarollback into " + theTx + ", xid=" + xid + " forcing a rollback regular");
               }


               try
               {
                 // jbpapp-8845
                  // This could have happened because the TX timed out,
                  // at this point we would be better on rolling back this session as a way to prevent consumers from holding their messages
                  this.rollback(false);
               }
               catch (Exception e)
               {
                  HornetQServerLogger.LOGGER.warn(e.getMessage(), e);
               }


               throw new HornetQXAException(XAException.XAER_NOTA, "Cannot find xid in resource manager: " + xid);
            }
         }
         else
         {
            if (theTx.getState() == Transaction.State.SUSPENDED)
            {
               if (isTrace)
               {
                  HornetQServerLogger.LOGGER.trace("xarollback into " + theTx + " sending tx back as it was suspended");
               }

View Full Code Here


         throw new HornetQXAException(XAException.XAER_PROTO, msg);
      }
      else
      {
         Transaction theTx = resourceManager.getTransaction(xid);


         if (isTrace)
         {
            HornetQServerLogger.LOGGER.trace("xaprepare into " + ", xid=" + xid + ", tx= " + tx );
         }


         if (theTx == null)
         {
            final String msg = "Cannot find xid in resource manager: " + xid;


            throw new HornetQXAException(XAException.XAER_NOTA, msg);
         }
         else
         {
            if (theTx.getState() == Transaction.State.SUSPENDED)
            {
               throw new HornetQXAException(XAException.XAER_PROTO,
                                            "Cannot prepare transaction, it is suspended " + xid);
            }
            else if (theTx.getState() == Transaction.State.PREPARED)
            {
               HornetQServerLogger.LOGGER.info("ignoring prepare on xid as already called :" + xid);
            }
            else
            {
               theTx.prepare();
            }
         }
      }
   }

View Full Code Here

   private synchronized int iterQueue(final int flushLimit, final Filter filter1, QueueIterateAction messageAction) throws Exception
   {
      int count = 0;
      int txCount = 0;


      Transaction tx = new TransactionImpl(storageManager);


      LinkedListIterator<MessageReference> iter = iterator();
      try
      {


         while (iter.hasNext())
         {
            MessageReference ref = iter.next();


            if (ref.isPaged() && queueDestroyed)
            {
               // this means the queue is being removed
               // hence paged references are just going away through
               // page cleanup
               continue;
            }


            if (filter1 == null || filter1.match(ref.getMessage()))
            {
               messageAction.actMessage(tx, ref);
               iter.remove();
               txCount++;
               count++;
            }
         }


         if (txCount > 0)
         {
            tx.commit();


            tx = new TransactionImpl(storageManager);


            txCount = 0;
         }


         List<MessageReference> cancelled = scheduledDeliveryHandler.cancel(filter1);
         for (MessageReference messageReference : cancelled)
         {
            messageAction.actMessage(tx, messageReference);
            count++;
            txCount++;
         }


         if (txCount > 0)
         {
            tx.commit();
            tx = new TransactionImpl(storageManager);
            txCount = 0;
         }




         if (pageIterator != null && !queueDestroyed)
         {
            while (pageIterator.hasNext())
            {
               PagedReference reference = pageIterator.next();
               pageIterator.remove();


               if (filter1 == null || filter1.match(reference.getMessage()))
               {
                  count++;
                  txCount++;
                  messageAction.actMessage(tx, reference);
               }
               else
               {
                  addTail(reference, false);
               }


               if (txCount > 0 && txCount % flushLimit == 0)
               {
                  tx.commit();
                  tx = new TransactionImpl(storageManager);
                  txCount = 0;
               }
            }
         }


         if (txCount > 0)
         {
            tx.commit();
            tx = null;
         }

View Full Code Here


   public synchronized boolean deleteReference(final long messageID) throws Exception
   {
      boolean deleted = false;


      Transaction tx = new TransactionImpl(storageManager);


      LinkedListIterator<MessageReference> iter = iterator();
      try
      {


         while (iter.hasNext())
         {
            MessageReference ref = iter.next();
            if (ref.getMessage().getMessageID() == messageID)
            {
               incDelivering();
               acknowledge(tx, ref);
               iter.remove();
               refRemoved(ref);
               deleted = true;
               break;
            }
         }


         tx.commit();


         return deleted;
      }
      finally
      {

View Full Code Here

      else if(reference.getMessage().getSimpleStringProperty(Message.HDR_GROUP_ID) != null)
      {
         return HandleStatus.NO_MATCH;
      }


      final Transaction tx = new TransactionImpl(storageManager);


      final Pair<RoutingContext, ServerMessage> routingInfo = postOffice.redistribute(reference.getMessage(), queue, tx);


      if (routingInfo == null)
      {
         return HandleStatus.BUSY;
      }


      if (!reference.getMessage().isLargeMessage())
      {
         routingInfo.getB().finishCopy();


         postOffice.processRoute(routingInfo.getB(), routingInfo.getA(), false);


         ackRedistribution(reference, tx);
      }
      else
      {
         active = false;
         executor.execute(new Runnable()
         {
            public void run()
            {
               try
               {
                  routingInfo.getB().finishCopy();


                  postOffice.processRoute(routingInfo.getB(), routingInfo.getA(), false);


                  ackRedistribution(reference, tx);


                  synchronized (Redistributor.this)
                  {
                     active = true;


                     count++;


                     queue.deliverAsync();
                  }
               }
               catch (Exception e)
               {
                  try
                  {
                     tx.rollback();
                  }
                  catch (Exception e2)
                  {
                     // Nothing much we can do now

View Full Code Here


      JSONArray txDetailListJson = new JSONArray();
      for (Map.Entry<Xid, Long> entry : xidsSortedByCreationTime)
      {
         Xid xid = entry.getKey();
         Transaction tx = resourceManager.getTransaction(xid);
         if (tx == null)
         {
            continue;
         }
         TransactionDetail detail = new JMSTransactionDetail(xid, tx, entry.getValue());

View Full Code Here

      html.append("<h3>*** Prepared Transaction Details ***</h3>");


      for (Map.Entry<Xid, Long> entry : xidsSortedByCreationTime)
      {
         Xid xid = entry.getKey();
         Transaction tx = resourceManager.getTransaction(xid);
         if (tx == null)
         {
            continue;
         }
         TransactionDetail detail = new JMSTransactionDetail(xid, tx, entry.getValue());

View Full Code Here


   public void processRoute(final ServerMessage message, final RoutingContext context, final boolean direct) throws Exception
   {
      final List<MessageReference> refs = new ArrayList<MessageReference>();


      Transaction tx = context.getTransaction();


      for (Map.Entry<SimpleString, RouteContextList> entry : context.getContexListing().entrySet())
      {
         PagingStore store = pagingManager.getPageStore(entry.getKey());


         if (storageManager.addToPage(store, message, context.getTransaction(), entry.getValue()))
         {
            if (message.isLargeMessage())
            {
               confirmLargeMessageSend(tx, message);
            }


            // We need to kick delivery so the Queues may check for the cursors case they are empty
            schedulePageDelivery(tx, entry);
            continue;
         }


         for (Queue queue : entry.getValue().getNonDurableQueues())
         {
            MessageReference reference = message.createReference(queue);


            refs.add(reference);


            if (message.containsProperty(Message.HDR_SCHEDULED_DELIVERY_TIME))
            {
               Long scheduledDeliveryTime = message.getLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME);


               reference.setScheduledDeliveryTime(scheduledDeliveryTime);
            }


            message.incrementRefCount();
         }


         Iterator<Queue> iter = entry.getValue().getDurableQueues().iterator();


         while (iter.hasNext())
         {
            Queue queue = iter.next();


            MessageReference reference = message.createReference(queue);


            refs.add(reference);


            if (message.containsProperty(Message.HDR_SCHEDULED_DELIVERY_TIME))
            {
               Long scheduledDeliveryTime = message.getLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME);


               reference.setScheduledDeliveryTime(scheduledDeliveryTime);
            }


            if (message.isDurable())
            {
               int durableRefCount = message.incrementDurableRefCount();


               if (durableRefCount == 1)
               {
                  if (tx != null)
                  {
                     storageManager.storeMessageTransactional(tx.getID(), message);
                  }
                  else
                  {
                     storageManager.storeMessage(message);
                  }


                  if (message.isLargeMessage())
                  {
                     confirmLargeMessageSend(tx, message);
                  }
               }


               if (tx != null)
               {
                  storageManager.storeReferenceTransactional(tx.getID(), queue.getID(), message.getMessageID());


                  tx.setContainsPersistent();
               }
               else
               {
                  storageManager.storeReference(queue.getID(), message.getMessageID(), !iter.hasNext());
               }


               if (message.containsProperty(Message.HDR_SCHEDULED_DELIVERY_TIME))
               {
                  if (tx != null)
                  {
                     storageManager.updateScheduledDeliveryTimeTransactional(tx.getID(), reference);
                  }
                  else
                  {
                     storageManager.updateScheduledDeliveryTime(reference);
                  }
               }
            }


            message.incrementRefCount();
         }
      }


      if (tx != null)
      {
         tx.addOperation(new AddOperation(refs));
      }
      else
      {
         // This will use the same thread if there are no pending operations
         // avoiding a context switch on this case

View Full Code Here


      LinkedList<MessageReference> refs = cancelRefs(failed, false, null);


      Iterator<MessageReference> iter = refs.iterator();


      Transaction tx = new TransactionImpl(storageManager);


      while (iter.hasNext())
      {
         MessageReference ref = iter.next();


         ref.getQueue().cancel(tx, ref, true);
      }


      tx.rollback();


      if (!browseOnly)
      {
         TypedProperties props = new TypedProperties();

View Full Code Here


      JSONArray txDetailListJson = new JSONArray();
      for (Map.Entry<Xid, Long> entry : xidsSortedByCreationTime)
      {
         Xid xid = entry.getKey();
         Transaction tx = resourceManager.getTransaction(xid);
         if (tx == null)
         {
            continue;
         }
         TransactionDetail detail = new JMSTransactionDetail(xid, tx, entry.getValue());

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Examples of org.hornetq.core.transaction.Transaction

Related Classes of org.hornetq.core.transaction.Transaction