/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.event.output.adapter.jms.internal.util;
import org.apache.axis2.transport.base.BaseUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.NameNotFoundException;
import javax.naming.NamingException;
import javax.naming.Reference;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
/**
* Miscallaneous methods used for the JMS transport
*/
public class JMSUtils extends BaseUtils {
private static final Log log = LogFactory.getLog(JMSUtils.class);
/**
* Get a String property from the JMS message
*
* @param message JMS message
* @param property property name
* @return property value
*/
public static String getProperty(Message message, String property) {
try {
return message.getStringProperty(property);
} catch (JMSException e) {
return null;
}
}
/**
* Set the JMS ReplyTo for the message
*
* @param replyDestination the JMS Destination where the reply is expected
* @param session the session to use to create a temp Queue if a response is expected
* but a Destination has not been specified
* @param message the JMS message where the final Destinatio would be set as the JMS ReplyTo
* @return the JMS ReplyTo Destination for the message
*/
public static Destination setReplyDestination(Destination replyDestination, Session session,
Message message) {
if (replyDestination == null) {
try {
// create temporary queue to receive the reply
replyDestination = createTemporaryDestination(session);
} catch (JMSException e) {
handleException("Error creating temporary queue for response", e);
}
}
try {
message.setJMSReplyTo(replyDestination);
} catch (JMSException e) {
log.warn("Error setting JMS ReplyTo destination to : " + replyDestination, e);
}
if (log.isDebugEnabled()) {
try {
assert replyDestination != null;
log.debug("Expecting a response to JMS Destination : " +
(replyDestination instanceof Queue ?
((Queue) replyDestination).getQueueName() :
((Topic) replyDestination).getTopicName()));
} catch (JMSException ignore) {
}
}
return replyDestination;
}
/**
* Set transport headers from the axis message context, into the JMS message
*
* @param messageConfiguration the adaptor message context
* @param message the JMS Message
* @throws javax.jms.JMSException on exception
*/
public static Message setTransportHeaders(Map<String, String> messageConfiguration,
Message message)
throws JMSException {
if (messageConfiguration == null) {
return message;
}
for (String name : messageConfiguration.keySet()) {
if (name.startsWith(JMSConstants.JMSX_PREFIX) &&
!(name.equals(JMSConstants.JMSX_GROUP_ID) || name.equals(JMSConstants.JMSX_GROUP_SEQ))) {
continue;
}
if (JMSConstants.JMS_COORELATION_ID.equals(name)) {
message.setJMSCorrelationID(messageConfiguration.get(JMSConstants.JMS_COORELATION_ID));
} else if (JMSConstants.JMS_DELIVERY_MODE.equals(name)) {
String mode = messageConfiguration.get(JMSConstants.JMS_DELIVERY_MODE);
try {
message.setJMSDeliveryMode(Integer.parseInt(mode));
} catch (NumberFormatException nfe) {
log.warn("Invalid delivery mode ignored : " + mode, nfe);
}
} else if (JMSConstants.JMS_EXPIRATION.equals(name)) {
message.setJMSExpiration(
Long.parseLong(messageConfiguration.get(JMSConstants.JMS_EXPIRATION)));
} else if (JMSConstants.JMS_MESSAGE_ID.equals(name)) {
message.setJMSMessageID(messageConfiguration.get(JMSConstants.JMS_MESSAGE_ID));
} else if (JMSConstants.JMS_PRIORITY.equals(name)) {
message.setJMSPriority(
Integer.parseInt(messageConfiguration.get(JMSConstants.JMS_PRIORITY)));
} else if (JMSConstants.JMS_TIMESTAMP.equals(name)) {
message.setJMSTimestamp(
Long.parseLong(messageConfiguration.get(JMSConstants.JMS_TIMESTAMP)));
} else if (JMSConstants.JMS_MESSAGE_TYPE.equals(name)) {
message.setJMSType(messageConfiguration.get(JMSConstants.JMS_MESSAGE_TYPE));
} else {
//TODO currently only string is supported in messageConfiguration
Object value = messageConfiguration.get(name);
if (value instanceof String) {
message.setStringProperty(name, (String) value);
} else if (value instanceof Boolean) {
message.setBooleanProperty(name, (Boolean) value);
} else if (value instanceof Integer) {
message.setIntProperty(name, (Integer) value);
} else if (value instanceof Long) {
message.setLongProperty(name, (Long) value);
} else if (value instanceof Double) {
message.setDoubleProperty(name, (Double) value);
} else if (value instanceof Float) {
message.setFloatProperty(name, (Float) value);
}
}
}
return message;
}
/**
* Extract transport level headers for JMS from the given message into a Map
*
* @param message the JMS message
* @return a Map of the transport headers
*/
public static Map<String, Object> getTransportHeaders(Message message) {
// create a Map to hold transport headers
Map<String, Object> map = new HashMap<String, Object>();
// correlation ID
try {
if (message.getJMSCorrelationID() != null) {
map.put(JMSConstants.JMS_COORELATION_ID, message.getJMSCorrelationID());
}
} catch (JMSException ignore) {
}
// set the delivery mode as persistent or not
try {
map.put(JMSConstants.JMS_DELIVERY_MODE, Integer.toString(message.getJMSDeliveryMode()));
} catch (JMSException ignore) {
}
// destination name
try {
if (message.getJMSDestination() != null) {
Destination dest = message.getJMSDestination();
map.put(JMSConstants.JMS_DESTINATION,
dest instanceof Queue ?
((Queue) dest).getQueueName() : ((Topic) dest).getTopicName());
}
} catch (JMSException ignore) {
}
// expiration
try {
map.put(JMSConstants.JMS_EXPIRATION, Long.toString(message.getJMSExpiration()));
} catch (JMSException ignore) {
}
// if a JMS message ID is found
try {
if (message.getJMSMessageID() != null) {
map.put(JMSConstants.JMS_MESSAGE_ID, message.getJMSMessageID());
}
} catch (JMSException ignore) {
}
// priority
try {
map.put(JMSConstants.JMS_PRIORITY, Long.toString(message.getJMSPriority()));
} catch (JMSException ignore) {
}
// redelivered
try {
map.put(JMSConstants.JMS_REDELIVERED, Boolean.toString(message.getJMSRedelivered()));
} catch (JMSException ignore) {
}
// replyto destination name
try {
if (message.getJMSReplyTo() != null) {
Destination dest = message.getJMSReplyTo();
map.put(JMSConstants.JMS_REPLY_TO,
dest instanceof Queue ?
((Queue) dest).getQueueName() : ((Topic) dest).getTopicName());
}
} catch (JMSException ignore) {
}
// priority
try {
map.put(JMSConstants.JMS_TIMESTAMP, Long.toString(message.getJMSTimestamp()));
} catch (JMSException ignore) {
}
// message type
try {
if (message.getJMSType() != null) {
map.put(JMSConstants.JMS_TYPE, message.getJMSType());
}
} catch (JMSException ignore) {
}
// any other transport properties / headers
Enumeration<?> e = null;
try {
e = message.getPropertyNames();
} catch (JMSException ignore) {
}
if (e != null) {
while (e.hasMoreElements()) {
String headerName = (String) e.nextElement();
try {
map.put(headerName, message.getStringProperty(headerName));
continue;
} catch (JMSException ignore) {
}
try {
map.put(headerName, message.getBooleanProperty(headerName));
continue;
} catch (JMSException ignore) {
}
try {
map.put(headerName, message.getIntProperty(headerName));
continue;
} catch (JMSException ignore) {
}
try {
map.put(headerName, message.getLongProperty(headerName));
continue;
} catch (JMSException ignore) {
}
try {
map.put(headerName, message.getDoubleProperty(headerName));
continue;
} catch (JMSException ignore) {
}
try {
map.put(headerName, message.getFloatProperty(headerName));
} catch (JMSException ignore) {
}
}
}
return map;
}
/**
* Create a MessageConsumer for the given Destination
*
* @param session JMS Session to use
* @param dest Destination for which the Consumer is to be created
* @param messageSelector the message selector to be used if any
* @return a MessageConsumer for the specified Destination
* @throws javax.jms.JMSException
*/
public static MessageConsumer createConsumer(Session session, Destination dest,
String messageSelector)
throws JMSException {
if (dest instanceof Queue) {
return ((QueueSession) session).createReceiver((Queue) dest, messageSelector);
} else {
return ((TopicSession) session).createSubscriber((Topic) dest, messageSelector, false);
}
}
/**
* Create a temp queue or topic for synchronous receipt of responses, when a reply destination
* is not specified
*
* @param session the JMS Session to use
* @return a temporary Queue or Topic, depending on the session
* @throws javax.jms.JMSException
*/
public static Destination createTemporaryDestination(Session session) throws JMSException {
if (session instanceof QueueSession) {
return session.createTemporaryQueue();
} else {
return session.createTemporaryTopic();
}
}
public static <T> T lookup(Context context, Class<T> clazz, String name)
throws NamingException {
Object object = context.lookup(name);
try {
return clazz.cast(object);
} catch (ClassCastException ex) {
// Instead of a ClassCastException, throw an exception with some
// more information.
if (object instanceof Reference) {
Reference ref = (Reference) object;
handleException("JNDI failed to de-reference Reference with name " +
name + "; is the factory " + ref.getFactoryClassName() +
" in your classpath?");
return null;
} else {
handleException("JNDI lookup of name " + name + " returned a " +
object.getClass().getName() + " while a " + clazz + " was expected");
return null;
}
}
}
/**
* This is a JMS spec independent method to create a Connection. Please be cautious when
* making any changes
*
* @param conFac the ConnectionFactory to use
* @param user optional user name
* @param pass optional password
* @param jmsSpec11 should we use JMS 1.1 API ?
* @param isQueue is this to deal with a Queue?
* @return a JMS Connection as requested
* @throws javax.jms.JMSException on errors, to be handled and logged by the caller
*/
public static Connection createConnection(ConnectionFactory conFac,
String user, String pass, boolean jmsSpec11,
Boolean isQueue,
boolean isDurable, String clientID)
throws JMSException {
Connection connection = null;
if (log.isDebugEnabled()) {
log.debug("Creating a " + (isQueue ? "Queue" : "Topic") +
"Connection using credentials : (" + user + "/" + pass + ")");
}
if (jmsSpec11 || isQueue == null) {
if (user != null && pass != null) {
connection = conFac.createConnection(user, pass);
} else {
connection = conFac.createConnection();
}
if (isDurable) {
connection.setClientID(clientID);
}
} else {
QueueConnectionFactory qConFac = null;
TopicConnectionFactory tConFac = null;
if (isQueue) {
qConFac = (QueueConnectionFactory) conFac;
} else {
tConFac = (TopicConnectionFactory) conFac;
}
if (user != null && pass != null) {
if (qConFac != null) {
connection = qConFac.createQueueConnection(user, pass);
} else if (tConFac != null) {
connection = tConFac.createTopicConnection(user, pass);
}
} else {
if (qConFac != null) {
connection = qConFac.createQueueConnection();
} else if (tConFac != null) {
connection = tConFac.createTopicConnection();
}
}
if (isDurable) {
connection.setClientID(clientID);
}
}
return connection;
}
/**
* This is a JMS spec independent method to create a Session. Please be cautious when
* making any changes
*
* @param connection the JMS Connection
* @param transacted should the session be transacted?
* @param ackMode the ACK mode for the session
* @param jmsSpec11 should we use the JMS 1.1 API?
* @param isQueue is this Session to deal with a Queue?
* @return a Session created for the given information
* @throws javax.jms.JMSException on errors, to be handled and logged by the caller
*/
public static Session createSession(Connection connection, boolean transacted, int ackMode,
boolean jmsSpec11, Boolean isQueue) throws JMSException {
if (jmsSpec11 || isQueue == null) {
return connection.createSession(transacted, ackMode);
} else {
if (isQueue) {
return ((QueueConnection) connection).createQueueSession(transacted, ackMode);
} else {
return ((TopicConnection) connection).createTopicSession(transacted, ackMode);
}
}
}
/**
* This is a JMS spec independent method to create a MessageConsumer. Please be cautious when
* making any changes
*
* @param session JMS session
* @param destination the Destination
* @param isQueue is the Destination a queue?
* @param subscriberName optional client name to use for a durable subscription to a topic
* @param messageSelector optional message selector
* @param pubSubNoLocal should we receive messages sent by us during pub-sub?
* @param isDurable is this a durable topic subscription?
* @param jmsSpec11 should we use JMS 1.1 API ?
* @return a MessageConsumer to receive messages
* @throws javax.jms.JMSException on errors, to be handled and logged by the caller
*/
public static MessageConsumer createConsumer(
Session session, Destination destination, Boolean isQueue,
String subscriberName, String messageSelector, boolean pubSubNoLocal,
boolean isDurable, boolean jmsSpec11) throws JMSException {
if (jmsSpec11 || isQueue == null) {
if (isDurable) {
return session.createDurableSubscriber(
(Topic) destination, subscriberName, messageSelector, pubSubNoLocal);
} else {
return session.createConsumer(destination, messageSelector, pubSubNoLocal);
}
} else {
if (isQueue) {
return ((QueueSession) session).createReceiver((Queue) destination, messageSelector);
} else {
if (isDurable) {
return ((TopicSession) session).createDurableSubscriber(
(Topic) destination, subscriberName, messageSelector, pubSubNoLocal);
} else {
return ((TopicSession) session).createSubscriber(
(Topic) destination, messageSelector, pubSubNoLocal);
}
}
}
}
/**
* This is a JMS spec independent method to create a MessageProducer. Please be cautious when
* making any changes
*
* @param session JMS session
* @param destination the Destination
* @param isQueue is the Destination a queue?
* @param jmsSpec11 should we use JMS 1.1 API ?
* @return a MessageProducer to send messages to the given Destination
* @throws javax.jms.JMSException on errors, to be handled and logged by the caller
*/
public static MessageProducer createProducer(
Session session, Destination destination, Boolean isQueue, boolean jmsSpec11)
throws JMSException {
if (jmsSpec11 || isQueue == null) {
return session.createProducer(destination);
} else {
if (isQueue) {
return ((QueueSession) session).createSender((Queue) destination);
} else {
return ((TopicSession) session).createPublisher((Topic) destination);
}
}
}
/**
* Return a String representation of the destination type
*
* @param destType the destination type indicator int
* @return a descriptive String
*/
public static String getDestinationTypeAsString(int destType) {
if (destType == JMSConstants.QUEUE) {
return "queue";
} else if (destType == JMSConstants.TOPIC) {
return "topic";
} else {
return "generic";
}
}
/**
* Return the JMS destination with the given destination name looked up from the context
*
* @param context the Context to lookup
* @param destinationName name of the destination to be looked up
* @param destinationType type of the destination to be looked up
* @return the JMS destination, or null if it does not exist
*/
public static Destination lookupDestination(Context context, String destinationName,
String destinationType) throws NamingException {
if (destinationName == null) {
return null;
}
try {
return JMSUtils.lookup(context, Destination.class, destinationName);
} catch (NameNotFoundException e) {
try {
return JMSUtils.lookup(context, Destination.class,
(JMSConstants.DESTINATION_TYPE_TOPIC.equalsIgnoreCase(destinationType) ?
"dynamicTopics/" : "dynamicQueues/") + destinationName);
} catch (NamingException x) {
log.warn("Cannot locate destination : " + destinationName);
throw x;
}
} catch (NamingException e) {
log.warn("Cannot locate destination : " + destinationName, e);
throw e;
}
}
}