Package org.hornetq.jms.tests

Source Code of org.hornetq.jms.tests.XARecoveryTest

/*
* Copyright 2009 Red Hat, Inc.
* Red Hat licenses this file to you under the Apache License, version
* 2.0 (the "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*    http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied.  See the License for the specific language governing
* permissions and limitations under the License.
*/

package org.hornetq.jms.tests;

import javax.jms.Connection;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.XAConnection;
import javax.jms.XASession;
import javax.transaction.xa.XAResource;
import javax.transaction.xa.Xid;

import com.arjuna.ats.arjuna.common.Uid;
import com.arjuna.ats.jta.xa.XidImple;

import org.hornetq.core.transaction.impl.XidImpl;
import org.hornetq.jms.tests.util.ProxyAssertSupport;

/**
*
* A XARecoveryTest
*
* @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>
* @author <a href="mailto:juha@jboss.org">Juha Lindfors</a>
* @version <tt>$Revision: 8611 $</tt>
*
* $Id: XARecoveryTest.java 8611 2009-12-08 01:06:31Z timfox $
*
*/
public class XARecoveryTest extends JMSTestCase
{
   // Constants -----------------------------------------------------

   // Static --------------------------------------------------------

   // Attributes ----------------------------------------------------

   // Constructors --------------------------------------------------

   // TestCase overrides -------------------------------------------

   // Public --------------------------------------------------------

   /*
    * In this test, we have two queues, each with four messages already in them.
    *
    * We send 4 more messages to each queue, and ack the original 4 in a tx
    *
    * Then recover it without restarting the server
    *
    */
   public void testComplexTransactionalRecoveryWithoutRestart() throws Exception
   {
      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createConnection();

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue2);

         MessageProducer prod2 = sess1.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm1 = sess1.createTextMessage("tm1");
         TextMessage tm2 = sess1.createTextMessage("tm2");
         TextMessage tm3 = sess1.createTextMessage("tm3");
         TextMessage tm4 = sess1.createTextMessage("tm4");
         TextMessage tm5 = sess1.createTextMessage("tm5");
         TextMessage tm6 = sess1.createTextMessage("tm6");
         TextMessage tm7 = sess1.createTextMessage("tm7");
         TextMessage tm8 = sess1.createTextMessage("tm8");

         prod1.send(tm1);
         prod1.send(tm2);
         prod1.send(tm3);
         prod1.send(tm4);

         prod2.send(tm5);
         prod2.send(tm6);
         prod2.send(tm7);
         prod2.send(tm8);

         conn1.close();

         conn2 = JMSTestCase.cf.createXAConnection();

         conn2.start();

         XASession sess2 = conn2.createXASession();

         XAResource res = sess2.getXAResource();

         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod3 = sess2.createProducer(HornetQServerTestCase.queue2);

         TextMessage tm9 = sess2.createTextMessage("tm9");
         TextMessage tm10 = sess2.createTextMessage("tm10");
         TextMessage tm11 = sess2.createTextMessage("tm11");
         TextMessage tm12 = sess2.createTextMessage("tm12");

         prod3.send(tm9);
         prod3.send(tm10);
         prod3.send(tm11);
         prod3.send(tm12);

         MessageProducer prod4 = sess2.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm13 = sess2.createTextMessage("tm13");
         TextMessage tm14 = sess2.createTextMessage("tm14");
         TextMessage tm15 = sess2.createTextMessage("tm15");
         TextMessage tm16 = sess2.createTextMessage("tm16");

         prod4.send(tm13);
         prod4.send(tm14);
         prod4.send(tm15);
         prod4.send(tm16);

         MessageConsumer cons1 = sess2.createConsumer(HornetQServerTestCase.queue2);

         TextMessage rm1 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         TextMessage rm2 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         TextMessage rm3 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         TextMessage rm4 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         Message m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         MessageConsumer cons2 = sess2.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm5 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         TextMessage rm6 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         TextMessage rm7 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         TextMessage rm8 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         res.end(xid1, XAResource.TMSUCCESS);

         // prepare it

         log.trace("Preparing xid " + xid1);
         res.prepare(xid1);
         log.trace("Prepared xid " + xid1);

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         log.trace("Committing the tx");

         // Commit
         res3.commit(xids[0], false);

         log.trace("committed the tx");

         conn1.close();

         conn2.close();

         conn1 = JMSTestCase.cf.createConnection();

         conn1.start();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         log.trace("creating a consumer");

         cons1 = sess1.createConsumer(HornetQServerTestCase.queue2);

         log.trace("created a consumer");

