Examples of org.hornetq.core.server.HornetQServer

org.hornetq.core.server.HornetQServer
This interface defines the internal interface of the HornetQ Server exposed to other components of the server.
This is not part of our public API. @author Tim Fox @author Andy Taylor

      Configuration config = createDefaultConfig();


      config.setJournalSyncNonTransactional(false);
      config.setJournalFileSize(10 * 1024 * 1024);


      HornetQServer server = createServer(true, config, 512 * 1024, 1024 * 1024, new HashMap<String, AddressSettings>());


      server.start();


      final int messageSize = 51527;


      final int numberOfMessages = 200;


      try
      {
         ServerLocator locator = createInVMNonHALocator();


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


         final ClientSessionFactory sf = locator.createSessionFactory();


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


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


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


         final AtomicInteger errors = new AtomicInteger(0);


         Thread consumeThread = new Thread()
         {
            public void run()
            {
               ClientSession sessionConsumer = null;
               try
               {
                  sessionConsumer = sf.createSession(false, false);
                  sessionConsumer.start();


                  ClientConsumer cons = sessionConsumer.createConsumer(ADDRESS);


                  for (int i = 0; i < numberOfMessages; i++)
                  {
                     ClientMessage msg = cons.receive(PagingTest.RECEIVE_TIMEOUT);
                     System.out.println("Message " + i + " consumed");
                     assertNotNull(msg);
                     msg.acknowledge();


                     if (i % 20 == 0)
                     {
                        System.out.println("Commit consumer");
                        sessionConsumer.commit();
                     }
                  }
                  sessionConsumer.commit();
               }
               catch (Throwable e)
               {
                  e.printStackTrace();
                  errors.incrementAndGet();
               }
               finally
               {
                  try
                  {
                     sessionConsumer.close();
                  }
                  catch (HornetQException e)
                  {
                     e.printStackTrace();
                     errors.incrementAndGet();
                  }
               }


            }
         };


         consumeThread.start();


         ClientMessage message = null;


         byte[] body = new byte[messageSize];


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


            System.out.println("Message " + i + " sent");


            HornetQBuffer bodyLocal = message.getBodyBuffer();


            bodyLocal.writeBytes(body);


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


            producer.send(message);


            Thread.sleep(50);
         }


         consumeThread.join();


         long timeout = System.currentTimeMillis() + 5000;


         while (System.currentTimeMillis() < timeout && (server.getPagingManager().getPageStore(ADDRESS).isPaging() || server.getPagingManager()
                                                                                                                             .getPageStore(ADDRESS)
                                                                                                                             .getNumberOfPages() != 1))
         {
            Thread.sleep(1);
         }


         // It's async, so need to wait a bit for it happening
         assertFalse(server.getPagingManager().getPageStore(ADDRESS).isPaging());


         assertEquals(1, server.getPagingManager().getPageStore(ADDRESS).getNumberOfPages());


         sf.close();


         locator.close();
      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here


      Configuration config = createDefaultConfig();


      config.setJournalSyncNonTransactional(false);


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


      server.start();


      final int messageSize = 1024;


      final int numberOfMessages = 200;


      try
      {
         ServerLocator locator = createInVMNonHALocator();


         locator.setClientFailureCheckPeriod(120000);
         locator.setConnectionTTL(5000000);
         locator.setCallTimeout(120000);


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


         ClientSessionFactory sf = locator.createSessionFactory();


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


         // note: if you want to change this, numberOfMessages has to be a multiple of NQUEUES
         int NQUEUES = 2;


         for (int i = 0; i < NQUEUES; i++)
         {
            session.createQueue(PagingTest.ADDRESS,
                                PagingTest.ADDRESS.concat("=" + i),
                                new SimpleString("propTest=" + i),
                                true);
         }


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


         ClientMessage message = null;


         byte[] body = new byte[messageSize];


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


            HornetQBuffer bodyLocal = message.getBodyBuffer();


            bodyLocal.writeBytes(body);


            message.putIntProperty("propTest", i % NQUEUES);
            message.putIntProperty("id", i);


            producer.send(message);
            if (i % 1000 == 0)
            {
               session.commit();
            }
         }


         session.commit();


         session.start();


         for (int nqueue = 0; nqueue < NQUEUES; nqueue++)
         {
            ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS.concat("=" + nqueue));


            for (int i = 0; i < (numberOfMessages / NQUEUES); i++)
            {
               message = consumer.receive(500000);
               assertNotNull(message);
               message.acknowledge();


               assertEquals(nqueue, message.getIntProperty("propTest").intValue());
            }


            assertNull(consumer.receiveImmediate());


            consumer.close();


            session.commit();
         }


         PagingStore store = server.getPagingManager().getPageStore(ADDRESS);
         store.getCursorProvier().cleanup();


         long timeout = System.currentTimeMillis() + 5000;
         while (store.isPaging() && timeout > System.currentTimeMillis())
         {
            Thread.sleep(100);
         }


         // It's async, so need to wait a bit for it happening
         assertFalse(server.getPagingManager().getPageStore(ADDRESS).isPaging());


         sf.close();


         locator.close();
      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here


      Configuration config = createDefaultConfig();


      config.setJournalSyncNonTransactional(false);


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


      server.start();


      final int messageSize = 1024;


      final int numberOfMessages = 1000;


      try
      {
         ServerLocator locator = createInVMNonHALocator();


         locator.setClientFailureCheckPeriod(120000);
         locator.setConnectionTTL(5000000);
         locator.setCallTimeout(120000);


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


         ClientSessionFactory sf = locator.createSessionFactory();


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


         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS.concat("=1"), null, true);
         session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS.concat("=2"), null, true);


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


         ClientMessage message = null;


         byte[] body = new byte[messageSize];


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


            HornetQBuffer bodyLocal = message.getBodyBuffer();


            bodyLocal.writeBytes(body);


            message.putIntProperty("propTest", i % 2 == 0 ? 1 : 2);


            producer.send(message);
            if (i % 1000 == 0)
            {
               session.commit();
            }
         }


         session.commit();


         session.start();


         for (int msg = 1; msg <= 2; msg++)
         {
            ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS.concat("=" + msg));


            for (int i = 0; i < numberOfMessages; i++)
            {
               message = consumer.receive(500000);
               assertNotNull(message);
               message.acknowledge();


               // assertEquals(msg, message.getIntProperty("propTest").intValue());


               System.out.println("i = " + i + " msg = " + message.getIntProperty("propTest"));
            }


            session.commit();


            assertNull(consumer.receiveImmediate());


            consumer.close();
         }


         PagingStore store = server.getPagingManager().getPageStore(ADDRESS);
         store.getCursorProvier().cleanup();


         long timeout = System.currentTimeMillis() + 5000;
         while (store.isPaging() && timeout > System.currentTimeMillis())
         {
            Thread.sleep(100);
         }


         store.getCursorProvier().cleanup();


         Thread.sleep(1000);


         // It's async, so need to wait a bit for it happening
         assertFalse(server.getPagingManager().getPageStore(ADDRESS).isPaging());


         sf.close();


         locator.close();
      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here

      AddressSettings dla = new AddressSettings();
      dla.setMaxDeliveryAttempts(5);
      dla.setDeadLetterAddress(new SimpleString("DLA"));
      settings.put(ADDRESS.toString(), dla);


      final HornetQServer server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, settings);


      server.start();


      final int messageSize = 1024;


      ServerLocator locator = null;
      ClientSessionFactory sf = null;
      ClientSession session = null;
      try
      {
         locator = createInVMNonHALocator();


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


         sf = locator.createSessionFactory();


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


         session.createQueue(ADDRESS, ADDRESS, true);


         session.createQueue("DLA", "DLA");


         PagingStore pgStoreAddress = server.getPagingManager().getPageStore(ADDRESS);
         pgStoreAddress.startPaging();
         PagingStore pgStoreDLA = server.getPagingManager().getPageStore(new SimpleString("DLA"));


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


         for (int i = 0; i < 100; i++)
         {
            log.debug("send message #" + i);
            ClientMessage message = session.createMessage(true);


            message.putStringProperty("id", "str" + i);


            message.setBodyInputStream(createFakeLargeStream(messageSize));


            producer.send(message);


            if ((i + 1) % 2 == 0)
            {
               session.commit();
            }
         }


         session.commit();


         session.start();


         ClientConsumer cons = session.createConsumer(ADDRESS);


         for (int msgNr = 0; msgNr < 2; msgNr++)
         {
            for (int i = 0; i < 5; i++)
            {
               ClientMessage msg = cons.receive(5000);


               assertNotNull(msg);


               msg.acknowledge();


               assertEquals("str" + msgNr, msg.getStringProperty("id"));


               for (int j = 0; j < messageSize; j++)
               {
                  assertEquals(getSamplebyte(j), msg.getBodyBuffer().readByte());
               }


               session.rollback();
            }


            pgStoreDLA.startPaging();
         }


         for (int i = 2; i < 100; i++)
         {
            log.debug("Received message " + i);
            ClientMessage message = cons.receive(5000);
            assertNotNull("Message " + i + " wasn't received", message);
            message.acknowledge();


            final AtomicInteger bytesOutput = new AtomicInteger(0);


            message.setOutputStream(new OutputStream()
            {
               @Override
               public void write(int b) throws IOException
               {
                  bytesOutput.incrementAndGet();
               }
            });


            try
            {
               if (!message.waitOutputStreamCompletion(10000))
               {
                  log.info(threadDump("dump"));
                  fail("Couldn't finish large message receiving");
               }
            }
            catch (Throwable e)
            {
               log.info("output bytes = " + bytesOutput);
               log.info(threadDump("dump"));
               fail("Couldn't finish large message receiving for id=" + message.getStringProperty("id") +
                    " with messageID=" +
                    message.getMessageID());
            }


         }


         assertNull(cons.receiveImmediate());


         cons.close();


         cons = session.createConsumer("DLA");


         for (int i = 0; i < 2; i++)
         {
            assertNotNull(cons.receive(5000));
         }


         sf.close();


         session.close();


         locator.close();


         server.stop();


         server.start();


         locator = createInVMNonHALocator();


         sf = locator.createSessionFactory();


         session = sf.createSession(false, false);


         session.start();


         cons = session.createConsumer(ADDRESS);


         for (int i = 2; i < 100; i++)
         {
            log.debug("Received message " + i);
            ClientMessage message = cons.receive(5000);
            assertNotNull(message);


            assertEquals("str" + i, message.getStringProperty("id"));


            message.acknowledge();


            message.setOutputStream(new OutputStream()
            {
               @Override
               public void write(int b) throws IOException
               {


               }
            });


            assertTrue(message.waitOutputStreamCompletion(5000));
         }


         assertNull(cons.receiveImmediate());


         cons.close();


         cons = session.createConsumer("DLA");


         for (int msgNr = 0; msgNr < 2; msgNr++)
         {
            ClientMessage msg = cons.receive(10000);


            assertNotNull(msg);


            assertEquals("str" + msgNr, msg.getStringProperty("id"));


            for (int i = 0; i < messageSize; i++)
            {
               assertEquals(getSamplebyte(i), msg.getBodyBuffer().readByte());
            }


            msg.acknowledge();
         }


         cons.close();


         cons = session.createConsumer(ADDRESS);


         session.commit();


         assertNull(cons.receiveImmediate());


         long timeout = System.currentTimeMillis() + 5000;


         pgStoreAddress = server.getPagingManager().getPageStore(ADDRESS);


         pgStoreAddress.getCursorProvier().getSubscription(server.locateQueue(ADDRESS).getID()).cleanupEntries();


         pgStoreAddress.getCursorProvier().cleanup();


         while (timeout > System.currentTimeMillis() && pgStoreAddress.isPaging())
         {
            Thread.sleep(50);
         }


         assertFalse(pgStoreAddress.isPaging());


         session.commit();
      }
      finally
      {
         session.close();
         sf.close();
         locator.close();
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here

      dla.setMaxDeliveryAttempts(5);
      dla.setDeadLetterAddress(new SimpleString("DLA"));
      dla.setExpiryAddress(new SimpleString("DLA"));
      settings.put(ADDRESS.toString(), dla);


      final HornetQServer server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX, settings);


      server.start();


      final int messageSize = 20;


      try
      {
         ServerLocator locator = createInVMNonHALocator();


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


         ClientSessionFactory sf = locator.createSessionFactory();


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


         session.createQueue(ADDRESS, ADDRESS, true);


         session.createQueue("DLA", "DLA");


         PagingStore pgStoreAddress = server.getPagingManager().getPageStore(ADDRESS);
         pgStoreAddress.startPaging();
         PagingStore pgStoreDLA = server.getPagingManager().getPageStore(new SimpleString("DLA"));


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


         ClientMessage message = null;


         for (int i = 0; i < 500; i++)
         {
            if (i % 100 == 0)
               log.info("send message #" + i);
            message = session.createMessage(true);


            message.putStringProperty("id", "str" + i);


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


            if (i % 2 == 0)
            {
               message.setBodyInputStream(createFakeLargeStream(messageSize));
            }
            else
            {
               byte bytes[] = new byte[messageSize];
               for (int s = 0; s < bytes.length; s++)
               {
                  bytes[s] = getSamplebyte(s);
               }
               message.getBodyBuffer().writeBytes(bytes);
            }


            producer.send(message);


            if ((i + 1) % 2 == 0)
            {
               session.commit();
               if (i < 400)
               {
                  pgStoreAddress.forceAnotherPage();
               }
            }
         }


         session.commit();


         sf.close();


         locator.close();


         server.stop();


         Thread.sleep(3000);


         server.start();


         locator = createInVMNonHALocator();


         sf = locator.createSessionFactory();


         session = sf.createSession(false, false);


         session.start();


         ClientConsumer consAddr = session.createConsumer(ADDRESS);


         assertNull(consAddr.receive(1000));


         ClientConsumer cons = session.createConsumer("DLA");


         for (int i = 0; i < 500; i++)
         {
            log.info("Received message " + i);
            message = cons.receive(10000);
            assertNotNull(message);
            message.acknowledge();


            message.saveToOutputStream(new OutputStream()
            {
               @Override
               public void write(int b) throws IOException
               {


               }
            });
         }


         assertNull(cons.receiveImmediate());


         session.commit();


         cons.close();


         long timeout = System.currentTimeMillis() + 5000;


         pgStoreAddress = server.getPagingManager().getPageStore(ADDRESS);


         while (timeout > System.currentTimeMillis() && pgStoreAddress.isPaging())
         {
            Thread.sleep(50);
         }


         assertFalse(pgStoreAddress.isPaging());


         session.close();
      }
      finally
      {
         locator.close();
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here


      Configuration config = createDefaultConfig();


      config.setJournalSyncNonTransactional(false);


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


      server.start();


      final int messageSize = 1024;


      final int numberOfMessages = 3000;


      final byte[] body = new byte[messageSize];


      ByteBuffer bb = ByteBuffer.wrap(body);


      for (int j = 1; j <= messageSize; j++)
      {
         bb.put(getSamplebyte(j));
      }


      try
      {
         {
            ServerLocator locator = createInVMNonHALocator();


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


            ClientSessionFactory sf = locator.createSessionFactory();


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


            session.createQueue(PagingTest.ADDRESS.toString(), PagingTest.ADDRESS + "-1", null, true);


            session.createQueue(PagingTest.ADDRESS.toString(), PagingTest.ADDRESS + "-2", null, false);


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


            ClientMessage message = null;


            for (int i = 0; i < numberOfMessages; i++)
            {
               if (i % 500 == 0)
               {
                  session.commit();
               }
               message = session.createMessage(true);


               HornetQBuffer bodyLocal = message.getBodyBuffer();


               bodyLocal.writeBytes(body);


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


               producer.send(message);
            }


            session.commit();


            session.close();


            server.stop();


            sf.close();
            locator.close();
         }


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


         ServerLocator locator = createInVMNonHALocator();
         final ClientSessionFactory sf2 = locator.createSessionFactory();


         final AtomicInteger errors = new AtomicInteger(0);


         Thread t = new Thread()
         {
            public void run()
            {
               try
               {
                  ClientSession session = sf2.createSession(null, null, false, true, true, false, 0);


                  ClientConsumer consumer = session.createConsumer(PagingTest.ADDRESS + "-1");


                  session.start();


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


                     Assert.assertNotNull(message2);


                     Assert.assertEquals(i, message2.getIntProperty("id").intValue());


                     message2.acknowledge();


                     Assert.assertNotNull(message2);


                     if (i % 1000 == 0)
                        session.commit();


                     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;
                     }
                  }


                  session.commit();


                  consumer.close();


                  session.close();
               }
               catch (Throwable e)
               {
                  e.printStackTrace();
                  errors.incrementAndGet();
               }


            }
         };


         t.start();
         t.join();


         assertEquals(0, errors.get());


         for (int i = 0; i < 20 && server.getPostOffice().getPagingManager().getPageStore(ADDRESS).isPaging(); i++)
         {
            // The delete may be asynchronous, giving some time case it eventually happen asynchronously
            Thread.sleep(500);
         }


         assertFalse(server.getPostOffice().getPagingManager().getPageStore(ADDRESS).isPaging());


         for (int i = 0; i < 20 && server.getPostOffice().getPagingManager().getTransactions().size() != 0; i++)
         {
            // The delete may be asynchronous, giving some time case it eventually happen asynchronously
            Thread.sleep(500);
         }


         assertEquals(0, server.getPostOffice().getPagingManager().getTransactions().size());


      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here


      Configuration config = createDefaultConfig();


      config.setJournalSyncNonTransactional(false);


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


      server.start();


      final int numberOfIntegers = 256;


      final int numberOfMessages = 1000;


      try
      {
         ServerLocator locator = createInVMNonHALocator();


         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[numberOfIntegers * 4];


         ByteBuffer bb = ByteBuffer.wrap(body);


         for (int j = 1; j <= numberOfIntegers; j++)
         {
            bb.putInt(j);
         }


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


            HornetQBuffer bodyLocal = message.getBodyBuffer();


            bodyLocal.writeBytes(body);


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


            producer.send(message);
         }


         session.close();
         sf.close();
         locator.close();


         if (persistentMessages)
         {
            server.stop();


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


         locator = createInVMNonHALocator();
         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);


            Assert.assertEquals(i, message2.getIntProperty("id").intValue());


            message2.acknowledge();


            Assert.assertNotNull(message2);


            if (i % 1000 == 0)
               session.commit();


            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();


         sf.close();


         locator.close();
      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here

   {
      clearData();


      Configuration config = createDefaultConfig();


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


      server.start();


      final int messageSize = 1024; // 1k


      try
      {
         ServerLocator locator = createInVMNonHALocator();
         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);


         byte[] body = new byte[messageSize];
         // HornetQBuffer bodyLocal = HornetQChannelBuffers.buffer(DataConstants.SIZE_INT * numberOfIntegers);


         ClientMessage message = null;


         int numberOfMessages = 0;
         while (true)
         {
            message = session.createMessage(true);
            message.getBodyBuffer().writeBytes(body);


            // 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();


         ClientSession sessionTransacted = sf.createSession(null, null, false, false, false, false, 0);


         ClientProducer producerTransacted = sessionTransacted.createProducer(PagingTest.ADDRESS);


         for (int i = 0; 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();
                  Assert.assertNotNull(msg);
               }


               Assert.assertNull(consumer.receiveImmediate());
               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"));


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


            message.acknowledge();
         }


         Assert.assertNull(consumer.receiveImmediate());


         consumer.close();


         session.close();


         sf.close();


         locator.close();
      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here

      boolean IS_DURABLE_MESSAGE = true;
      clearData();


      Configuration config = createDefaultConfig();


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


      server.start();


      final int messageSize = 1024; // 1k


      try
      {
         ServerLocator locator = createInVMNonHALocator();
         locator.setBlockOnNonDurableSend(true);
         locator.setBlockOnDurableSend(true);
         locator.setBlockOnAcknowledge(true);


         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();
      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here

   {
      clearData();


      Configuration config = createDefaultConfig();


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


      server.start();


      final int messageSize = 1024; // 1k


      try
      {
         ServerLocator locator = createInVMNonHALocator();
         locator.setBlockOnNonDurableSend(true);
         locator.setBlockOnDurableSend(true);
         locator.setBlockOnAcknowledge(true);


         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();
      }
      finally
      {
         try
         {
            server.stop();
         }
         catch (Throwable ignored)
         {
         }
      }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.hornetq.core.server.HornetQServer

com.degloba.controladorMSG.HornetQInitializer

com.insacosa.controladorMSG.HornetQInitializer

org.hornetq.core.example.EmbeddedExample

org.hornetq.core.example.EmbeddedServer

org.hornetq.core.server.impl.HornetQServerImpl

org.hornetq.jms.example.EmbeddedExample

org.hornetq.jms.SpawnedJMSServer

org.hornetq.tests.integration.client.AckBatchSizeTest

org.hornetq.tests.integration.client.AcknowledgeTest

org.hornetq.tests.integration.client.AddressSettingsTest

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.