public Destination resolveDestinationName(
Session session, String destinationName, boolean pubSubDomain) throws JMSException {
// use a temporary queue to gather the reply message
synchronized (refreshWanted) {
if (queue == null || refreshWanted.compareAndSet(true, false)) {
queue = session.createTemporaryQueue();
setReplyTo(queue);
if (log.isDebugEnabled()) {
log.debug("Refreshed Temporary ReplyTo Queue. New queue: {}", queue.getQueueName());
}
refreshWanted.notifyAll();
}
}
return queue;
}
/**
* Example for sending a message fire and forget
*
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
final String methodName = "doGet";
// We simply return some text showing what we've done
response.setContentType("text/plain");
PrintWriter out = response.getWriter();
WLMJMSMessageProducer wlmConnection = null;
boolean complete = false;
try {
// Begin a transaction
userTransaction.begin();
// Print the user transaction status
out.println(WLMJMSTranUtils.summarizeUserTranStatus(userTransaction));
// Create our JMS connection/session/producer using the WLM connection logic
// Many fire-and-forget scenarios are for exactly once delivery, where a
// database is updated in the same transaction as sending the request.
// For this reason in this example we begin a transaction and send
// a persistent message.
// As such JDBC operations could be inserted into this sample, and would
// be coordinated in an atomic transaction with sending the request.
//
// If you are instead looking to send nonpersistent messages, such as publishing
// some non-critical state data on a topic, then you should consider
// removing the transaction, changing the transaction
// boolean in the getMessageProducer() call to false, and setting the DeliveryMode
// to NON_PERSISTENT when sending the message.
out.println("JMS destination: " + fireAndForgetTarget);
wlmConnection =
wlmJMSAttach.getMessageProducer(fireAndForgetTarget, true, Session.AUTO_ACKNOWLEDGE);
// TODO: Replace this section with business logic
// We create a temporary queue solely for the purpose of finding out where
// we are connected, as the temporary queue name should show this.
// This is inefficient, so it is for demonstration purposes only.
TemporaryQueue temporaryQueue = wlmConnection.getSession().createTemporaryQueue();
String temporaryQueueName = temporaryQueue.getQueueName();
out.println("Temporary queue showing where we are connected:");
out.println(temporaryQueueName);
temporaryQueue.delete();
String exampleMessageBody =
this.getClass().getName()
+ " (thread \""
+ Thread.currentThread().getName()
+ "\") sending at "
+ new Date();
Message message = wlmConnection.getSession().createTextMessage(exampleMessageBody);
out.println("Sending message \"" + exampleMessageBody + "\"");
// Send the message
wlmConnection
.getProducer()
.send(
message,
DeliveryMode.PERSISTENT, /* We are persistent in this example */
wlmConnection.getProducer().getPriority() /* Default priority */,
0 /* Do not expire */);
out.println("JMSMessageID: " + message.getJMSMessageID());
// Commit the transaction
userTransaction.commit();
// Mark that we're complete, so that we throw any exception seen during cleanup,
// and do not attempt rollback of the transaction
complete = true;
} catch (HeuristicMixedException e) {
if (log.enabled()) log.logExStack(methodName, "Transaction HeuristicMixedException", e);
throw new ServletException("Transaction HeuristicMixedException: " + e.getMessage(), e);
} catch (HeuristicRollbackException e) {
if (log.enabled()) log.logExStack(methodName, "Transaction HeuristicRollbackException", e);
throw new ServletException("Transaction HeuristicRollbackException: " + e.getMessage(), e);
} catch (RollbackException e) {
if (log.enabled()) log.logExStack(methodName, "Transaction RollbackException", e);
throw new ServletException("Transaction RollbackException: " + e.getMessage(), e);
} catch (NotSupportedException e) {
if (log.enabled()) log.logExStack(methodName, "Transaction NotSupportedException", e);
throw new ServletException("Transaction NotSupportedException: " + e.getMessage(), e);
} catch (SystemException e) {
if (log.enabled()) log.logExStack(methodName, "Transaction SystemException", e);
throw new ServletException("Transaction SystemException: " + e.getMessage(), e);
} catch (JMSException e) {
if (log.enabled()) log.logRootExMsg(methodName, "JMSException in business logic", e);
throw new ServletException("JMSException: " + e.getMessage(), e);
} finally {
// Rollback if we didn't complete
if (!complete)
try {
userTransaction.rollback();
} catch (SystemException e) {
// We are already on an exception path, so we should not throw this exception
if (log.enabled()) log.logExStack(methodName, "Exception during rollback", e);
}
// Close off our resources, ensuring we only throw an exception if we completed
// our earlier logic, so we don't override an earlier exception that being thrown.
if (wlmConnection != null)
try {
wlmConnection.close(complete);
} catch (JMSException e) {
throw new ServletException("JMSException on Connection close: " + e.getMessage(), e);
}
}
}
/**
* Try to use ActiveMQ StatisticsPlugin to get size and if that fails fallback to {@link
* JMSMailQueue#getSize()}
*/
@Override
public long getSize() throws MailQueueException {
Connection connection = null;
Session session = null;
MessageConsumer consumer = null;
MessageProducer producer = null;
TemporaryQueue replyTo = null;
long size;
try {
connection = connectionFactory.createConnection();
connection.start();
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
replyTo = session.createTemporaryQueue();
consumer = session.createConsumer(replyTo);
Queue myQueue = session.createQueue(queueName);
producer = session.createProducer(null);
String queueName = "ActiveMQ.Statistics.Destination." + myQueue.getQueueName();
Queue query = session.createQueue(queueName);
Message msg = session.createMessage();
msg.setJMSReplyTo(replyTo);
producer.send(query, msg);
MapMessage reply = (MapMessage) consumer.receive(2000);
if (reply != null && reply.itemExists("size")) {
try {
size = reply.getLong("size");
return size;
} catch (NumberFormatException e) {
// if we hit this we can't calculate the size so just catch
// it
}
}
} catch (Exception e) {
throw new MailQueueException("Unable to remove mails", e);
} finally {
if (consumer != null) {
try {
consumer.close();
} catch (JMSException e1) {
e1.printStackTrace();
// ignore on rollback
}
}
if (producer != null) {
try {
producer.close();
} catch (JMSException e1) {
// ignore on rollback
}
}
if (replyTo != null) {
try {
// we need to delete the temporary queue to be sure we will
// free up memory if thats not done and a pool is used
// its possible that we will register a new mbean in jmx for
// every TemporaryQueue which will never get unregistered
replyTo.delete();
} catch (JMSException e) {
}
}
try {
if (session != null) session.close();
} catch (JMSException e1) {
// ignore here
}
try {
if (connection != null) connection.close();
} catch (JMSException e1) {
// ignore here
}
}
// if we came to this point we should just fallback to super method
return super.getSize();
}
