Examples of org.hornetq.api.core.client.ClientSession

org.hornetq.api.core.client.ClientSession
A ClientSession is a single-thread object required for producing and consuming messages. @author Tim Fox @author Clebert Suconic @author Andy Taylor @author Jeff Mesnil

      {


         locator.setAckBatchSize(0);


         ClientSessionFactory sf = locator.createSessionFactory();
         ClientSession session = sf.createSession();


         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);


         ClientProducer producer = session.createProducer(PagingTest.ADDRESS);


         ClientMessage message = null;


         class MyHandler implements MessageHandler
         {
            int count;


            public void onMessage(ClientMessage message)
            {
               try
               {
                  Thread.sleep(1);
               }
               catch (Exception e)
               {


               }


               count++;


               if (count % 1000 == 0)
               {
                  log.info("received " + count);
               }


               try
               {
                  message.acknowledge();
               }
               catch (Exception e)
               {
                  e.printStackTrace();
               }
            }
         }


         ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);


         session.start();


         consumer.setMessageHandler(new MyHandler());


         for (int i = 0; i < numberOfMessages; i++)
         {
            byte[] body = new byte[1024];


            message = session.createMessage(false);
            message.getBodyBuffer().writeBytes(body);


            message.setExpiration(System.currentTimeMillis() + 100);


            producer.send(message);
         }


         session.close();
      }
      finally
      {
         try
         {

View Full Code Here

         locator.setBlockOnNonDurableSend(true);
         locator.setBlockOnDurableSend(true);
         locator.setBlockOnAcknowledge(true);


         ClientSessionFactory sf = locator.createSessionFactory();
         ClientSession session = sf.createSession(null, null, false, !transacted, true, false, 0);


         for (int i = 0; i < NUMBER_OF_BINDINGS; i++)
         {
            session.createQueue(PagingTest.ADDRESS, new SimpleString("someQueue" + i), null, true);
         }


         ClientProducer producer = session.createProducer(PagingTest.ADDRESS);


         ClientMessage message = null;


         byte[] body = new byte[1024];


         message = session.createMessage(true);
         message.getBodyBuffer().writeBytes(body);


         for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
         {
            producer.send(message);


            if (transacted)
            {
               session.commit();
            }
         }


         session.close();


         server.stop();


         server = createServer(true,
                               config,
                               PagingTest.PAGE_SIZE,
                               PagingTest.PAGE_MAX,
                               new HashMap<String, AddressSettings>());
         server.start();


         sf = locator.createSessionFactory();


         session = sf.createSession(null, null, false, true, true, false, 0);


         session.start();


         for (int msg = 0; msg < NUMBER_OF_MESSAGES; msg++)
         {


            for (int i = 0; i < NUMBER_OF_BINDINGS; i++)
            {
               ClientConsumer consumer = session.createConsumer(new SimpleString("someQueue" + i));


               ClientMessage message2 = consumer.receive(PagingTest.RECEIVE_TIMEOUT);


               Assert.assertNotNull(message2);


               message2.acknowledge();


               Assert.assertNotNull(message2);


               consumer.close();


            }
         }


         session.close();


         for (int i = 0; i < NUMBER_OF_BINDINGS; i++)
         {
            Queue queue = (Queue)server.getPostOffice().getBinding(new SimpleString("someQueue" + i)).getBindable();

View Full Code Here

      {
         server.start();


         ClientSessionFactory sf = locator.createSessionFactory();


         ClientSession session = sf.createSession(false, true, false);


         session.createQueue(PAGED_ADDRESS, PAGED_ADDRESS, true);


         session.createQueue(NON_PAGED_ADDRESS, NON_PAGED_ADDRESS, true);


         ClientProducer producerPaged = session.createProducer(PAGED_ADDRESS);
         ClientProducer producerNonPaged = session.createProducer(NON_PAGED_ADDRESS);


         int NUMBER_OF_MESSAGES = 100;


         for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
         {
            ClientMessage msg = session.createMessage(true);
            msg.getBodyBuffer().writeBytes(new byte[512]);


            producerPaged.send(msg);
            producerNonPaged.send(msg);
         }


         session.close();


         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS).isPaging());
         Assert.assertFalse(server.getPostOffice().getPagingManager().getPageStore(NON_PAGED_ADDRESS).isPaging());


         session = sf.createSession(false, true, false);


         session.start();


         ClientConsumer consumerNonPaged = session.createConsumer(NON_PAGED_ADDRESS);
         ClientConsumer consumerPaged = session.createConsumer(PAGED_ADDRESS);


         ClientMessage ackList[] = new ClientMessage[NUMBER_OF_MESSAGES];


         for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
         {
            ClientMessage msg = consumerNonPaged.receive(5000);
            Assert.assertNotNull(msg);
            ackList[i] = msg;
         }


         Assert.assertNull(consumerNonPaged.receiveImmediate());


         for (ClientMessage ack : ackList)
         {
            ack.acknowledge();
         }


         consumerNonPaged.close();


         session.commit();


         ackList = null;


         for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
         {
            ClientMessage msg = consumerPaged.receive(5000);
            Assert.assertNotNull(msg);
            msg.acknowledge();
            session.commit();
         }


         Assert.assertNull(consumerPaged.receiveImmediate());


         session.close();


      }
      finally
      {
         if (server.isStarted())

View Full Code Here

      {
         server.start();


         ClientSessionFactory sf = locator.createSessionFactory();


         ClientSession session = sf.createSession(false, true, false);


         session.createQueue(PAGED_ADDRESS_A, PAGED_ADDRESS_A, true);


         session.createQueue(PAGED_ADDRESS_B, PAGED_ADDRESS_B, true);


         ClientProducer producerA = session.createProducer(PAGED_ADDRESS_A);
         ClientProducer producerB = session.createProducer(PAGED_ADDRESS_B);


         int NUMBER_OF_MESSAGES = 100;


         for (int i = 0; i < NUMBER_MESSAGES_BEFORE_PAGING; i++)
         {
            ClientMessage msg = session.createMessage(true);
            msg.getBodyBuffer().writeBytes(new byte[512]);


            producerA.send(msg);
            producerB.send(msg);
         }


         session.commit(); // commit was called to clean the buffer only (making sure everything is on the server side)


         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS_A).isPaging());
         Assert.assertFalse(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());


         for (int i = 0; i < NUMBER_MESSAGES_BEFORE_PAGING; i++)
         {
            ClientMessage msg = session.createMessage(true);
            msg.getBodyBuffer().writeBytes(new byte[512]);


            producerA.send(msg);
            producerB.send(msg);
         }


         session.commit(); // commit was called to clean the buffer only (making sure everything is on the server side)


         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS_A).isPaging());
         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());


         for (int i = NUMBER_MESSAGES_BEFORE_PAGING * 2; i < NUMBER_OF_MESSAGES; i++)
         {
            ClientMessage msg = session.createMessage(true);
            msg.getBodyBuffer().writeBytes(new byte[512]);


            producerA.send(msg);
            producerB.send(msg);
         }


         session.close();


         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS_A).isPaging());
         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());


         session = sf.createSession(null, null, false, true, true, false, 0);


         session.start();


         ClientConsumer consumerA = session.createConsumer(PAGED_ADDRESS_A);


         ClientConsumer consumerB = session.createConsumer(PAGED_ADDRESS_B);


         for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
         {
            ClientMessage msg = consumerA.receive(5000);
            Assert.assertNotNull("Couldn't receive a message on consumerA, iteration = " + i, msg);
            msg.acknowledge();
         }


         Assert.assertNull(consumerA.receiveImmediate());


         consumerA.close();


         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PAGED_ADDRESS_B).isPaging());


         for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
         {
            ClientMessage msg = consumerB.receive(5000);
            Assert.assertNotNull(msg);
            msg.acknowledge();
            session.commit();
         }


         Assert.assertNull(consumerB.receiveImmediate());


         consumerB.close();


         session.close();


      }
      finally
      {
         if (server.isStarted())

View Full Code Here


         ClientSessionFactory sf = locator.createSessionFactory();


         byte[] body = new byte[messageSize];


         ClientSession sessionTransacted = sf.createSession(null, null, false, false, false, false, 0);
         ClientProducer producerTransacted = sessionTransacted.createProducer(PagingTest.ADDRESS);


         ClientSession session = sf.createSession(null, null, false, true, true, false, 0);
         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);


         ClientMessage firstMessage = sessionTransacted.createMessage(IS_DURABLE_MESSAGE);
         firstMessage.getBodyBuffer().writeBytes(body);
         firstMessage.putIntProperty(new SimpleString("id"), 0);


         producerTransacted.send(firstMessage);


         ClientProducer producer = session.createProducer(PagingTest.ADDRESS);


         ClientMessage message = null;


         int numberOfMessages = 0;
         while (true)
         {
            message = session.createMessage(IS_DURABLE_MESSAGE);
            message.getBodyBuffer().writeBytes(body);
            message.putIntProperty("id", numberOfMessages);
            message.putBooleanProperty("new", false);


            // Stop sending message as soon as we start paging
            if (server.getPostOffice().getPagingManager().getPageStore(PagingTest.ADDRESS).isPaging())
            {
               break;
            }
            numberOfMessages++;


            producer.send(message);
         }


         Assert.assertTrue(server.getPostOffice().getPagingManager().getPageStore(PagingTest.ADDRESS).isPaging());


         session.start();


         for (int i = 1; i < 10; i++)
         {
            message = session.createMessage(true);
            message.getBodyBuffer().writeBytes(body);
            message.putIntProperty(new SimpleString("id"), i);


            // Consume messages to force an eventual out of order delivery
            if (i == 5)
            {
               ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);
               for (int j = 0; j < numberOfMessages; j++)
               {
                  ClientMessage msg = consumer.receive(PagingTest.RECEIVE_TIMEOUT);
                  msg.acknowledge();
                  assertEquals(j, msg.getIntProperty("id").intValue());
                  assertFalse(msg.getBooleanProperty("new"));
                  Assert.assertNotNull(msg);
               }


               ClientMessage msgReceived = consumer.receiveImmediate();


               if (msgReceived != null)
               {
                  System.out.println("new = " + msgReceived.getBooleanProperty("new") +
                                     " id = " +
                                     msgReceived.getIntProperty("id"));
               }


               Assert.assertNull(msgReceived);
               consumer.close();
            }


            Integer messageID = (Integer)message.getObjectProperty(new SimpleString("id"));
            Assert.assertNotNull(messageID);
            Assert.assertEquals(messageID.intValue(), i);


            producerTransacted.send(message);
         }


         ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);


         Assert.assertNull(consumer.receiveImmediate());


         sessionTransacted.commit();


         sessionTransacted.close();


         for (int i = 0; i < 10; i++)
         {
            message = consumer.receive(PagingTest.RECEIVE_TIMEOUT);


            Assert.assertNotNull(message);


            Integer messageID = (Integer)message.getObjectProperty(new SimpleString("id"));


            // System.out.println(messageID);
            Assert.assertNotNull(messageID);
            Assert.assertEquals("message received out of order", i, messageID.intValue());


            message.acknowledge();
         }


         Assert.assertNull(consumer.receiveImmediate());


         consumer.close();


         session.close();


         sf.close();


         locator.close();
      }

