JMS Colocated Failover Shared Store Example

This example demonstrates how you can colocate live and backup servers in the same VM. We do this by creating an HA Policy that is colocated. colocated means that backup servers can be created and maintained by live servers on behalf of other requesting live servers. In this example we create a colocated shared store server.

This example starts 2 live servers each with a backup server that backs up the other live server.

The first live server will be killed and the backup in the second will become live

The following shows how to configure the live servers to request and allow backups to be deployed

     <ha-policy>
         <shared-store>
             <colocated>
                 <backup-port-offset>100</backup-port-offset>
                 <backup-request-retries>-1</backup-request-retries>
                 <backup-request-retry-interval>2000</backup-request-retry-interval>
                 <max-backups>1</max-backups>
                 <request-backup>true</request-backup>
                 <master/>
                 <slave/>
             </colocated>
         </shared-store>
     </ha-policy>
     
     

notice that we have used a template to set some sensible defaults but overridden the backup strategy so back ups are full servers

Example step-by-step

To run the example, simply type mvn verify -Pexample 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

           
    connection1.start();
           
        

9. create a consumer

           
    MessageConsumer consumer = session1.createConsumer(queue);
            
        

10. Receive and acknowledge all of the sent messages, the backup server that is colocated with server 1 will have become live and is now handling messages for server 0.

           
    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. Receive and acknowledge the rest of the sent messages from server 1.

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

12. 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();
       }
    }