/** Make sure redelivered flag is set on redelivery via rollback */
@Test
public void testRedeliveredQueue() throws Exception {
Connection conn = null;
try {
conn = createConnection();
Session sess = conn.createSession(true, Session.SESSION_TRANSACTED);
MessageProducer producer = sess.createProducer(queue1);
MessageConsumer consumer = sess.createConsumer(queue1);
conn.start();
Message mSent = sess.createTextMessage("igloo");
producer.send(mSent);
sess.commit();
TextMessage mRec = (TextMessage) consumer.receive(2000);
ProxyAssertSupport.assertEquals("igloo", mRec.getText());
ProxyAssertSupport.assertFalse(mRec.getJMSRedelivered());
sess.rollback();
mRec = (TextMessage) consumer.receive(2000);
ProxyAssertSupport.assertEquals("igloo", mRec.getText());
ProxyAssertSupport.assertTrue(mRec.getJMSRedelivered());
sess.commit();
} finally {
if (conn != null) {
conn.close();
}
}
}
/**
* Make sure redelivered flag is set on redelivery via rollback, different setup: we close the
* rolled back session and we receive the message whose acknowledgment was cancelled on a new
* session.
*/
@Test
public void testRedeliveredQueue2() throws Exception {
Connection conn = null;
try {
conn = createConnection();
Session sendSession = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = sendSession.createProducer(queue1);
prod.send(sendSession.createTextMessage("a message"));
conn.close();
conn = createConnection();
Session sess = conn.createSession(true, Session.SESSION_TRANSACTED);
MessageConsumer cons = sess.createConsumer(queue1);
conn.start();
TextMessage tm = (TextMessage) cons.receive(1000);
ProxyAssertSupport.assertNotNull(tm);
ProxyAssertSupport.assertEquals("a message", tm.getText());
ProxyAssertSupport.assertFalse(tm.getJMSRedelivered());
ProxyAssertSupport.assertEquals(1, tm.getIntProperty("JMSXDeliveryCount"));
sess.rollback();
sess.close();
Session sess2 = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
cons = sess2.createConsumer(queue1);
tm = (TextMessage) cons.receive(1000);
ProxyAssertSupport.assertEquals("a message", tm.getText());
ProxyAssertSupport.assertEquals(2, tm.getIntProperty("JMSXDeliveryCount"));
ProxyAssertSupport.assertTrue(tm.getJMSRedelivered());
} finally {
if (conn != null) {
conn.close();
}
}
}
public void onMessage(final Message message) {
try {
// Step 9. We know the client is sending a text message so we cast
TextMessage textMessage = (TextMessage) message;
// Step 10. get the text from the message.
String text = textMessage.getText();
System.out.println("message " + text + " received");
if (!textMessage.getJMSRedelivered()) {
// Step 11. On first delivery get the transaction, take a look, and throw an exception
Transaction tx = tm.getTransaction();
if (tx != null) {
System.out.println("something is wrong, there should be no global transaction: " + tx);
} else {
System.out.println(
"there is no global transaction, although the message delivery is using a local transaction");
System.out.println("let's throw an exception and see what happens");
throw new RuntimeException("DOH!");
}
} else {
// Step 12. Print the message
System.out.println(
"The message was redelivered since the message delivery used a local transaction");
}
} catch (JMSException e) {
e.printStackTrace();
} catch (SystemException e) {
e.printStackTrace();
}
}
public void testSubscribeWithClientAck() throws Exception {
String frame = "CONNECT\n" + "login: brianm\n" + "passcode: wombats\n\n" + Stomp.NULL;
sendFrame(frame);
frame = receiveFrame(10000);
Assert.assertTrue(frame.startsWith("CONNECTED"));
frame =
"SUBSCRIBE\n"
+ "destination:/queue/"
+ getQueueName()
+ "\n"
+ "ack:client\n\n"
+ Stomp.NULL;
sendFrame(frame);
sendMessage(getName());
frame = receiveFrame(10000);
Assert.assertTrue(frame.startsWith("MESSAGE"));
frame = "DISCONNECT\n" + "\n\n" + Stomp.NULL;
sendFrame(frame);
// message should be received since message was not acknowledged
MessageConsumer consumer = session.createConsumer(queue);
TextMessage message = (TextMessage) consumer.receive(1000);
Assert.assertNotNull(message);
Assert.assertTrue(message.getJMSRedelivered());
}
/**
* test messages are acknowledged and recovered properly
*
* @throws Exception
*/
public void testClientAcknowledge() throws Exception {
Destination destination = createDestination(getClass().getName());
Connection connection = createConnection();
connection.setClientID(idGen.generateId());
connection.start();
Session consumerSession = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
MessageConsumer consumer = consumerSession.createConsumer(destination);
Session producerSession = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer producer = producerSession.createProducer(destination);
producer.setDeliveryMode(deliveryMode);
// send some messages
TextMessage sent1 = producerSession.createTextMessage();
sent1.setText("msg1");
sent1.setStringProperty("str", "1");
producer.send(sent1);
TextMessage sent2 = producerSession.createTextMessage();
sent2.setText("msg2");
sent2.setStringProperty("str", "2");
producer.send(sent2);
TextMessage sent3 = producerSession.createTextMessage();
sent2.setText("msg3");
sent2.setStringProperty("str", "3");
producer.send(sent3);
TextMessage msgTest = (TextMessage) consumer.receive(RECEIVE_TIMEOUT);
System.out.println("msgTest::" + msgTest + " // " + msgTest.getText());
TextMessage rec2 = (TextMessage) consumer.receive(RECEIVE_TIMEOUT);
System.out.println("msgTest::" + rec2 + " // " + rec2.getText());
assertNull(consumer.receiveNoWait());
// ack rec2
rec2.acknowledge();
TextMessage sent4 = producerSession.createTextMessage();
sent4.setText("msg4");
producer.send(sent4);
TextMessage rec4 = (TextMessage) consumer.receive(RECEIVE_TIMEOUT);
assertTrue(rec4.equals(sent4));
consumerSession.recover();
rec4 = (TextMessage) consumer.receive(RECEIVE_TIMEOUT);
assertTrue(rec4.equals(sent4));
assertTrue(rec4.getJMSRedelivered());
rec4.acknowledge();
connection.close();
}
@Test
public void testRedeliveredFlagTopic() throws Exception {
Connection conn = null;
try {
conn = createConnection();
Session sessSend = conn.createSession(true, Session.SESSION_TRANSACTED);
Session sess1 = conn.createSession(true, Session.SESSION_TRANSACTED);
MessageConsumer consumer1 = sess1.createConsumer(ActiveMQServerTestCase.topic1);
MessageProducer producer = sessSend.createProducer(ActiveMQServerTestCase.topic1);
Message mSent = sessSend.createTextMessage("igloo");
producer.send(mSent);
sessSend.commit();
conn.start();
TextMessage mRec1 = (TextMessage) consumer1.receive(2000);
ProxyAssertSupport.assertNotNull(mRec1);
ProxyAssertSupport.assertEquals("igloo", mRec1.getText());
ProxyAssertSupport.assertFalse(mRec1.getJMSRedelivered());
sess1.rollback(); // causes redelivery for session
mRec1 = (TextMessage) consumer1.receive(2000);
ProxyAssertSupport.assertEquals("igloo", mRec1.getText());
ProxyAssertSupport.assertTrue(mRec1.getJMSRedelivered());
sess1.commit();
} finally {
if (conn != null) {
conn.close();
}
}
}
@Override
public boolean runExample() throws Exception {
final int numMessages = 30;
Connection connection = null;
InitialContext initialContext = null;
try {
// Step 1. Get an initial context for looking up JNDI from the server #1
initialContext = new InitialContext();
// Step 2. Look up the JMS resources from JNDI
Queue queue = (Queue) initialContext.lookup("queue/exampleQueue");
ConnectionFactory connectionFactory =
(ConnectionFactory) initialContext.lookup("ConnectionFactory");
// Step 3. Create a JMS Connection
connection = connectionFactory.createConnection();
// Step 4. Create a *non-transacted* JMS Session with client acknowledgement
Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
// Step 5. Start the connection to ensure delivery occurs
connection.start();
// Step 6. Create a JMS MessageProducer and a MessageConsumer
MessageProducer producer = session.createProducer(queue);
MessageConsumer consumer = session.createConsumer(queue);
// Step 7. Send some messages to server #1, the live server
for (int i = 0; i < numMessages; i++) {
TextMessage message = session.createTextMessage("This is text message " + i);
producer.send(message);
System.out.println("Sent message: " + message.getText());
}
// Step 8. Receive and acknowledge a third of the sent messages
TextMessage message0 = null;
for (int i = 0; i < numMessages / 3; i++) {
message0 = (TextMessage) consumer.receive(5000);
System.out.println("Got message: " + message0.getText());
}
message0.acknowledge();
// Step 9. Receive the rest third of the sent messages but *do not* acknowledge them yet
for (int i = numMessages / 3; i < numMessages; i++) {
message0 = (TextMessage) consumer.receive(5000);
System.out.println("Got message: " + message0.getText());
}
// Step 10. Crash server #1, the live server, and wait a little while to make sure
// it has really crashed
Thread.sleep(5000);
killServer(0);
// Step 11. Acknowledging the 2nd half of the sent messages will fail as failover to the
// backup server has occurred
try {
message0.acknowledge();
} catch (JMSException e) {
System.out.println(
"Got (the expected) exception while acknowledging message: " + e.getMessage());
}
// Step 12. Consume again the 2nd third of the messages again. Note that they are not
// considered as redelivered.
for (int i = numMessages / 3; i < (numMessages / 3) * 2; i++) {
message0 = (TextMessage) consumer.receive(5000);
System.out.printf(
"Got message: %s (redelivered?: %s)\n",
message0.getText(), message0.getJMSRedelivered());
}
message0.acknowledge();
reStartServer(0, 10000);
Thread.sleep(10000);
// Step 11. Acknowledging the 2nd half of the sent messages will fail as failover to the
// backup server has occurred
try {
message0.acknowledge();
} catch (JMSException e) {
System.err.println("Got exception while acknowledging message: " + e.getMessage());
}
// Step 12. Consume again the 2nd third of the messages again. Note that they are not
// considered as redelivered.
for (int i = (numMessages / 3) * 2; i < numMessages; i++) {
message0 = (TextMessage) consumer.receive(5000);
System.out.printf(
"Got message: %s (redelivered?: %s)\n",
message0.getText(), message0.getJMSRedelivered());
}
message0.acknowledge();
return true;
} finally {
// Step 13. Be sure to close our resources!
if (connection != null) {
connection.close();
}
if (initialContext != null) {
initialContext.close();
}
}
}