View Full Code Here


         ClientSessionFactory sf = locator.createSessionFactory();


         byte[] body = new byte[messageSize];


         ClientSession sessionTransacted = sf.createSession(null, null, false, false, false, false, 0);
         ClientProducer producerTransacted = sessionTransacted.createProducer(PagingTest.ADDRESS);


         ClientSession sessionNonTX = sf.createSession(true, true, 0);
         sessionNonTX.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);


         ClientProducer producerNonTransacted = sessionNonTX.createProducer(PagingTest.ADDRESS);


         sessionNonTX.start();


         for (int i = 0; i < 50; i++)
         {
            System.out.println("Sending " + i);
            ClientMessage message = sessionNonTX.createMessage(true);
            message.getBodyBuffer().writeBytes(body);
            message.putIntProperty(new SimpleString("id"), i);
            message.putStringProperty(new SimpleString("tst"), new SimpleString("i=" + i));


            producerTransacted.send(message);


            if (i % 2 == 0)
            {
               System.out.println("Sending 20 msgs to make it page");
               for (int j = 0; j < 20; j++)
               {
                  ClientMessage msgSend = sessionNonTX.createMessage(true);
                  msgSend.putStringProperty(new SimpleString("tst"), new SimpleString("i=" + i + ", j=" + j));
                  msgSend.getBodyBuffer().writeBytes(new byte[10 * 1024]);
                  producerNonTransacted.send(msgSend);
               }
               assertTrue(server.getPostOffice().getPagingManager().getPageStore(PagingTest.ADDRESS).isPaging());
            }
            else
            {
               System.out.println("Consuming 20 msgs to make it page");
               ClientConsumer consumer = sessionNonTX.createConsumer(PagingTest.ADDRESS);
               for (int j = 0; j < 20; j++)
               {
                  ClientMessage msgReceived = consumer.receive(10000);
                  assertNotNull(msgReceived);
                  msgReceived.acknowledge();
               }
               consumer.close();
            }
         }


         ClientConsumer consumerNonTX = sessionNonTX.createConsumer(PagingTest.ADDRESS);
         while (true)
         {
            ClientMessage msgReceived = consumerNonTX.receive(1000);
            if (msgReceived == null)
            {
               break;
            }
            msgReceived.acknowledge();
         }
         consumerNonTX.close();


         ClientConsumer consumer = sessionNonTX.createConsumer(PagingTest.ADDRESS);


         Assert.assertNull(consumer.receiveImmediate());


         sessionTransacted.commit();


         sessionTransacted.close();


         for (int i = 0; i < 50; i++)
         {
            ClientMessage message = consumer.receive(PagingTest.RECEIVE_TIMEOUT);


            Assert.assertNotNull(message);


            Integer messageID = (Integer)message.getObjectProperty(new SimpleString("id"));


            // System.out.println(messageID);
            Assert.assertNotNull(messageID);
            Assert.assertEquals("message received out of order", i, messageID.intValue());


            System.out.println("MessageID = " + messageID);


            message.acknowledge();
         }


         Assert.assertNull(consumer.receiveImmediate());


         consumer.close();


         sessionNonTX.close();


         sf.close();


         locator.close();
      }

