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