JMS Colocated Failover Shared Store Example

This example demonstrates how you can configure a live server to scale down messages to another live server on shutdown.

This example starts 2 live servers each one with a connector configured for the other live server.

The second live server is killed and its messages are scaled down to the first server on shutdown.

The following shows how to configure the live servers to scale down to one another.

     
     <ha-policy>
         <live-only>
             <scale-down>
                 <connectors>
                     <connector-ref>server0-connector</connector-ref>
                 </connectors>
             </scale-down>
         </live-only>
     </ha-policy>
     
     

Example step-by-step

To run the example, simply type mvn verify from this directory

1. Get an initial context for looking up JNDI for both servers

           
    initialContext1 = getContext(1);
    initialContext = getContext(0);
   
        

2. Look up the JMS resources from JNDI

           
    Queue queue = (Queue)initialContext.lookup("/queue/exampleQueue");
    ConnectionFactory connectionFactory = (ConnectionFactory)initialContext.lookup("/ConnectionFactory");
    ConnectionFactory connectionFactory1 = (ConnectionFactory)initialContext1.lookup("/ConnectionFactory");
           
        

3. Create a JMS Connections

           
    connection = connectionFactory.createConnection();
    connection1 = connectionFactory1.createConnection();
           
        

4. Create a *non-transacted* JMS Session with client acknowledgement

           
    Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
    Session session1 = connection1.createSession(false, Session.CLIENT_ACKNOWLEDGE);
           
        

5. Create a JMS MessageProducer

           
    MessageProducer producer = session.createProducer(queue);
    MessageProducer producer1 = session1.createProducer(queue);
           
        

6. Send some messages to both servers

          
    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());
      message = session1.createTextMessage("This is another text message " + i);
      producer1.send(message);
      System.out.println("Sent message: " + message.getText());
    }
          
        

7. Crash server #0, the live server

          
    killServer(0);
          
        

8. start the connection ready to receive messages

           
    connection.start();
           
        

9. create a consumer

           
    MessageConsumer consumer = session.createConsumer(queue);
            
        

10. Receive and acknowledge all of the sent messages, you will notice that messages from both servers are received

           
    TextMessage message0 = null;
    for (int i = 0; i < numMessages; i++)
    {
       message0 = (TextMessage)consumer.receive(5000);
       System.out.println("Got message: " + message0.getText());
    }
    message0.acknowledge();
           
        

11. And finally (no pun intended), always remember to close your JMS resources after use, in a finally block. Closing a JMS connection will automatically close all of its sessions, consumers, producer and browser objects

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

       if (initialContext != null)
       {
       initialContext.close();
       }
       if (connection1 != null)
       {
       connection1.close();
       }

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