View Full Code Here


         Thread producerThread = new Thread()
         {
            public void run()
            {
               ClientSession sessionProducer = null;
               try
               {
                  sessionProducer = sf.createSession(false, false);
                  ClientProducer producer = sessionProducer.createProducer(ADDRESS);


                  for (int i = 0; i < numberOfMessages; i++)
                  {
                     ClientMessage msg = sessionProducer.createMessage(true);
                     msg.getBodyBuffer().writeBytes(body);
                     msg.putIntProperty("count", i);
                     producer.send(msg);


                     if (i % 100 == 0 && i != 0)
                     {
                        sessionProducer.commit();
                        // Thread.sleep(500);
                     }
                  }


                  sessionProducer.commit();


                  System.out.println("Producer gone");


               }
               catch (Throwable e)
               {
                  e.printStackTrace(); // >> junit report
                  errors.incrementAndGet();
               }
               finally
               {
                  try
                  {
                     if (sessionProducer != null)
                     {
                        sessionProducer.close();
                     }
                  }
                  catch (Throwable e)
                  {
                     e.printStackTrace();
                     errors.incrementAndGet();
                  }
               }
            }
         };


         ClientSession session = sf.createSession(true, true, 0);
         session.start();
         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);


         producerThread.start();


         ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = consumer.receive(5000);
            assertNotNull(msg);
            assertEquals(i, msg.getIntProperty("count").intValue());
            msg.acknowledge();
            if (i > 0 && i % 10 == 0)
            {
               session.commit();
            }
         }
         session.commit();


         session.close();


         producerThread.join();


         locator.close();

