Examples of org.hornetq.core.client.impl.ClientConsumerInternal

org.hornetq.core.client.impl.ClientConsumerInternal
A ClientConsumerInternal @author Tim Fox


         // Reads the messages, rollback.. read them again
         for (int trans = 0; trans < 2; trans++)
         {


            ClientConsumerInternal consumer = (ClientConsumerInternal)session.createConsumer(LargeMessageTest.ADDRESS);


            // Wait the consumer to be complete with 10 messages before getting others
            long timeout = System.currentTimeMillis() + 10000;
            while (consumer.getBufferSize() < 10 && timeout > System.currentTimeMillis())
            {
               Thread.sleep(10);
            }


            for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
            {
               ClientMessage msg = consumer.receive(10000);
               Assert.assertNotNull(msg);


               // it will ignore the buffer (not read it) on the first try
               if (trans == 0)
               {
                  for (int byteRead = 0; byteRead < SIZE; byteRead++)
                  {
                     Assert.assertEquals(UnitTestCase.getSamplebyte(byteRead), msg.getBodyBuffer().readByte());
                  }
               }


               msg.acknowledge();
            }
            if (trans == 0)
            {
               session.rollback();
            }
            else
            {
               session.commit();
            }


            consumer.close();
         }


         Assert.assertEquals(0,
                             ((Queue)server.getPostOffice().getBinding(LargeMessageTest.ADDRESS).getBindable()).getDeliveringCount());
         Assert.assertEquals(0,

View Full Code Here

         sessionB = sf.createSession(false, true, true);
         sessionB.start();


         session.start();


         ClientConsumerInternal consReceiveOneAndHold = (ClientConsumerInternal)sessionB.createConsumer(ADDRESS);


         final CountDownLatch latchReceived = new CountDownLatch(2);


         final CountDownLatch latchDone = new CountDownLatch(1);


         // It can't close the session while the large message is being read
         final CountDownLatch latchRead = new CountDownLatch(1);


         // It should receive two messages and then give up
         class LocalHandler implements MessageHandler
         {
            boolean failed = false;


            int count = 0;


            /* (non-Javadoc)
             * @see org.hornetq.api.core.client.MessageHandler#onMessage(org.hornetq.api.core.client.ClientMessage)
             */
            public synchronized void onMessage(final ClientMessage message)
            {
               try
               {
                  String str = getTextMessage(message);


                  failed = failed || !str.equals("Msg" + count);


                  message.acknowledge();
                  latchReceived.countDown();


                  if (count++ == 1)
                  {
                     // it will hold here for a while
                     if (!latchDone.await(TIMEOUT, TimeUnit.SECONDS)) // a timed wait, so if the test fails, one less
                     // thread around
                     {
                        new Exception("ClientConsuemrWindowSizeTest Handler couldn't receive signal in less than 5 seconds").printStackTrace();
                        failed = true;
                     }


                     if (largeMessages)
                     {
                        message.getBodyBuffer().readBytes(new byte[600]);
                     }


                     latchRead.countDown();
                  }
               }
               catch (Exception e)
               {
                  e.printStackTrace(); // Hudson / JUnit report
                  failed = true;
               }
            }
         }


         LocalHandler handler = new LocalHandler();


         ClientConsumer cons1 = session.createConsumer(ADDRESS);


         ClientProducer prod = session.createProducer(ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = createTextMessage(session, "Msg" + i);
            if (largeMessages)
            {
               msg.getBodyBuffer().writeBytes(new byte[600]);
            }
            prod.send(msg);
         }


         consReceiveOneAndHold.setMessageHandler(handler);


         Assert.assertTrue(latchReceived.await(TIMEOUT, TimeUnit.SECONDS));


         Assert.assertEquals(0, consReceiveOneAndHold.getBufferSize());


         for (int i = 2; i < numberOfMessages; i++)
         {
            ClientMessage msg = cons1.receive(1000);
            Assert.assertNotNull("expected message at i = " + i, msg);
            Assert.assertEquals("Msg" + i, getTextMessage(msg));
            msg.acknowledge();
         }


         Assert.assertEquals(0, consReceiveOneAndHold.getBufferSize());


         latchDone.countDown();


         // The test can' t close the session while the message is still being read, or it could interrupt the data
         Assert.assertTrue(latchRead.await(10, TimeUnit.SECONDS));

View Full Code Here

         sessionB = sf.createSession(false, true, true);
         sessionB.start();


         session.start();


         ClientConsumerInternal consReceiveOneAndHold = (ClientConsumerInternal)sessionB.createConsumer(ADDRESS);


         final CountDownLatch latchReceived = new CountDownLatch(2);
         final CountDownLatch latchReceivedBuffered = new CountDownLatch(3);


         final CountDownLatch latchDone = new CountDownLatch(1);


         // It should receive two messages and then give up
         class LocalHandler implements MessageHandler
         {
            boolean failed = false;


            int count = 0;


            /* (non-Javadoc)
             * @see org.hornetq.api.core.client.MessageHandler#onMessage(org.hornetq.api.core.client.ClientMessage)
             */
            public synchronized void onMessage(final ClientMessage message)
            {
               try
               {
                  log.info("received msg " + message);
                  String str = getTextMessage(message);
                  if (ConsumerWindowSizeTest.isTrace)
                  {
                     ConsumerWindowSizeTest.log.trace("Received message " + str);
                  }


                  ConsumerWindowSizeTest.log.info("Received message " + str);


                  failed = failed || !str.equals("Msg" + count);


                  message.acknowledge();
                  latchReceived.countDown();
                  latchReceivedBuffered.countDown();


                  if (count++ == 1)
                  {
                     // it will hold here for a while
                     if (!latchDone.await(TIMEOUT, TimeUnit.SECONDS))
                     {
                        new Exception("ClientConsuemrWindowSizeTest Handler couldn't receive signal in less than 5 seconds").printStackTrace();
                        failed = true;
                     }
                  }
               }
               catch (Exception e)
               {
                  e.printStackTrace(); // Hudson / JUnit report
                  failed = true;
               }
            }
         }


         LocalHandler handler = new LocalHandler();


         ClientProducer prod = session.createProducer(ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = createTextMessage(session, "Msg" + i);
            if (largeMessage)
            {
               msg.getBodyBuffer().writeBytes(new byte[600]);
            }
            prod.send(msg);
         }


         consReceiveOneAndHold.setMessageHandler(handler);


         Assert.assertTrue(latchReceived.await(TIMEOUT, TimeUnit.SECONDS));


         log.info("bs " + consReceiveOneAndHold.getBufferSize());


         long timeout = System.currentTimeMillis() + 1000 * TIMEOUT;
         while (consReceiveOneAndHold.getBufferSize() == 0 && System.currentTimeMillis() < timeout)
         {
            log.info("bs " + consReceiveOneAndHold.getBufferSize());
            Thread.sleep(10);
         }


         Assert.assertEquals(1, consReceiveOneAndHold.getBufferSize());


         ClientConsumer cons1 = session.createConsumer(ADDRESS);


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

View Full Code Here

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


         sessionA.start();
         sessionB.start();


         ClientConsumerInternal consA = (ClientConsumerInternal)sessionA.createConsumer(ADDRESS);


         ClientConsumerInternal consB = (ClientConsumerInternal)sessionB.createConsumer(ADDRESS);


         {
            // We can only guarantee round robing with WindowSize = -1, after the ServerConsumer object received
            // SessionConsumerFlowCreditMessage(-1)
            // Since that is done asynchronously we verify that the information was received before we proceed on
            // sending messages or else the distribution won't be
            // even as expected by the test
            Bindings bindings = server.getPostOffice().getBindingsForAddress(ADDRESS);


            Assert.assertEquals(1, bindings.getBindings().size());


            for (Binding binding : bindings.getBindings())
            {
               Collection<Consumer> consumers = ((QueueBinding)binding).getQueue().getConsumers();


               for (Consumer consumer : consumers)
               {
                  ServerConsumerImpl consumerImpl = (ServerConsumerImpl)consumer;
                  long timeout = System.currentTimeMillis() + 5000;
                  while (timeout > System.currentTimeMillis() && consumerImpl.getAvailableCredits() != null)
                  {
                     Thread.sleep(10);
                  }


                  Assert.assertNull(consumerImpl.getAvailableCredits());
               }
            }
         }


         ClientProducer prod = sessionA.createProducer(ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = createTextMessage(sessionA, "Msg" + i);
            if (largeMessages)
            {
               msg.getBodyBuffer().writeBytes(new byte[600]);
            }
            prod.send(msg);
         }


         long timeout = System.currentTimeMillis() + TIMEOUT * 1000;


         boolean foundA = false;
         boolean foundB = false;


         do
         {
            foundA = consA.getBufferSize() == numberOfMessages / 2;
            foundB = consB.getBufferSize() == numberOfMessages / 2;


            Thread.sleep(10);
         }
         while ((!foundA || !foundB) && System.currentTimeMillis() < timeout);


         Assert.assertTrue("ConsumerA didn't receive the expected number of messages on buffer (consA=" + consA.getBufferSize() +
                                    ", consB=" +
                                    consB.getBufferSize() +
                                    ") foundA = " +
                                    foundA +
                                    " foundB = " +
                                    foundB,
                           foundA);
         Assert.assertTrue("ConsumerB didn't receive the expected number of messages on buffer (consA=" + consA.getBufferSize() +
                                    ", consB=" +
                                    consB.getBufferSize() +
                                    ") foundA = " +
                                    foundA +
                                    " foundB = " +
                                    foundB,
                           foundB);

View Full Code Here

         sessionB = sf.createSession(false, true, true);
         sessionB.start();


         session.start();


         ClientConsumerInternal consNeverUsed = (ClientConsumerInternal)sessionB.createConsumer(ADDRESS);


         ClientProducer prod = session.createProducer(ADDRESS);


         // This will force a credit to be sent, but if the message wasn't received we need to take out that credit from
         // the server
         // or the client will be buffering messages
         Assert.assertNull(consNeverUsed.receive(1));


         ClientMessage msg = createTextMessage(session, "This one will expire");
         if (largeMessages)
         {
            msg.getBodyBuffer().writeBytes(new byte[600]);
         }


         msg.setExpiration(System.currentTimeMillis() + 100);
         prod.send(msg);


         msg = createTextMessage(session, "First-on-non-buffered");


         prod.send(msg);


         Thread.sleep(110);


         // It will be able to receive another message, but it shouldn't send a credit again, as the credit was already
         // sent
         msg = consNeverUsed.receive(TIMEOUT * 1000);
         Assert.assertNotNull(msg);
         Assert.assertEquals("First-on-non-buffered", getTextMessage(msg));
         msg.acknowledge();


         ClientConsumer cons1 = session.createConsumer(ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            msg = createTextMessage(session, "Msg" + i);


            if (largeMessages)
            {
               msg.getBodyBuffer().writeBytes(new byte[600]);
            }


            prod.send(msg);
         }


         for (int i = 0; i < numberOfMessages; i++)
         {
            msg = cons1.receive(1000);
            Assert.assertNotNull("expected message at i = " + i, msg);
            Assert.assertEquals("Msg" + i, getTextMessage(msg));
            msg.acknowledge();
         }


         Assert.assertEquals(0, consNeverUsed.getBufferSize());


         session.close();
         session = null;


         sessionB.close();

View Full Code Here


         SimpleString ADDRESS = new SimpleString("some-queue");


         session1.createQueue(ADDRESS, ADDRESS, true);


         ClientConsumerInternal cons1 = (ClientConsumerInternal)session1.createConsumer(ADDRESS);


         // Note we make sure we send the messages *before* cons2 is created


         ClientProducer prod = session1.createProducer(ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = createTextMessage(session1, "Msg" + i);
            if (largeMessages)
            {
               msg.getBodyBuffer().writeBytes(new byte[600]);
            }
            prod.send(msg);
         }


         ClientConsumerInternal cons2 = (ClientConsumerInternal)session2.createConsumer(ADDRESS);


         for (int i = 0; i < numberOfMessages / 2; i++)
         {
            ClientMessage msg = cons1.receive(1000);
            Assert.assertNotNull("expected message at i = " + i, msg);


            String str = getTextMessage(msg);
            Assert.assertEquals("Msg" + i, str);


            log.info("got msg " + str);


            msg.acknowledge();


            Assert.assertEquals("A slow consumer shouldn't buffer anything on the client side!",
                                0,
                                cons1.getBufferSize());
         }


         for (int i = numberOfMessages / 2; i < numberOfMessages; i++)
         {
            ClientMessage msg = cons2.receive(1000);


            Assert.assertNotNull("expected message at i = " + i, msg);


            String str = getTextMessage(msg);


            log.info("got msg " + str);


            Assert.assertEquals("Msg" + i, str);


            msg.acknowledge();


            Assert.assertEquals("A slow consumer shouldn't buffer anything on the client side!",
                                0,
                                cons2.getBufferSize());
         }


         session1.close(); // just to make sure everything is flushed and no pending packets on the sending buffer, or
         // the getMessageCount would fail
         session2.close();


         session1 = sf.createSession(false, true, true);
         session1.start();
         session2 = sf.createSession(false, true, true);
         session2.start();


         prod = session1.createProducer(ADDRESS);


         Assert.assertEquals(0, getMessageCount(server, ADDRESS.toString()));


         // This should also work the other way around


         cons1.close();


         cons2.close();


         cons1 = (ClientConsumerInternal)session1.createConsumer(ADDRESS);


         // Note we make sure we send the messages *before* cons2 is created


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = createTextMessage(session1, "Msg" + i);
            if (largeMessages)
            {
               msg.getBodyBuffer().writeBytes(new byte[600]);
            }
            prod.send(msg);
         }


         cons2 = (ClientConsumerInternal)session2.createConsumer(ADDRESS);


         // Now we receive on cons2 first


         for (int i = 0; i < numberOfMessages / 2; i++)
         {
            ClientMessage msg = cons2.receive(1000);
            Assert.assertNotNull("expected message at i = " + i, msg);


            Assert.assertEquals("Msg" + i, msg.getBodyBuffer().readString());


            msg.acknowledge();


            Assert.assertEquals("A slow consumer shouldn't buffer anything on the client side!",
                                0,
                                cons2.getBufferSize());


         }


         for (int i = numberOfMessages / 2; i < numberOfMessages; i++)
         {

View Full Code Here


         SimpleString ADDRESS = new SimpleString("some-queue");


         session1.createQueue(ADDRESS, ADDRESS, true);


         ClientConsumerInternal cons1 = (ClientConsumerInternal)session1.createConsumer(ADDRESS);


         // Note we make sure we send the messages *before* cons2 is created


         ClientProducer prod = session1.createProducer(ADDRESS);


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = session1.createMessage(true);
            msg.getBodyBuffer().writeBytes(new byte[600]);
            prod.send(msg);
         }


         for (int i = 0; i < numberOfMessages; i++)
         {
            ClientMessage msg = cons1.receive(1000);
            Assert.assertNotNull("expected message at i = " + i, msg);


            msg.saveToOutputStream(new FakeOutputStream());


            msg.acknowledge();


            Assert.assertEquals("A slow consumer shouldn't buffer anything on the client side!",
                                0,
                                cons1.getBufferSize());
         }


         session1.close(); // just to make sure everything is flushed and no pending packets on the sending buffer, or
         session1.close();
         session1 = null;

