public void process(String[] arg) {
if (arg.length != 13 && arg.length != 14) {
System.out.println("Invalid number of arguments! " + arg.length);
printUsage();
System.exit(-1);
}
String sourceHost;
String sourceUser;
String sourcePass;
int sourcePort;
String queue;
String targetHost;
int targetPort;
String targetUser;
String targetPassword;
String producingAddress;
int commit;
int waitTimeout;
String filter = null;
try {
sourceHost = arg[1];
sourcePort = Integer.parseInt(arg[2]);
sourceUser = arg[3];
sourcePass = arg[4];
queue = arg[5];
targetHost = arg[6];
targetPort = Integer.parseInt(arg[7]);
targetUser = arg[8];
targetPassword = arg[9];
producingAddress = arg[10];
waitTimeout = Integer.parseInt(arg[11]);
commit = Integer.parseInt(arg[12]);
if (arg.length == 14) {
filter = arg[13];
}
} catch (Exception e) {
e.printStackTrace();
printUsage();
System.exit(-1);
return; // the compiler doesn't understand exit as leaving the VM
}
Map<String, Object> sourceParameters = new HashMap<String, Object>();
sourceParameters.put(TransportConstants.HOST_PROP_NAME, sourceHost);
sourceParameters.put(TransportConstants.PORT_PROP_NAME, sourcePort);
Map<String, Object> targetParameters = new HashMap<String, Object>();
sourceParameters.put(TransportConstants.HOST_PROP_NAME, targetHost);
sourceParameters.put(TransportConstants.PORT_PROP_NAME, targetPort);
try {
TransportConfiguration configurationSource =
new TransportConfiguration(NettyConnectorFactory.class.getName(), sourceParameters);
ServerLocator locatorSource = ActiveMQClient.createServerLocator(false, configurationSource);
ClientSessionFactory factorySource = locatorSource.createSessionFactory();
ClientSession sessionSource =
factorySource.createSession(sourceUser, sourcePass, false, false, false, false, 0);
ClientConsumer consumer;
if (filter == null) {
consumer = sessionSource.createConsumer(queue);
} else {
consumer = sessionSource.createConsumer(queue, filter);
}
TransportConfiguration configurationTarget =
new TransportConfiguration(NettyConnectorFactory.class.getName(), targetParameters);
ServerLocator locatorTarget =
ActiveMQClient.createServerLocatorWithoutHA(configurationTarget);
ClientSessionFactory factoryTarget = locatorTarget.createSessionFactory();
ClientSession sessionTarget =
factoryTarget.createSession(targetUser, targetPassword, false, false, false, false, 0);
ClientProducer producer = sessionTarget.createProducer(producingAddress);
sessionSource.start();
int countMessage = 0;
while (true) {
ClientMessage message = consumer.receive(waitTimeout);
if (message == null) {
break;
}
message.acknowledge();
if (!message.containsProperty("_HQ_TOOL_original_address")) {
message.putStringProperty("_HQ_TOOL_original_address", message.getAddress().toString());
}
LinkedList<String> listToRemove = new LinkedList<String>();
for (SimpleString name : message.getPropertyNames()) {
if (name.toString().startsWith("_HQ_ROUTE_TO")) {
listToRemove.add(name.toString());
}
}
for (String str : listToRemove) {
message.removeProperty(str);
}
producer.send(message);
if (countMessage++ % commit == 0) {
System.out.println("Sent " + countMessage + " messages");
sessionTarget.commit();
sessionSource.commit();
}
}
sessionTarget.commit();
sessionSource.commit();
consumer.close();
producer.close();
sessionSource.close();
sessionTarget.close();
locatorSource.close();
locatorTarget.close();
} catch (Exception e) {
e.printStackTrace();
printUsage();
System.exit(-1);
}
}
@Test
public void testRollbackMultipleConsumers() throws Exception {
int numberOfMessages = 3000;
int numberOfConsumers = 10;
ClientSession session = factory.createTransactedSession();
sendMessages(numberOfMessages, session);
AtomicInteger count = new AtomicInteger(0);
CountDownLatch commitLatch = new CountDownLatch(numberOfMessages);
LocalConsumer[] consumers = new LocalConsumer[numberOfConsumers];
for (int i = 0; i < numberOfConsumers; i++) {
consumers[i] = new LocalConsumer(count, commitLatch);
consumers[i].start();
}
commitLatch.await(2, TimeUnit.MINUTES);
for (LocalConsumer consumer : consumers) {
consumer.stop();
}
ClientConsumer consumer = session.createConsumer(outQueue);
session.start();
HashSet<Integer> values = new HashSet<Integer>();
for (int i = 0; i < numberOfMessages; i++) {
ClientMessage msg = consumer.receive(1000);
assertNotNull(msg);
int value = msg.getIntProperty("out_msg");
msg.acknowledge();
assertFalse("msg " + value + " received in duplicate", values.contains(value));
values.add(value);
}
assertNull(consumer.receiveImmediate());
for (int i = 0; i < numberOfMessages; i++) {
assertTrue(values.contains(i));
}
assertEquals(numberOfMessages, values.size());
session.close();
}
public void start() throws Exception {
consumerLocator = createNettyNonHALocator();
factoryLocator = createSessionFactory(consumerLocator);
session = factoryLocator.createTransactedSession();
consumer = session.createConsumer(inQueue);
producer = session.createProducer(outQueue);
consumer.setMessageHandler(this);
session.start();
}
/**
* @param session
* @param queueToRead
* @param numberOfBytes
* @throws org.apache.activemq.api.core.ActiveMQException
* @throws FileNotFoundException
* @throws IOException
*/
protected void readMessage(
final ClientSession session, final SimpleString queueToRead, final int numberOfBytes)
throws ActiveMQException, IOException {
session.start();
ClientConsumer consumer = session.createConsumer(queueToRead);
ClientMessage clientMessage = consumer.receive(5000);
Assert.assertNotNull(clientMessage);
clientMessage.acknowledge();
session.commit();
consumer.close();
}
protected void testChunks(
final boolean isXA,
final boolean restartOnXA,
final boolean rollbackFirstSend,
final boolean useStreamOnConsume,
final boolean realFiles,
final boolean preAck,
final boolean sendingBlocking,
final boolean testBrowser,
final boolean useMessageConsumer,
final int numberOfMessages,
final long numberOfBytes,
final int waitOnConsumer,
final long delayDelivery,
final int producerWindow,
final int minSize)
throws Exception {
clearDataRecreateServerDirs();
server = createServer(realFiles);
server.start();
ServerLocator locator = createInVMNonHALocator();
try {
if (sendingBlocking) {
locator.setBlockOnNonDurableSend(true);
locator.setBlockOnDurableSend(true);
locator.setBlockOnAcknowledge(true);
}
if (producerWindow > 0) {
locator.setConfirmationWindowSize(producerWindow);
}
locator.setMinLargeMessageSize(minSize);
ClientSessionFactory sf = locator.createSessionFactory();
ClientSession session;
Xid xid = null;
session = sf.createSession(null, null, isXA, false, false, preAck, 0);
if (isXA) {
xid = newXID();
session.start(xid, XAResource.TMNOFLAGS);
}
session.createQueue(ADDRESS, ADDRESS, null, true);
ClientProducer producer = session.createProducer(ADDRESS);
if (rollbackFirstSend) {
sendMessages(numberOfMessages, numberOfBytes, delayDelivery, session, producer);
if (isXA) {
session.end(xid, XAResource.TMSUCCESS);
session.prepare(xid);
session.close();
if (realFiles && restartOnXA) {
server.stop();
server.start();
sf = locator.createSessionFactory();
}
session = sf.createSession(null, null, isXA, false, false, preAck, 0);
Xid[] xids = session.recover(XAResource.TMSTARTRSCAN);
Assert.assertEquals(1, xids.length);
Assert.assertEquals(xid, xids[0]);
session.rollback(xid);
producer = session.createProducer(ADDRESS);
xid = newXID();
session.start(xid, XAResource.TMNOFLAGS);
} else {
session.rollback();
}
validateNoFilesOnLargeDir();
}
sendMessages(numberOfMessages, numberOfBytes, delayDelivery, session, producer);
if (isXA) {
session.end(xid, XAResource.TMSUCCESS);
session.prepare(xid);
session.close();
if (realFiles && restartOnXA) {
server.stop();
server.start();
// we need to recreate sf's
sf = locator.createSessionFactory();
}
session = sf.createSession(null, null, isXA, false, false, preAck, 0);
Xid[] xids = session.recover(XAResource.TMSTARTRSCAN);
Assert.assertEquals(1, xids.length);
Assert.assertEquals(xid, xids[0]);
producer = session.createProducer(ADDRESS);
session.commit(xid, false);
xid = newXID();
session.start(xid, XAResource.TMNOFLAGS);
} else {
session.commit();
}
session.close();
if (realFiles) {
server.stop();
server = createServer(realFiles);
server.start();
sf = locator.createSessionFactory();
}
session = sf.createSession(null, null, isXA, false, false, preAck, 0);
if (isXA) {
xid = newXID();
session.start(xid, XAResource.TMNOFLAGS);
}
ClientConsumer consumer = null;
for (int iteration = testBrowser ? 0 : 1; iteration < 2; iteration++) {
session.stop();
// first time with a browser
consumer = session.createConsumer(ADDRESS, null, iteration == 0);
if (useMessageConsumer) {
final CountDownLatch latchDone = new CountDownLatch(numberOfMessages);
final AtomicInteger errors = new AtomicInteger(0);
MessageHandler handler =
new MessageHandler() {
int msgCounter;
public void onMessage(final ClientMessage message) {
try {
if (delayDelivery > 0) {
long originalTime =
(Long) message.getObjectProperty(new SimpleString("original-time"));
Assert.assertTrue(
System.currentTimeMillis() - originalTime + "<" + delayDelivery,
System.currentTimeMillis() - originalTime >= delayDelivery);
}
if (!preAck) {
message.acknowledge();
}
Assert.assertNotNull(message);
if (delayDelivery <= 0) {
// right now there is no guarantee of ordered delivered on multiple
// scheduledMessages with
// the same
// scheduled delivery time
Assert.assertEquals(
msgCounter,
((Integer) message.getObjectProperty(new SimpleString("counter-message")))
.intValue());
}
if (useStreamOnConsume) {
final AtomicLong bytesRead = new AtomicLong(0);
message.saveToOutputStream(
new OutputStream() {
@Override
public void write(final byte[] b) throws IOException {
if (b[0] == UnitTestCase.getSamplebyte(bytesRead.get())) {
bytesRead.addAndGet(b.length);
LargeMessageTestBase.log.debug(
"Read position " + bytesRead.get() + " on consumer");
} else {
LargeMessageTestBase.log.warn(
"Received invalid packet at position " + bytesRead.get());
}
}
@Override
public void write(final int b) throws IOException {
if (b == UnitTestCase.getSamplebyte(bytesRead.get())) {
bytesRead.incrementAndGet();
} else {
LargeMessageTestBase.log.warn("byte not as expected!");
}
}
});
Assert.assertEquals(numberOfBytes, bytesRead.get());
} else {
ActiveMQBuffer buffer = message.getBodyBuffer();
buffer.resetReaderIndex();
for (long b = 0; b < numberOfBytes; b++) {
if (b % (1024L * 1024L) == 0) {
LargeMessageTestBase.log.debug("Read " + b + " bytes");
}
Assert.assertEquals(UnitTestCase.getSamplebyte(b), buffer.readByte());
}
try {
buffer.readByte();
Assert.fail("Supposed to throw an exception");
} catch (Exception e) {
}
}
} catch (Throwable e) {
e.printStackTrace();
LargeMessageTestBase.log.warn("Got an error", e);
errors.incrementAndGet();
} finally {
latchDone.countDown();
msgCounter++;
}
}
};
session.start();
consumer.setMessageHandler(handler);
Assert.assertTrue(latchDone.await(waitOnConsumer, TimeUnit.SECONDS));
Assert.assertEquals(0, errors.get());
} else {
session.start();
for (int i = 0; i < numberOfMessages; i++) {
System.currentTimeMillis();
ClientMessage message = consumer.receive(waitOnConsumer + delayDelivery);
Assert.assertNotNull(message);
System.currentTimeMillis();
if (delayDelivery > 0) {
long originalTime =
(Long) message.getObjectProperty(new SimpleString("original-time"));
Assert.assertTrue(
System.currentTimeMillis() - originalTime + "<" + delayDelivery,
System.currentTimeMillis() - originalTime >= delayDelivery);
}
if (!preAck) {
message.acknowledge();
}
Assert.assertNotNull(message);
if (delayDelivery <= 0) {
// right now there is no guarantee of ordered delivered on multiple scheduledMessages
// with the same
// scheduled delivery time
Assert.assertEquals(
i,
((Integer) message.getObjectProperty(new SimpleString("counter-message")))
.intValue());
}
if (useStreamOnConsume) {
final AtomicLong bytesRead = new AtomicLong(0);
message.saveToOutputStream(
new OutputStream() {
@Override
public void write(final byte[] b) throws IOException {
if (b[0] == UnitTestCase.getSamplebyte(bytesRead.get())) {
bytesRead.addAndGet(b.length);
} else {
LargeMessageTestBase.log.warn(
"Received invalid packet at position " + bytesRead.get());
}
}
@Override
public void write(final int b) throws IOException {
if (bytesRead.get() % (1024L * 1024L) == 0) {
LargeMessageTestBase.log.debug("Read " + bytesRead.get() + " bytes");
}
if (b == (byte) 'a') {
bytesRead.incrementAndGet();
} else {
LargeMessageTestBase.log.warn("byte not as expected!");
}
}
});
Assert.assertEquals(numberOfBytes, bytesRead.get());
} else {
ActiveMQBuffer buffer = message.getBodyBuffer();
buffer.resetReaderIndex();
for (long b = 0; b < numberOfBytes; b++) {
if (b % (1024L * 1024L) == 0L) {
LargeMessageTestBase.log.debug("Read " + b + " bytes");
}
Assert.assertEquals(UnitTestCase.getSamplebyte(b), buffer.readByte());
}
}
}
}
consumer.close();
if (iteration == 0) {
if (isXA) {
session.end(xid, XAResource.TMSUCCESS);
session.rollback(xid);
xid = newXID();
session.start(xid, XAResource.TMNOFLAGS);
} else {
session.rollback();
}
} else {
if (isXA) {
session.end(xid, XAResource.TMSUCCESS);
session.commit(xid, true);
xid = newXID();
session.start(xid, XAResource.TMNOFLAGS);
} else {
session.commit();
}
}
}
session.close();
Assert.assertEquals(
0,
((Queue) server.getPostOffice().getBinding(ADDRESS).getBindable()).getDeliveringCount());
Assert.assertEquals(
0, getMessageCount((Queue) server.getPostOffice().getBinding(ADDRESS).getBindable()));
validateNoFilesOnLargeDir();
} finally {
locator.close();
try {
server.stop();
} catch (Throwable ignored) {
}
}
}