View Full Code Here


         Thread producerThread = new Thread()
         {
            public void run()
            {
               ClientSession sessionProducer = null;
               try
               {
                  sessionProducer = sf.createSession(true, true);
                  ClientProducer producer = sessionProducer.createProducer(ADDRESS);


                  for (int i = 0; i < numberOfMessages; i++)
                  {
                     ClientMessage msg = sessionProducer.createMessage(true);
                     msg.getBodyBuffer().writeBytes(body);
                     msg.putIntProperty("count", i);
                     producer.send(msg);


                     if (i == 1000)
                     {
                        // The session is not TX, but we do this just to perform a round trip to the server
                        // and make sure there are no pending messages
                        sessionProducer.commit();


                        assertTrue(server.getPagingManager().getPageStore(ADDRESS).isPaging());
                        ready.countDown();
                     }
                  }


                  sessionProducer.commit();


                  log.info("Producer gone");


               }
               catch (Throwable e)
               {
                  e.printStackTrace(); // >> junit report
                  errors.incrementAndGet();
               }
               finally
               {
                  try
                  {
                     if (sessionProducer != null)
                     {
                        sessionProducer.close();
                     }
                  }
                  catch (Throwable e)
                  {
                     e.printStackTrace();
                     errors.incrementAndGet();
                  }
               }
            }
         };


         ClientSession session = sf.createSession(true, true, 0);
         session.start();
         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);


         producerThread.start();


         assertTrue(ready.await(100, TimeUnit.SECONDS));


         ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = consumer.receive(5000);
            assertNotNull(msg);
            log.info("Received " + i + " with property = " + msg.getIntProperty("count"));
            if (i != msg.getIntProperty("count").intValue())
            {
               log.info("###### different");
            }
            // assertEquals(i, msg.getIntProperty("count").intValue());
            msg.acknowledge();
         }


         session.close();


         producerThread.join();


         assertEquals(0, errors.get());
      }