         TextMessage rm9 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm9);
         ProxyAssertSupport.assertEquals(tm9.getText(), rm9.getText());

         TextMessage rm10 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm10);
         ProxyAssertSupport.assertEquals(tm10.getText(), rm10.getText());

         TextMessage rm11 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm11);
         ProxyAssertSupport.assertEquals(tm11.getText(), rm11.getText());

         TextMessage rm12 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm12);
         ProxyAssertSupport.assertEquals(tm12.getText(), rm12.getText());

         m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         cons2 = sess1.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm13 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm13);
         ProxyAssertSupport.assertEquals(tm13.getText(), rm13.getText());

         TextMessage rm14 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm14);
         ProxyAssertSupport.assertEquals(tm14.getText(), rm14.getText());

         TextMessage rm15 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm15);
         ProxyAssertSupport.assertEquals(tm15.getText(), rm15.getText());

         TextMessage rm16 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm16);
         ProxyAssertSupport.assertEquals(tm16.getText(), rm16.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

      }
      finally
      {
         if (conn1 != null)
         {
            conn1.close();
         }

         if (conn2 != null)
         {
            conn2.close();
         }

         if (conn3 != null)
         {
            conn3.close();
         }
      }
   }

   /*
    * In this test, we have two queues, each with four messages already in them.
    *
    * We send 4 more messages to each queue, and ack the original 4 in a tx
    *
    * Then recover it without restarting the server, then rollback
    *
    */
   public void testComplexTransactionalRecoveryWithoutRestartRollback() throws Exception
   {
      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createConnection();

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue2);

         MessageProducer prod2 = sess1.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm1 = sess1.createTextMessage("tm1");
         TextMessage tm2 = sess1.createTextMessage("tm2");
         TextMessage tm3 = sess1.createTextMessage("tm3");
         TextMessage tm4 = sess1.createTextMessage("tm4");
         TextMessage tm5 = sess1.createTextMessage("tm5");
         TextMessage tm6 = sess1.createTextMessage("tm6");
         TextMessage tm7 = sess1.createTextMessage("tm7");
         TextMessage tm8 = sess1.createTextMessage("tm8");

         prod1.send(tm1);
         prod1.send(tm2);
         prod1.send(tm3);
         prod1.send(tm4);

         prod2.send(tm5);
         prod2.send(tm6);
         prod2.send(tm7);
         prod2.send(tm8);

         conn2 = JMSTestCase.cf.createXAConnection();

         conn2.start();

         XASession sess2 = conn2.createXASession();

         XAResource res = sess2.getXAResource();

         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod3 = sess2.createProducer(HornetQServerTestCase.queue2);

         TextMessage tm9 = sess2.createTextMessage("tm9");
         TextMessage tm10 = sess2.createTextMessage("tm10");
         TextMessage tm11 = sess2.createTextMessage("tm11");
         TextMessage tm12 = sess2.createTextMessage("tm12");

         prod3.send(tm9);
         prod3.send(tm10);
         prod3.send(tm11);
         prod3.send(tm12);

         MessageProducer prod4 = sess2.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm13 = sess2.createTextMessage("tm13");
         TextMessage tm14 = sess2.createTextMessage("tm14");
         TextMessage tm15 = sess2.createTextMessage("tm15");
         TextMessage tm16 = sess2.createTextMessage("tm16");

         prod4.send(tm13);
         prod4.send(tm14);
         prod4.send(tm15);
         prod4.send(tm16);

         MessageConsumer cons1 = sess2.createConsumer(HornetQServerTestCase.queue2);

         TextMessage rm1 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         TextMessage rm2 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         TextMessage rm3 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         TextMessage rm4 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         Message m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         MessageConsumer cons2 = sess2.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm5 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         TextMessage rm6 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         TextMessage rm7 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         TextMessage rm8 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         res.end(xid1, XAResource.TMSUCCESS);

         // prepare it

         res.prepare(xid1);

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         log.trace("rolling back the tx");

         // rollback
         res3.rollback(xids[0]);

         log.trace("rolledb back the tx");

         conn1.close();

         conn2.close();

         conn1 = JMSTestCase.cf.createConnection();

         conn1.start();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         log.trace("creating a consumer");

         cons1 = sess1.createConsumer(HornetQServerTestCase.queue2);

         log.trace("created a consumer");

         TextMessage rm9 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm9);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm9.getText());

         TextMessage rm10 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm10);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm10.getText());

         TextMessage rm11 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm11);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm11.getText());

         TextMessage rm12 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm12);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm12.getText());

         m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         cons2 = sess1.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm13 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm13);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm13.getText());

         TextMessage rm14 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm14);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm14.getText());

         TextMessage rm15 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm15);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm15.getText());

         TextMessage rm16 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm16);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm16.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);
      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /*
    * In this test, we have two queues, each with four messages already in them.
    *
    * We send 4 more messages to each queue, and ack the original 4 in a tx
    *
    * Then recover it after restarting the server
    *
    */
   public void testComplexTransactionalRecoveryWithRestart() throws Exception
   {
      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createConnection();

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue2);

         MessageProducer prod2 = sess1.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm1 = sess1.createTextMessage("tm1");
         TextMessage tm2 = sess1.createTextMessage("tm2");
         TextMessage tm3 = sess1.createTextMessage("tm3");
         TextMessage tm4 = sess1.createTextMessage("tm4");
         TextMessage tm5 = sess1.createTextMessage("tm5");
         TextMessage tm6 = sess1.createTextMessage("tm6");
         TextMessage tm7 = sess1.createTextMessage("tm7");
         TextMessage tm8 = sess1.createTextMessage("tm8");

         prod1.send(tm1);
         prod1.send(tm2);
         prod1.send(tm3);
         prod1.send(tm4);

         prod2.send(tm5);
         prod2.send(tm6);
         prod2.send(tm7);
         prod2.send(tm8);

         conn2 = JMSTestCase.cf.createXAConnection();

         conn2.start();

         XASession sess2 = conn2.createXASession();

         XAResource res = sess2.getXAResource();

         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod3 = sess2.createProducer(HornetQServerTestCase.queue2);

         TextMessage tm9 = sess2.createTextMessage("tm9");
         TextMessage tm10 = sess2.createTextMessage("tm10");
         TextMessage tm11 = sess2.createTextMessage("tm11");
         TextMessage tm12 = sess2.createTextMessage("tm12");

         prod3.send(tm9);
         prod3.send(tm10);
         prod3.send(tm11);
         prod3.send(tm12);

         MessageProducer prod4 = sess2.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm13 = sess2.createTextMessage("tm13");
         TextMessage tm14 = sess2.createTextMessage("tm14");
         TextMessage tm15 = sess2.createTextMessage("tm15");
         TextMessage tm16 = sess2.createTextMessage("tm16");

         prod4.send(tm13);
         prod4.send(tm14);
         prod4.send(tm15);
         prod4.send(tm16);

         MessageConsumer cons1 = sess2.createConsumer(HornetQServerTestCase.queue2);

         TextMessage rm1 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         TextMessage rm2 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         TextMessage rm3 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         TextMessage rm4 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         Message m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         MessageConsumer cons2 = sess2.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm5 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         TextMessage rm6 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         TextMessage rm7 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         TextMessage rm8 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         res.end(xid1, XAResource.TMSUCCESS);

         // prepare it

         res.prepare(xid1);

         conn1.close();
         conn2.close();

         conn1 = null;

         conn2 = null;

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         log.trace("Committing the tx");

         // Commit
         res3.commit(xids[0], false);

         log.trace("committed the tx");

         conn1 = JMSTestCase.cf.createConnection();

         conn1.start();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         log.trace("creating a consumer");

         cons1 = sess1.createConsumer(HornetQServerTestCase.queue2);

         log.trace("created a consumer");

         TextMessage rm9 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm9);
         ProxyAssertSupport.assertEquals(tm9.getText(), rm9.getText());

         TextMessage rm10 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm10);
         ProxyAssertSupport.assertEquals(tm10.getText(), rm10.getText());

         TextMessage rm11 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm11);
         ProxyAssertSupport.assertEquals(tm11.getText(), rm11.getText());

         TextMessage rm12 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm12);
         ProxyAssertSupport.assertEquals(tm12.getText(), rm12.getText());

         m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         cons2 = sess1.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm13 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm13);
         ProxyAssertSupport.assertEquals(tm13.getText(), rm13.getText());

         TextMessage rm14 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm14);
         ProxyAssertSupport.assertEquals(tm14.getText(), rm14.getText());

         TextMessage rm15 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm15);
         ProxyAssertSupport.assertEquals(tm15.getText(), rm15.getText());

         TextMessage rm16 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm16);
         ProxyAssertSupport.assertEquals(tm16.getText(), rm16.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);
      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
         Thread.sleep(1000);
         removeAllMessages(HornetQServerTestCase.queue2.getQueueName(), true);
         removeAllMessages(HornetQServerTestCase.queue3.getQueueName(), true);
      }
   }

   /*
    * In this test, we have two queues, each with four messages already in them.
    *
    * We send 4 more messages to each queue, and ack the original 4 in a tx
    *
    * Then recover it after restarting the server, then rollback
    *
    */
   public void testComplexTransactionalRecoveryWithRestartRollback() throws Exception
   {
      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createConnection();

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue2);

         MessageProducer prod2 = sess1.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm1 = sess1.createTextMessage("tm1");
         TextMessage tm2 = sess1.createTextMessage("tm2");
         TextMessage tm3 = sess1.createTextMessage("tm3");
         TextMessage tm4 = sess1.createTextMessage("tm4");
         TextMessage tm5 = sess1.createTextMessage("tm5");
         TextMessage tm6 = sess1.createTextMessage("tm6");
         TextMessage tm7 = sess1.createTextMessage("tm7");
         TextMessage tm8 = sess1.createTextMessage("tm8");

         prod1.send(tm1);
         prod1.send(tm2);
         prod1.send(tm3);
         prod1.send(tm4);

         prod2.send(tm5);
         prod2.send(tm6);
         prod2.send(tm7);
         prod2.send(tm8);

         conn2 = JMSTestCase.cf.createXAConnection();

         conn2.start();

         XASession sess2 = conn2.createXASession();

         XAResource res = sess2.getXAResource();

         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod3 = sess2.createProducer(HornetQServerTestCase.queue2);

         TextMessage tm9 = sess2.createTextMessage("tm9");
         TextMessage tm10 = sess2.createTextMessage("tm10");
         TextMessage tm11 = sess2.createTextMessage("tm11");
         TextMessage tm12 = sess2.createTextMessage("tm12");

         prod3.send(tm9);
         prod3.send(tm10);
         prod3.send(tm11);
         prod3.send(tm12);

         MessageProducer prod4 = sess2.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm13 = sess2.createTextMessage("tm13");
         TextMessage tm14 = sess2.createTextMessage("tm14");
         TextMessage tm15 = sess2.createTextMessage("tm15");
         TextMessage tm16 = sess2.createTextMessage("tm16");

         prod4.send(tm13);
         prod4.send(tm14);
         prod4.send(tm15);
         prod4.send(tm16);

         MessageConsumer cons1 = sess2.createConsumer(HornetQServerTestCase.queue2);

         TextMessage rm1 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         TextMessage rm2 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         TextMessage rm3 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         TextMessage rm4 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         Message m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         MessageConsumer cons2 = sess2.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm5 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         TextMessage rm6 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         TextMessage rm7 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         TextMessage rm8 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         res.end(xid1, XAResource.TMSUCCESS);

         // prepare it

         res.prepare(xid1);

         conn1.close();
         conn2.close();
         conn1 = null;

         conn2 = null;

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         log.trace("rolling back the tx");

         // rollback
         res3.rollback(xids[0]);

         log.trace("rolled back the tx");

         Thread.sleep(1000);

         conn1 = JMSTestCase.cf.createConnection();

         conn1.start();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         log.trace("creating a consumer");

         cons1 = sess1.createConsumer(HornetQServerTestCase.queue2);

         log.trace("created a consumer");

         TextMessage rm9 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm9);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm9.getText());

         TextMessage rm10 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm10);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm10.getText());

         TextMessage rm11 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm11);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm11.getText());

         TextMessage rm12 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm12);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm12.getText());

         m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         cons2 = sess1.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm13 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm13);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm13.getText());

         TextMessage rm14 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm14);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm14.getText());

         TextMessage rm15 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm15);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm15.getText());

         TextMessage rm16 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm16);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm16.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         cons1.close();
      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /* Not really necessary - but it does no harm */
   public void testComplexTransactional() throws Exception
   {
      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createConnection();

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue2);

         MessageProducer prod2 = sess1.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm1 = sess1.createTextMessage("tm1");
         TextMessage tm2 = sess1.createTextMessage("tm2");
         TextMessage tm3 = sess1.createTextMessage("tm3");
         TextMessage tm4 = sess1.createTextMessage("tm4");
         TextMessage tm5 = sess1.createTextMessage("tm5");
         TextMessage tm6 = sess1.createTextMessage("tm6");
         TextMessage tm7 = sess1.createTextMessage("tm7");
         TextMessage tm8 = sess1.createTextMessage("tm8");

         prod1.send(tm1);
         prod1.send(tm2);
         prod1.send(tm3);
         prod1.send(tm4);

         prod2.send(tm5);
         prod2.send(tm6);
         prod2.send(tm7);
         prod2.send(tm8);

         conn2 = JMSTestCase.cf.createXAConnection();

         conn2.start();

         XASession sess2 = conn2.createXASession();

         XAResource res = sess2.getXAResource();

         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod3 = sess2.createProducer(HornetQServerTestCase.queue2);

         TextMessage tm9 = sess2.createTextMessage("tm9");
         TextMessage tm10 = sess2.createTextMessage("tm10");
         TextMessage tm11 = sess2.createTextMessage("tm11");
         TextMessage tm12 = sess2.createTextMessage("tm12");

         prod3.send(tm9);
         prod3.send(tm10);
         prod3.send(tm11);
         prod3.send(tm12);

         MessageProducer prod4 = sess2.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm13 = sess2.createTextMessage("tm13");
         TextMessage tm14 = sess2.createTextMessage("tm14");
         TextMessage tm15 = sess2.createTextMessage("tm15");
         TextMessage tm16 = sess2.createTextMessage("tm16");

         prod4.send(tm13);
         prod4.send(tm14);
         prod4.send(tm15);
         prod4.send(tm16);

         MessageConsumer cons1 = sess2.createConsumer(HornetQServerTestCase.queue2);

         TextMessage rm1 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         TextMessage rm2 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         TextMessage rm3 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         TextMessage rm4 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         Message m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         MessageConsumer cons2 = sess2.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm5 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         TextMessage rm6 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         TextMessage rm7 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         TextMessage rm8 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         res.end(xid1, XAResource.TMSUCCESS);

         // prepare it

         res.prepare(xid1);

         res.commit(xid1, false);

         conn1.close();

         conn2.close();

         conn1 = JMSTestCase.cf.createConnection();

         conn1.start();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         cons1 = sess1.createConsumer(HornetQServerTestCase.queue2);

         TextMessage rm9 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm9);
         ProxyAssertSupport.assertEquals(tm9.getText(), rm9.getText());

         TextMessage rm10 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm10);
         ProxyAssertSupport.assertEquals(tm10.getText(), rm10.getText());

         TextMessage rm11 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm11);
         ProxyAssertSupport.assertEquals(tm11.getText(), rm11.getText());

         TextMessage rm12 = (TextMessage)cons1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm12);
         ProxyAssertSupport.assertEquals(tm12.getText(), rm12.getText());

         m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         cons2 = sess1.createConsumer(HornetQServerTestCase.queue3);

         TextMessage rm13 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm13);
         ProxyAssertSupport.assertEquals(tm13.getText(), rm13.getText());

         TextMessage rm14 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm14);
         ProxyAssertSupport.assertEquals(tm14.getText(), rm14.getText());

         TextMessage rm15 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm15);
         ProxyAssertSupport.assertEquals(tm15.getText(), rm15.getText());

         TextMessage rm16 = (TextMessage)cons2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm16);
         ProxyAssertSupport.assertEquals(tm16.getText(), rm16.getText());

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);
      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /* A simple send in a transaction - recovered without restarting the server */
   public void testSimpleTransactionalSendRecoveryWithoutRestart() throws Exception
   {
      log.trace("starting testSimpleTransactionalDeliveryRecoveryWithoutRestart");

      XAConnection conn1 = null;

      Connection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createXAConnection();

         XASession sess1 = conn1.createXASession();

         XAResource res1 = sess1.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         log.trace("Sending message");

         // Send message in tx

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue4);

         TextMessage tm1 = sess1.createTextMessage("tm1");

         prod1.send(tm1);

         res1.end(xid1, XAResource.TMSUCCESS);

         log.trace("Sent message");

         // prepare tx

         res1.prepare(xid1);

         log.trace("prepared tx");

         conn2 = JMSTestCase.cf.createConnection();

         Session sess2 = conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageConsumer cons2 = sess2.createConsumer(HornetQServerTestCase.queue4);

         conn2.start();

         // Verify message can't be received

         Message m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         // Now recover

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         // Verify message still can't be received

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         // Commit the tx

         res1.commit(xids[0], false);

         // The message should now be available

         TextMessage rm1 = (TextMessage)cons2.receive(1000);

         ProxyAssertSupport.assertNotNull(rm1);

         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /* A simple send in a transaction - recovered after restarting the server */
   public void testSimpleTransactionalSendRecoveryWithRestart() throws Exception
   {
      log.trace("starting testSimpleTransactionalDeliveryRecoveryWithRestart");

      XAConnection conn1 = null;

      Connection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createXAConnection();

         XASession sess1 = conn1.createXASession();

         XAResource res1 = sess1.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         log.trace("Sending message");

         // Send message in tx

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue4);

         TextMessage tm1 = sess1.createTextMessage("tm1");

         prod1.send(tm1);

         res1.end(xid1, XAResource.TMSUCCESS);

         log.trace("Sent message");

         // prepare tx

         res1.prepare(xid1);

         log.trace("prepared tx");

         conn2 = JMSTestCase.cf.createConnection();

         Session sess2 = conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageConsumer cons2 = sess2.createConsumer(HornetQServerTestCase.queue4);

         conn2.start();

         // Verify message can't be received

         Message m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         conn1.close();

         conn2.close();

         conn1 = null;

         conn2 = null;

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         log.trace("created connection");

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         log.trace("recovered");

         conn2 = JMSTestCase.cf.createConnection();

         sess2 = conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);

         cons2 = sess2.createConsumer(HornetQServerTestCase.queue4);

         conn2.start();

         // Verify message still can't be received

         m = cons2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         log.trace("still can't see message");

         // Commit the tx

         res3.commit(xids[0], false);

         log.trace("committed");

         // The message should now be available

         TextMessage rm1 = (TextMessage)cons2.receive(1000);

         ProxyAssertSupport.assertNotNull(rm1);

         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /* A simple acknowledgement in a transaction, recovered without restart */
   public void testSimpleTransactionalAcknowledgementRecoveryWithoutRestart() throws Exception
   {
      log.trace("starting testSimpleTransactionalAcknowledgementRecovery");

      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         // First send a message to the queue
         conn1 = JMSTestCase.cf.createConnection();

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod = sess1.createProducer(HornetQServerTestCase.queue4);

         TextMessage tm1 = sess1.createTextMessage("tm1");

         prod.send(tm1);

         conn2 = JMSTestCase.cf.createXAConnection();

         XASession sess2 = conn2.createXASession();

         XAResource res1 = sess2.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageConsumer cons = sess2.createConsumer(HornetQServerTestCase.queue4);

         conn2.start();

         // Consume the message

         TextMessage rm1 = (TextMessage)cons.receive(1000);

         ProxyAssertSupport.assertNotNull(rm1);

         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         res1.end(xid1, XAResource.TMSUCCESS);

         // prepare the tx

         res1.prepare(xid1);

         // Now recover

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         // Commit the tx

         res1.commit(xids[0], false);

         // The message should be acknowldged

         conn1.close();

         conn2.close();

         conn3.close();

         conn1 = JMSTestCase.cf.createConnection();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageConsumer cons1 = sess1.createConsumer(HornetQServerTestCase.queue4);

         conn1.start();

         Message m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /* A simple acknowledgement in a transaction, recovered with restart */
   public void testSimpleTransactionalAcknowledgementRecoveryWithRestart() throws Exception
   {
      log.trace("starting testSimpleTransactionalAcknowledgementRecoveryWithRestart");

      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         // First send a message to the queue
         conn1 = JMSTestCase.cf.createConnection();

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod = sess1.createProducer(HornetQServerTestCase.queue4);

         TextMessage tm1 = sess1.createTextMessage("tm1");

         prod.send(tm1);

         conn2 = JMSTestCase.cf.createXAConnection();

         XASession sess2 = conn2.createXASession();

         XAResource res1 = sess2.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageConsumer cons = sess2.createConsumer(HornetQServerTestCase.queue4);

         conn2.start();

         // Consume the message

         TextMessage rm1 = (TextMessage)cons.receive(1000);

         ProxyAssertSupport.assertNotNull(rm1);

         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         res1.end(xid1, XAResource.TMSUCCESS);

         // prepare the tx

         res1.prepare(xid1);

         conn1.close();

         conn2.close();

         conn1 = null;

         conn2 = null;

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         // Now recover

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         // Commit the tx

         res3.commit(xids[0], false);

         // The message should be acknowldged

         conn3.close();

         conn1 = JMSTestCase.cf.createConnection();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageConsumer cons1 = sess1.createConsumer(HornetQServerTestCase.queue4);

         conn1.start();

         Message m = cons1.receive(1000);

         ProxyAssertSupport.assertNull(m);

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /*
    * In this test, we have 4 messages in a 2 durable subs on the same topic.
    *
    * We ack them, then add four more messages
    *
    * This test tests for the recovery when the same message is in multiple channels
    *
    * We don't restart in this test
    *
    */
   public void testRecoveryWithTwoDurableSubsWithoutRestart() throws Exception
   {
      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createConnection();

         conn1.setClientID("wib1");

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.topic2);

         MessageConsumer sub1 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub1");

         MessageConsumer sub2 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub2");

         // send four messages

         TextMessage tm1 = sess1.createTextMessage("tm1");
         TextMessage tm2 = sess1.createTextMessage("tm2");
         TextMessage tm3 = sess1.createTextMessage("tm3");
         TextMessage tm4 = sess1.createTextMessage("tm4");

         prod1.send(tm1);
         prod1.send(tm2);
         prod1.send(tm3);
         prod1.send(tm4);

         conn1.close();

         // The messages should now be in both durable subs

         conn2 = JMSTestCase.cf.createXAConnection();

         conn2.setClientID("wib1");

         conn2.start();

         XASession sess2 = conn2.createXASession();

         XAResource res = sess2.getXAResource();

         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res.start(xid1, XAResource.TMNOFLAGS);

         // Now send four more messages in a global tx

         MessageProducer prod2 = sess2.createProducer(HornetQServerTestCase.topic2);

         TextMessage tm5 = sess2.createTextMessage("tm5");
         TextMessage tm6 = sess2.createTextMessage("tm6");
         TextMessage tm7 = sess2.createTextMessage("tm7");
         TextMessage tm8 = sess2.createTextMessage("tm8");

         prod2.send(tm5);
         prod2.send(tm6);
         prod2.send(tm7);
         prod2.send(tm8);

         // And consume the first four from each in the tx

         sub1 = sess2.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub1");

         sub2 = sess2.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub2");

         TextMessage rm1 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         TextMessage rm2 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         TextMessage rm3 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         TextMessage rm4 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         Message m = sub1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         rm1 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         rm2 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         rm3 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         rm4 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         m = sub2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         res.end(xid1, XAResource.TMSUCCESS);

         // prepare it

         res.prepare(xid1);

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         // recover

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         log.trace("Committing the tx");

         // Commit
         res3.commit(xids[0], false);

         log.trace("committed the tx");

         conn2.close();

         conn1 = JMSTestCase.cf.createConnection();

         conn1.setClientID("wib1");

         conn1.start();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         // Should now see the last 4 messages

         sub1 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub1");

         sub2 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub2");

         TextMessage rm5 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         TextMessage rm6 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         TextMessage rm7 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         TextMessage rm8 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = sub1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         rm5 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         rm6 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         rm7 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         rm8 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = sub2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         sub1.close();

         sub2.close();

         sess1.unsubscribe("sub1");

         sess1.unsubscribe("sub2");

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /*
    * In this test, we have 4 messages in a 2 durable subs on the same topic.
    *
    * We ack them, then add four more messages
    *
    * This test tests for the recovery when the same message is in multiple channels
    *
    * We do restart in this test
    *
    */
   public void testRecoveryWithTwoDurableSubsWithRestart() throws Exception
   {
      Connection conn1 = null;

      XAConnection conn2 = null;

      XAConnection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createConnection();

         conn1.setClientID("wib1");

         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.topic2);

         MessageConsumer sub1 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub1");

         MessageConsumer sub2 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub2");

         // send four messages

         TextMessage tm1 = sess1.createTextMessage("tm1");
         TextMessage tm2 = sess1.createTextMessage("tm2");
         TextMessage tm3 = sess1.createTextMessage("tm3");
         TextMessage tm4 = sess1.createTextMessage("tm4");

         prod1.send(tm1);
         prod1.send(tm2);
         prod1.send(tm3);
         prod1.send(tm4);

         conn1.close();

         // The messages should now be in both durable subs

         conn2 = JMSTestCase.cf.createXAConnection();

         conn2.setClientID("wib1");

         conn2.start();

         XASession sess2 = conn2.createXASession();

         XAResource res = sess2.getXAResource();

         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());

         res.start(xid1, XAResource.TMNOFLAGS);

         // Now send four more messages in a global tx

         MessageProducer prod2 = sess2.createProducer(HornetQServerTestCase.topic2);

         TextMessage tm5 = sess2.createTextMessage("tm5");
         TextMessage tm6 = sess2.createTextMessage("tm6");
         TextMessage tm7 = sess2.createTextMessage("tm7");
         TextMessage tm8 = sess2.createTextMessage("tm8");

         prod2.send(tm5);
         prod2.send(tm6);
         prod2.send(tm7);
         prod2.send(tm8);

         // And consume the first four from each in the tx

         sub1 = sess2.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub1");

         sub2 = sess2.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub2");

         TextMessage rm1 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         TextMessage rm2 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         TextMessage rm3 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         TextMessage rm4 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         Message m = sub1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         rm1 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm1);
         ProxyAssertSupport.assertEquals(tm1.getText(), rm1.getText());

         rm2 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm2);
         ProxyAssertSupport.assertEquals(tm2.getText(), rm2.getText());

         rm3 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm3);
         ProxyAssertSupport.assertEquals(tm3.getText(), rm3.getText());

         rm4 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm4);
         ProxyAssertSupport.assertEquals(tm4.getText(), rm4.getText());

         m = sub2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         res.end(xid1, XAResource.TMSUCCESS);

         // prepare it

         res.prepare(xid1);

         conn1.close();
         conn2.close();
         conn1 = null;

         conn2 = null;

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn3 = JMSTestCase.cf.createXAConnection();

         XASession sess3 = conn3.createXASession();

         XAResource res3 = sess3.getXAResource();

         // recover

         Xid[] xids = res3.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(1, xids.length);

         Xid[] xids2 = res3.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertEquals(xid1, xids[0]);

         log.trace("Committing the tx");

         // Commit
         res3.commit(xids[0], false);

         log.trace("committed the tx");

         conn1 = JMSTestCase.cf.createConnection();

         conn1.setClientID("wib1");

         conn1.start();

         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);

         // Should now see the last 4 messages

         sub1 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub1");

         sub2 = sess1.createDurableSubscriber((Topic)HornetQServerTestCase.topic2, "sub2");

         TextMessage rm5 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         TextMessage rm6 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         TextMessage rm7 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         TextMessage rm8 = (TextMessage)sub1.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = sub1.receive(1000);

         ProxyAssertSupport.assertNull(m);

         rm5 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm5);
         ProxyAssertSupport.assertEquals(tm5.getText(), rm5.getText());

         rm6 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm6);
         ProxyAssertSupport.assertEquals(tm6.getText(), rm6.getText());

         rm7 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm7);
         ProxyAssertSupport.assertEquals(tm7.getText(), rm7.getText());

         rm8 = (TextMessage)sub2.receive(1000);
         ProxyAssertSupport.assertNotNull(rm8);
         ProxyAssertSupport.assertEquals(tm8.getText(), rm8.getText());

         m = sub2.receive(1000);

         ProxyAssertSupport.assertNull(m);

         sub1.close();

         sub2.close();

         sess1.unsubscribe("sub1");

         sess1.unsubscribe("sub2");

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /*
    * Send two messages in two transactions.
    * Prepare tx
    * Crash the server
    * Restart the server
    * Make sure the messages can be received
    * NOTE this test only tests transactional sends, not transactional acknowledgments
    *
    */
   public void testTransactionalDeliveryRecovery() throws Exception
   {
      log.trace("starting testTransactionalDeliveryRecovery");

      XAConnection conn1 = null;

      XAConnection conn2 = null;

      Connection conn3 = null;

      try
      {
         conn1 = JMSTestCase.cf.createXAConnection();

         conn2 = JMSTestCase.cf.createXAConnection();

         XASession sess1 = conn1.createXASession();

         XASession sess2 = conn2.createXASession();

         XAResource res1 = sess1.getXAResource();

         XAResource res2 = sess2.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "eemeli".getBytes());
         Xid xid2 = new XidImpl("bq2".getBytes(), 42, "frigtard".getBytes());

         log.trace("Sending messages");

         // Send two messages in transaction 1

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue4);

         TextMessage tm1 = sess1.createTextMessage("tm1");

         prod1.send(tm1);

         TextMessage tm2 = sess1.createTextMessage("tm2");

         prod1.send(tm2);

         res1.end(xid1, XAResource.TMSUCCESS);

         // Send two messages in transaction 2

         res2.start(xid2, XAResource.TMNOFLAGS);

         MessageProducer prod2 = sess2.createProducer(HornetQServerTestCase.queue4);

         TextMessage tm3 = sess2.createTextMessage("tm3");

         prod2.send(tm3);

         TextMessage tm4 = sess2.createTextMessage("tm4");

         prod2.send(tm4);

         res2.end(xid2, XAResource.TMSUCCESS);

         log.trace("Sent messages");

         // prepare both txs

         res1.prepare(xid1);
         res2.prepare(xid2);

         log.trace("prepared messages");

         // Now "crash" the server

         conn1.close();

         conn2.close();

         conn1 = null;

         conn2 = null;

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn1 = JMSTestCase.cf.createXAConnection();

         XAResource res = conn1.createXASession().getXAResource();

         log.trace("Recovering");

         Xid[] xids = res.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(2, xids.length);

         Xid[] xids2 = res.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         // They may be in a different order
         ProxyAssertSupport.assertTrue(xids[0].equals(xid1) || xids[1].equals(xid1));
         ProxyAssertSupport.assertTrue(xids[0].equals(xid2) || xids[1].equals(xid2));

         // Make sure can't receive the messages

         log.trace("Creating conn");

         conn3 = JMSTestCase.cf.createConnection();

         Session sessRec = conn3.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageConsumer cons = sessRec.createConsumer(HornetQServerTestCase.queue4);
         conn3.start();

         log.trace("Created conn3");

         TextMessage m1 = (TextMessage)cons.receive(1000);
         ProxyAssertSupport.assertNull(m1);

         log.trace("comitting");

         // Commit tx1

         res.commit(xid1, false);

         log.trace("comitted");

         // Should now be able to receive tm1 and tm2

         m1 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m1);

         ProxyAssertSupport.assertEquals(tm1.getText(), m1.getText());

         TextMessage m2 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m2);

         ProxyAssertSupport.assertEquals(tm2.getText(), m2.getText());

         TextMessage m3 = (TextMessage)cons.receive(1000);
         ProxyAssertSupport.assertNull(m3);

         // Now commit tx2

         res.commit(xid2, false);

         // Should now be able to receive tm3 and tm4

         m3 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m3);

         ProxyAssertSupport.assertEquals(tm3.getText(), m3.getText());

         TextMessage m4 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m4);

         ProxyAssertSupport.assertEquals(tm4.getText(), m4.getText());

         TextMessage m5 = (TextMessage)cons.receive(1000);
         ProxyAssertSupport.assertNull(m5);
      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   /*
    * This test sends some messages in a couple of txs, crashes then recovers
    * NOTE it does not test transactional acknowledgements
    */
   public void testMockCoordinatorRecovery() throws Exception
   {
      XAConnection conn1 = null;

      XAConnection conn2 = null;

      Connection conn3 = null;

      try
      {

         conn1 = JMSTestCase.cf.createXAConnection();

         conn2 = JMSTestCase.cf.createXAConnection();

         XASession sess1 = conn1.createXASession();

         XASession sess2 = conn2.createXASession();

         XAResource res1 = sess1.getXAResource();

         XAResource res2 = sess2.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 42, "aapeli".getBytes());
         Xid xid2 = new XidImpl("bq2".getBytes(), 42, "belsebub".getBytes());

         // Send a message in each tx

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue2);

         TextMessage tm1 = sess1.createTextMessage("alpha");

         prod1.send(tm1);

         res1.end(xid1, XAResource.TMSUCCESS);

         res2.start(xid2, XAResource.TMNOFLAGS);

         MessageProducer prod2 = sess2.createProducer(HornetQServerTestCase.queue2);

         TextMessage tm2 = sess2.createTextMessage("beta");

         prod2.send(tm2);

         res2.end(xid2, XAResource.TMSUCCESS);

         // prepare both txs

         res1.prepare(xid1);
         res2.prepare(xid2);

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn1.close();

         conn2.close();

         conn1 = JMSTestCase.cf.createXAConnection();

         XAResource res = conn1.createXASession().getXAResource();

         Xid[] xids = res.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(2, xids.length);

         Xid[] xids2 = res.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertTrue(xids[0].equals(xid1) || xids[1].equals(xid1));
         ProxyAssertSupport.assertTrue(xids[0].equals(xid2) || xids[1].equals(xid2));

         res.commit(xid1, false);

         res.commit(xid2, false);

         conn3 = JMSTestCase.cf.createConnection();

         Session sessRec = conn3.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageConsumer cons = sessRec.createConsumer(HornetQServerTestCase.queue2);
         conn3.start();

         Message msg = cons.receive(HornetQServerTestCase.MAX_TIMEOUT);

         TextMessage m1 = (TextMessage)msg;
         ProxyAssertSupport.assertNotNull(m1);

         ProxyAssertSupport.assertTrue("alpha".equals(m1.getText()) || "beta".equals(m1.getText()));

         TextMessage m2 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m2);

         ProxyAssertSupport.assertTrue("alpha".equals(m2.getText()) || "beta".equals(m2.getText()));

         ProxyAssertSupport.assertTrue(!tm1.getText().equals(tm2.getText()));

         Message nullMessage = cons.receive(HornetQServerTestCase.MIN_TIMEOUT);
         ProxyAssertSupport.assertTrue(nullMessage == null);

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }

   }

   /*
    * This test sends some messages in a couple of txs, crashes then recovers
    * It uses the JBoss TS XId implementation - so we can show compatibility
    * NOTE it does not test transactional acknowledgements
    */
   public void testMockCoordinatorRecoveryWithJBossTSXids() throws Exception
   {
      XAConnection conn1 = null;

      XAConnection conn2 = null;

      Connection conn3 = null;

      try
      {

         conn1 = JMSTestCase.cf.createXAConnection();

         conn2 = JMSTestCase.cf.createXAConnection();

         XASession sess1 = conn1.createXASession();

         XASession sess2 = conn2.createXASession();

         XAResource res1 = sess1.getXAResource();

         XAResource res2 = sess2.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImple(new Uid("cadaver"), new Uid("bq1"), 666);
         Xid xid2 = new XidImple(new Uid("dalidom"), new Uid("bq2"), 661); // TODO

         // Send a message in each tx

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue1);

         TextMessage tm1 = sess1.createTextMessage("testing1");

         prod1.send(tm1);

         res1.end(xid1, XAResource.TMSUCCESS);

         res2.start(xid2, XAResource.TMNOFLAGS);

         MessageProducer prod2 = sess2.createProducer(HornetQServerTestCase.queue1);

         TextMessage tm2 = sess2.createTextMessage("testing2");

         prod2.send(tm2);

         res2.end(xid2, XAResource.TMSUCCESS);

         // prepare both txs

         res1.prepare(xid1);
         res2.prepare(xid2);

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn1.close();

         conn2.close();

         conn1 = JMSTestCase.cf.createXAConnection();

         XAResource res = conn1.createXASession().getXAResource();

         Xid[] xids = res.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(2, xids.length);

         Xid[] xids2 = res.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertTrue(xids[0].equals(xid1) || xids[1].equals(xid1));
         ProxyAssertSupport.assertTrue(xids[0].equals(xid2) || xids[1].equals(xid2));

         res.commit(xid1, false);

         res.commit(xid2, false);

         conn3 = JMSTestCase.cf.createConnection();

         Session sessRec = conn3.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageConsumer cons = sessRec.createConsumer(HornetQServerTestCase.queue1);
         conn3.start();

         TextMessage m1 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m1);
         ProxyAssertSupport.assertEquals("testing1", m1.getText());

         TextMessage m2 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m2);

         ProxyAssertSupport.assertEquals("testing2", m2.getText());

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   public void testMockCoordinatorRecovery3() throws Exception
   {
      XAConnection conn1 = null;

      XAConnection conn2 = null;

      Connection conn3 = null;

      try
      {

         conn1 = JMSTestCase.cf.createXAConnection();

         conn2 = JMSTestCase.cf.createXAConnection();

         XASession sess1 = conn1.createXASession();

         XASession sess2 = conn2.createXASession();

         XAResource res1 = sess1.getXAResource();

         XAResource res2 = sess2.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 123, "gbtxid1".getBytes());
         Xid xid2 = new XidImpl("bq2".getBytes(), 124, "gbtxid2".getBytes());

         // Send a message in each tx

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue1);

         TextMessage tm1 = sess1.createTextMessage("testing1");

         prod1.send(tm1);

         res1.end(xid1, XAResource.TMSUCCESS);

         res2.start(xid2, XAResource.TMNOFLAGS);

         MessageProducer prod2 = sess2.createProducer(HornetQServerTestCase.queue1);

         TextMessage tm2 = sess2.createTextMessage("testing2");

         prod2.send(tm2);

         res2.end(xid2, XAResource.TMSUCCESS);

         // prepare both txs

         res1.prepare(xid1);
         res2.prepare(xid2);

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn1.close();

         conn2.close();

         conn1 = JMSTestCase.cf.createXAConnection();

         XAResource res = conn1.createXASession().getXAResource();

         Xid[] xids = res.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(2, xids.length);

         Xid[] xids2 = res.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertTrue(xids[0].equals(xid1) || xids[1].equals(xid1));
         ProxyAssertSupport.assertTrue(xids[0].equals(xid2) || xids[1].equals(xid2));

         res.commit(xids[0], false);

         res.commit(xids[1], false);

         conn3 = JMSTestCase.cf.createConnection();

         Session sessRec = conn3.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageConsumer cons = sessRec.createConsumer(HornetQServerTestCase.queue1);
         conn3.start();

         TextMessage m1 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m1);
         ProxyAssertSupport.assertEquals("testing1", m1.getText());

         TextMessage m2 = (TextMessage)cons.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m2);

         ProxyAssertSupport.assertEquals("testing2", m2.getText());
      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }

   public void testMultiChannelRecovery() throws Exception
   {
      XAConnection conn1 = null;

      XAConnection conn2 = null;

      Connection conn3 = null;

      try
      {

         conn1 = JMSTestCase.cf.createXAConnection();

         conn2 = JMSTestCase.cf.createXAConnection();

         XASession sess1 = conn1.createXASession();

         XASession sess2 = conn2.createXASession();

         XAResource res1 = sess1.getXAResource();

         XAResource res2 = sess2.getXAResource();

         // Pretend to be a transaction manager by interacting through the XAResources
         Xid xid1 = new XidImpl("bq1".getBytes(), 123, "gbtxid1".getBytes());
         Xid xid2 = new XidImpl("bq2".getBytes(), 124, "gbtxid2".getBytes());

         // Send a message in each tx

         res1.start(xid1, XAResource.TMNOFLAGS);

         MessageProducer prod1 = sess1.createProducer(HornetQServerTestCase.queue2);
         MessageProducer prod2 = sess1.createProducer(HornetQServerTestCase.queue3);

         TextMessage tm1 = sess1.createTextMessage("testing1");
         TextMessage tm2 = sess1.createTextMessage("testing2");

         prod1.send(tm1);
         prod2.send(tm2);

         res1.end(xid1, XAResource.TMSUCCESS);

         res2.start(xid2, XAResource.TMNOFLAGS);

         MessageProducer prod3 = sess2.createProducer(HornetQServerTestCase.queue1);

         TextMessage tm3 = sess2.createTextMessage("testing3");

         prod3.send(tm3);

         res2.end(xid2, XAResource.TMSUCCESS);

         // prepare both txs

         res1.prepare(xid1);
         res2.prepare(xid2);

         // Now "crash" the server

         stopServerPeer();

         startServerPeer();

         deployAndLookupAdministeredObjects();

         conn1.close();

         conn2.close();

         conn1 = JMSTestCase.cf.createXAConnection();

         XAResource res = conn1.createXASession().getXAResource();

         Xid[] xids = res.recover(XAResource.TMSTARTRSCAN);
         ProxyAssertSupport.assertEquals(2, xids.length);

         Xid[] xids2 = res.recover(XAResource.TMENDRSCAN);
         ProxyAssertSupport.assertEquals(0, xids2.length);

         ProxyAssertSupport.assertTrue(xids[0].equals(xid1) || xids[1].equals(xid1));
         ProxyAssertSupport.assertTrue(xids[0].equals(xid2) || xids[1].equals(xid2));

         res.commit(xids[0], false);

         res.commit(xids[1], false);

         conn3 = JMSTestCase.cf.createConnection();

         Session sessRec = conn3.createSession(false, Session.AUTO_ACKNOWLEDGE);

         MessageConsumer cons1 = sessRec.createConsumer(HornetQServerTestCase.queue2);
         MessageConsumer cons2 = sessRec.createConsumer(HornetQServerTestCase.queue3);
         MessageConsumer cons3 = sessRec.createConsumer(HornetQServerTestCase.queue1);

         conn3.start();

         TextMessage m1 = (TextMessage)cons1.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m1);
         ProxyAssertSupport.assertEquals("testing1", m1.getText());

         TextMessage m2 = (TextMessage)cons2.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m2);
         ProxyAssertSupport.assertEquals("testing2", m2.getText());

         TextMessage m3 = (TextMessage)cons3.receive(HornetQServerTestCase.MAX_TIMEOUT);
         ProxyAssertSupport.assertNotNull(m3);
         ProxyAssertSupport.assertEquals("testing3", m3.getText());

      }
      finally
      {
         if (conn1 != null)
         {
            try
            {
               conn1.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn2 != null)
         {
            try
            {
               conn2.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }

         if (conn3 != null)
         {
            try
            {
               conn3.close();
            }
            catch (Exception e)
            {
               // Ignore
            }
         }
      }
   }
}
TOP

Related Classes of org.hornetq.jms.tests.XARecoveryTest

TOP
Copyright © 2018 www.massapi.com. 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.