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);
}
}
public void onMessage(ClientMessage message) {
try {
message.acknowledge();
ClientMessage outmsg = session.createMessage(true);
outmsg.putIntProperty("out_msg", message.getIntProperty("msg"));
producer.send(outmsg);
if (rollbackFirstMessage) {
session.rollback();
rollbackFirstMessage = false;
return;
}
if (counter.incrementAndGet() % 200 == 0) {
System.out.println("rollback " + message);
session.rollback();
} else {
commitLatch.countDown();
session.commit();
}
} catch (Exception e) {
e.printStackTrace();
try {
session.rollback();
} catch (Exception ignored) {
ignored.printStackTrace();
}
}
}
/**
* @param numberOfMessages
* @param session
* @throws Exception
*/
private void sendMessages(int numberOfMessages, ClientSession session) throws Exception {
ClientProducer producer = session.createProducer(inQueue);
for (int i = 0; i < numberOfMessages; i++) {
ActiveMQTextMessage txt = new ActiveMQTextMessage(session);
txt.setIntProperty("msg", i);
txt.setText("Message Number (" + i + ")");
txt.doBeforeSend();
producer.send(txt.getCoreMessage());
}
session.commit();
}
/**
* @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) {
}
}
}