View Full Code Here

            producer.send(msg);
         }
         
         session.commit();
         
         ClientConsumerInternal consumer = (ClientConsumerInternal)session.createConsumer(ADDRESS);
         
         session.start();


         for (int repeat = 0; repeat < 100; repeat ++)
         {
            System.out.println("Repeat " + repeat);
            long timeout = System.currentTimeMillis() + 2000;
            // At least 10 messages on the buffer
            while (timeout > System.currentTimeMillis() && consumer.getBufferSize() <= 10)
            {
               Thread.sleep(10);
            }
            assertTrue(consumer.getBufferSize() >= 10);
            
            ClientMessage msg = consumer.receive(500);
            msg.getBodyBuffer().readByte();
            assertNotNull(msg);
            msg.acknowledge();
            session.rollback();
         }
         
         
         for (int i = 0 ; i < numberOfMessages; i++)
         {
            ClientMessage msg = consumer.receive(5000);
            assertNotNull(msg);
            System.out.println("msg " + msg);
            msg.getBodyBuffer().readByte();
            msg.acknowledge();
            session.commit();

View Full Code Here

         session.commit();
         producer.close();


         session.start();


         ClientConsumerInternal consumer = (ClientConsumerInternal)session.createConsumer(LargeMessageTest.ADDRESS);


         // Wait the consumer to be complete with 10 messages before getting others
         long timeout = System.currentTimeMillis() + 10000;
         while (consumer.getBufferSize() < NUMBER_OF_MESSAGES && timeout > System.currentTimeMillis())
         {
            Thread.sleep(10);
         }
         Assert.assertEquals(NUMBER_OF_MESSAGES, consumer.getBufferSize());


         // Reads the messages, rollback.. read them again
         for (int trans = 0; trans < 2; trans++)
         {


            for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
            {
               ClientMessage msg = consumer.receive(10000);
               Assert.assertNotNull(msg);


               // it will ignore the buffer (not read it) on the first try
               if (trans == 0)
               {

View Full Code Here

         session.commit();
         producer.close();


         session.start();


         ClientConsumerInternal consumer = (ClientConsumerInternal)session.createConsumer(LargeMessageTest.ADDRESS);


         // Wait the consumer to be complete with 10 messages before getting others
         long timeout = System.currentTimeMillis() + 10000;
         while (consumer.getBufferSize() < NUMBER_OF_MESSAGES && timeout > System.currentTimeMillis())
         {
            Thread.sleep(10);
         }
         Assert.assertEquals(NUMBER_OF_MESSAGES, consumer.getBufferSize());


         // Reads the messages, rollback.. read them again
         for (int trans = 0; trans < 2; trans++)
         {


            for (int i = 0; i < NUMBER_OF_MESSAGES; i++)
            {
               ClientMessage msg = consumer.receive(10000);
               Assert.assertNotNull(msg);


               // it will ignore the buffer (not read it) on the first try
               if (trans == 0)
               {

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of org.hornetq.core.client.impl.ClientConsumerInternal

org.hornetq.tests.integration.client.ConsumerWindowSizeTest

org.hornetq.tests.integration.client.LargeMessageTest

org.hornetq.tests.integration.client.PagingTest

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.