@Before public void init() throws Exception { this.factory = new EventFactory(mockPrincipalProvider); this.principal = TestUtil.createOwnerPrincipal(); eventFilter = new EventFilter(new CandlepinCommonTestConfig()); when(mockPrincipalProvider.get()).thenReturn(this.principal); when(mockSessionFactory.createTransactedSession()).thenReturn(mockClientSession); when(mockClientSession.createProducer(anyString())).thenReturn(mockClientProducer); when(mockClientSession.createMessage(anyBoolean())).thenReturn(mockClientMessage); when(mockClientMessage.getBodyBuffer()).thenReturn(HornetQBuffers.fixedBuffer(2000)); when(mockSessionFactory.getServerLocator()).thenReturn(mockLocator); this.mapper = spy(new ObjectMapper()); this.eventSinkImpl = createEventSink(mockSessionFactory); o = new Owner("test owner"); }
// https://jira.jboss.org/jira/browse/HORNETQ-111 // Test that, on rollback credits are released for messages cleared in the buffer public void testConsumerCreditsOnRollbackLargeMessages() throws Exception { locator.setConsumerWindowSize(10000); locator.setMinLargeMessageSize(1000); ClientSessionFactory sf = createSessionFactory(locator); ClientSession session = sf.createTransactedSession(); session.createQueue(QUEUE, QUEUE, null, false); ClientProducer producer = session.createProducer(QUEUE); final int numMessages = 100; final byte[] bytes = new byte[10000]; for (int i = 0; i < numMessages; i++) { ClientMessage message = session.createMessage(false); message.getBodyBuffer().writeBytes(bytes); message.putIntProperty("count", i); producer.send(message); } session.commit(); ClientConsumer consumer = session.createConsumer(QUEUE); session.start(); for (int i = 0; i < 110; i++) { ClientMessage message = consumer.receive(); int count = message.getIntProperty("count"); boolean redelivered = message.getDeliveryCount() > 1; if (count % 2 == 0 && !redelivered) { session.rollback(); } else { session.commit(); } } session.close(); }
public void doTestStressSend(final boolean netty) throws Exception { // first set up the server Map<String, Object> params = new HashMap<String, Object>(); params.put(TransportConstants.PORT_PROP_NAME, 5445); params.put(TransportConstants.HOST_PROP_NAME, "localhost"); params.put(TransportConstants.USE_NIO_PROP_NAME, true); // minimize threads to maximize possibility for deadlock params.put(TransportConstants.NIO_REMOTING_THREADS_PROPNAME, 1); params.put(TransportConstants.BATCH_DELAY, 50); Configuration config = createDefaultConfig(params, ServiceTestBase.NETTY_ACCEPTOR_FACTORY); HornetQServer server = createServer(true, config); server.getConfiguration().setThreadPoolMaxSize(2); server.start(); // now the client side Map<String, Object> connectionParams = new HashMap<String, Object>(); connectionParams.put(TransportConstants.PORT_PROP_NAME, 5445); connectionParams.put(TransportConstants.HOST_PROP_NAME, "localhost"); connectionParams.put(TransportConstants.USE_NIO_PROP_NAME, true); connectionParams.put(TransportConstants.BATCH_DELAY, 50); connectionParams.put(TransportConstants.NIO_REMOTING_THREADS_PROPNAME, 6); final TransportConfiguration transpConf = new TransportConfiguration(NettyConnectorFactory.class.getName(), connectionParams); final ServerLocator locator = createNonHALocator(netty); // each thread will do this number of transactions final int numberOfMessages = 100; // these must all be the same final int numProducers = 30; final int numConsumerProducers = 30; final int numConsumers = 30; // each produce, consume+produce and consume increments this counter final AtomicInteger totalCount = new AtomicInteger(0); // the total we expect if all producers, consumer-producers and // consumers complete normally int totalExpectedCount = (numProducers + numConsumerProducers + numConsumerProducers) * numberOfMessages; // each group gets a separate connection final Connection connectionProducer; final Connection connectionConsumerProducer; final Connection connectionConsumer; // create the 2 queues used in the test ClientSessionFactory sf = locator.createSessionFactory(transpConf); ClientSession session = sf.createTransactedSession(); session.createQueue("jms.queue.queue", "jms.queue.queue"); session.createQueue("jms.queue.queue2", "jms.queue.queue2"); session.commit(); sf.close(); session.close(); locator.close(); // create and start JMS connections HornetQConnectionFactory cf = HornetQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, transpConf); connectionProducer = cf.createConnection(); connectionProducer.start(); connectionConsumerProducer = cf.createConnection(); connectionConsumerProducer.start(); connectionConsumer = cf.createConnection(); connectionConsumer.start(); // these threads produce messages on the the first queue for (int i = 0; i < numProducers; i++) { new Thread() { @Override public void run() { Session session = null; try { session = connectionProducer.createSession(true, Session.SESSION_TRANSACTED); MessageProducer messageProducer = session.createProducer(HornetQDestination.createQueue("queue")); messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT); for (int i = 0; i < numberOfMessages; i++) { BytesMessage message = session.createBytesMessage(); message.writeBytes(new byte[3000]); message.setStringProperty("Service", "LoadShedService"); message.setStringProperty("Action", "testAction"); messageProducer.send(message); session.commit(); totalCount.incrementAndGet(); } } catch (Exception e) { throw new RuntimeException(e); } finally { if (session != null) { try { session.close(); } catch (Exception e) { e.printStackTrace(); } } } } }.start(); } // these threads just consume from the one and produce on a second queue for (int i = 0; i < numConsumerProducers; i++) { new Thread() { @Override public void run() { Session session = null; try { session = connectionConsumerProducer.createSession(true, Session.SESSION_TRANSACTED); MessageConsumer consumer = session.createConsumer(HornetQDestination.createQueue("queue")); MessageProducer messageProducer = session.createProducer(HornetQDestination.createQueue("queue2")); messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT); for (int i = 0; i < numberOfMessages; i++) { BytesMessage message = (BytesMessage) consumer.receive(5000); if (message == null) { return; } message = session.createBytesMessage(); message.writeBytes(new byte[3000]); message.setStringProperty("Service", "LoadShedService"); message.setStringProperty("Action", "testAction"); messageProducer.send(message); session.commit(); totalCount.incrementAndGet(); } } catch (Exception e) { throw new RuntimeException(e); } finally { if (session != null) { try { session.close(); } catch (Exception e) { e.printStackTrace(); } } } } }.start(); } // these threads consume from the second queue for (int i = 0; i < numConsumers; i++) { new Thread() { @Override public void run() { Session session = null; try { session = connectionConsumer.createSession(true, Session.SESSION_TRANSACTED); MessageConsumer consumer = session.createConsumer(HornetQDestination.createQueue("queue2")); for (int i = 0; i < numberOfMessages; i++) { BytesMessage message = (BytesMessage) consumer.receive(5000); if (message == null) { return; } session.commit(); totalCount.incrementAndGet(); } } catch (Exception e) { throw new RuntimeException(e); } finally { if (session != null) { try { session.close(); } catch (Exception e) { e.printStackTrace(); } } } } }.start(); } // check that the overall transaction count reaches the expected number, // which would indicate that the system didn't stall int timeoutCounter = 0; int maxSecondsToWait = 60; while (timeoutCounter < maxSecondsToWait && totalCount.get() < totalExpectedCount) { timeoutCounter++; Thread.sleep(1000); System.out.println( "Not done yet.. " + (maxSecondsToWait - timeoutCounter) + "; " + totalCount.get()); } System.out.println("Done.." + totalCount.get() + ", expected " + totalExpectedCount); Assert.assertEquals("Possible deadlock", totalExpectedCount, totalCount.get()); System.out.println("After assert"); // attempt cleaning up (this is not in a finally, still needs some work) connectionProducer.close(); connectionConsumerProducer.close(); connectionConsumer.close(); server.stop(); }