View Full Code Here

         locator.setBlockOnNonDurableSend(true);
         locator.setBlockOnDurableSend(true);
         locator.setBlockOnAcknowledge(true);


         ClientSessionFactory sf = locator.createSessionFactory();
         ClientSession session = sf.createSession(null, null, false, true, true, false, 0);


         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);


         ClientProducer producer = session.createProducer(PagingTest.ADDRESS);


         ClientMessage message = null;


         byte[] body = new byte[numberOfBytes];


         for (int j = 0; j < numberOfBytes; j++)
         {
            body[j] = UnitTestCase.getSamplebyte(j);
         }


         long scheduledTime = System.currentTimeMillis() + 5000;


         for (int i = 0; i < numberOfMessages; i++)
         {
            message = session.createMessage(true);


            message.getBodyBuffer().writeBytes(body);
            message.putIntProperty(new SimpleString("id"), i);


            TestSupportPageStore store = (TestSupportPageStore)server.getPostOffice()
                                                                     .getPagingManager()
                                                                     .getPageStore(PagingTest.ADDRESS);


            // Worse scenario possible... only schedule what's on pages
            if (store.getCurrentPage() != null)
            {
               message.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, scheduledTime);
            }


            producer.send(message);
         }


         if (restart)
         {
            session.close();


            server.stop();


            server = createServer(true,
                                  config,
                                  PagingTest.PAGE_SIZE,
                                  PagingTest.PAGE_MAX,
                                  new HashMap<String, AddressSettings>());
            server.start();


            sf = locator.createSessionFactory();


            session = sf.createSession(null, null, false, true, true, false, 0);
         }


         ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);


         session.start();


         for (int i = 0; i < numberOfMessages; i++)
         {


            ClientMessage message2 = consumer.receive(PagingTest.RECEIVE_TIMEOUT);


            Assert.assertNotNull(message2);


            message2.acknowledge();


            Assert.assertNotNull(message2);


            Long scheduled = (Long)message2.getObjectProperty(Message.HDR_SCHEDULED_DELIVERY_TIME);
            if (scheduled != null)
            {
               Assert.assertTrue("Scheduling didn't work", System.currentTimeMillis() >= scheduledTime);
            }


            try
            {
               assertBodiesEqual(body, message2.getBodyBuffer());
            }
            catch (AssertionFailedError e)
            {
               PagingTest.log.info("Expected buffer:" + UnitTestCase.dumbBytesHex(body, 40));
               PagingTest.log.info("Arriving buffer:" + UnitTestCase.dumbBytesHex(message2.getBodyBuffer()
                                                                                          .toByteBuffer()
                                                                                          .array(), 40));
               throw e;
            }
         }


         consumer.close();


         session.close();
      }
      finally
      {
         try
         {

View Full Code Here

         locator.setBlockOnNonDurableSend(true);
         locator.setBlockOnDurableSend(true);
         locator.setBlockOnAcknowledge(true);


         ClientSessionFactory sf = locator.createSessionFactory();
         ClientSession session = sf.createSession(null, null, false, false, true, false, 0);


         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);


         ClientProducer producer = session.createProducer(PagingTest.ADDRESS);


         ClientMessage message = null;


         for (int i = 0; i < numberOfMessages; i++)
         {
            message = session.createMessage(true);


            HornetQBuffer bodyLocal = message.getBodyBuffer();


            for (int j = 1; j <= numberOfIntegers; j++)
            {
               bodyLocal.writeInt(j);
            }


            message.putIntProperty(new SimpleString("id"), i);


            producer.send(message);
         }


         session.rollback();


         ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS);


         session.start();


         Assert.assertNull(consumer.receiveImmediate());


         session.close();
      }
      finally
      {
         try
         {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hornetq.api.core.client.ClientSession

org.hornetq.jms.bridge.impl.JMSBridgeImpl

org.hornetq.jms.client.HornetQConnection

org.hornetq.jms.server.recovery.HornetQXAResourceWrapper

org.hornetq.jms.tests.message.MessageHeaderTest

org.hornetq.ra.HornetQResourceAdapter

org.hornetq.ra.inflow.HornetQActivation

org.hornetq.rest.queue.AcknowledgedQueueConsumer

org.hornetq.rest.queue.PostMessage

org.hornetq.rest.queue.QueueDestinationsResource

org.hornetq.rest.queue.QueueServiceManager

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.