/*
* Copyright 2004,2005 The Apache Software Foundation.
*
* Licensed 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.apache.axis2.transport.jms;
import org.apache.axis2.transport.OutTransportInfo;
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.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
/**
* The JMS OutTransportInfo is a holder of information to send an outgoing message
* (e.g. a Response) to a JMS destination. Thus at a minimum a reference to a
* ConnectionFactory and a Destination are held
*/
public class JMSOutTransportInfo implements OutTransportInfo {
private static final Log log = LogFactory.getLog(JMSOutTransportInfo.class);
/** The naming context */
private Context context;
/**
* this is a reference to the underlying JMS ConnectionFactory when sending messages
* through connection factories not defined at the TransportSender level
*/
private ConnectionFactory connectionFactory = null;
/**
* this is a reference to a JMS Connection Factory instance, which has a reference
* to the underlying actual connection factory, an open connection to the JMS provider
* and optionally a session already available for use
*/
private JMSConnectionFactory jmsConnectionFactory = null;
/** the Destination queue or topic for the outgoing message */
private Destination destination = null;
/** the Destination queue or topic for the outgoing message
* i.e. JMSConstants.DESTINATION_TYPE_QUEUE, DESTINATION_TYPE_TOPIC or DESTINATION_TYPE_GENERIC
*/
private String destinationType = JMSConstants.DESTINATION_TYPE_GENERIC;
/** the Reply Destination queue or topic for the outgoing message */
private Destination replyDestination = null;
/** the Reply Destination name */
private String replyDestinationName = null;
/** the Reply Destination queue or topic for the outgoing message
* i.e. JMSConstants.DESTINATION_TYPE_QUEUE, DESTINATION_TYPE_TOPIC or DESTINATION_TYPE_GENERIC
*/
private String replyDestinationType = JMSConstants.DESTINATION_TYPE_GENERIC;
/** the EPR properties when the out-transport info is generated from a target EPR */
private Hashtable<String,String> properties = null;
/** the target EPR string where applicable */
private String targetEPR = null;
/** the message property name that stores the content type of the outgoing message */
private String contentTypeProperty;
/**
* Creates an instance using the given JMS connection factory and destination
*
* @param jmsConnectionFactory the JMS connection factory
* @param dest the destination
* @param contentTypeProperty the content type
*/
JMSOutTransportInfo(JMSConnectionFactory jmsConnectionFactory, Destination dest,
String contentTypeProperty) {
this.jmsConnectionFactory = jmsConnectionFactory;
this.destination = dest;
destinationType = dest instanceof Topic ? JMSConstants.DESTINATION_TYPE_TOPIC
: JMSConstants.DESTINATION_TYPE_QUEUE;
this.contentTypeProperty = contentTypeProperty;
}
/**
* Creates and instance using the given URL
*
* @param targetEPR the target EPR
*/
JMSOutTransportInfo(String targetEPR) {
this.targetEPR = targetEPR;
if (!targetEPR.startsWith(JMSConstants.JMS_PREFIX)) {
handleException("Invalid prefix for a JMS EPR : " + targetEPR);
} else {
properties = BaseUtils.getEPRProperties(targetEPR);
String destinationType = properties.get(JMSConstants.PARAM_DEST_TYPE);
if (destinationType != null) {
setDestinationType(destinationType);
}
String replyDestinationType = properties.get(JMSConstants.PARAM_REPLY_DEST_TYPE);
if (replyDestinationType != null) {
setReplyDestinationType(replyDestinationType);
}
replyDestinationName = properties.get(JMSConstants.PARAM_REPLY_DESTINATION);
contentTypeProperty = properties.get(JMSConstants.CONTENT_TYPE_PROPERTY_PARAM);
try {
context = new InitialContext(properties);
} catch (NamingException e) {
handleException("Could not get an initial context using " + properties, e);
}
destination = getDestination(context, targetEPR);
replyDestination = getReplyDestination(context, targetEPR);
}
}
/**
* Provides a lazy load when created with a target EPR. This method performs actual
* lookup for the connection factory and destination
*/
public void loadConnectionFactoryFromProperies() {
if (properties != null) {
connectionFactory = getConnectionFactory(context, properties);
}
}
/**
* Get the referenced ConnectionFactory using the properties from the context
*
* @param context the context to use for lookup
* @param props the properties which contains the JNDI name of the factory
* @return the connection factory
*/
private ConnectionFactory getConnectionFactory(Context context, Hashtable<String,String> props) {
try {
String conFacJndiName = props.get(JMSConstants.PARAM_CONFAC_JNDI_NAME);
if (conFacJndiName != null) {
return JMSUtils.lookup(context, ConnectionFactory.class, conFacJndiName);
} else {
handleException("Connection Factory JNDI name cannot be determined");
}
} catch (NamingException e) {
handleException("Failed to look up connection factory from JNDI", e);
}
return null;
}
/**
* Get the JMS destination specified by the given URL from the context
*
* @param context the Context to lookup
* @param url URL
* @return the JMS destination, or null if it does not exist
*/
private Destination getDestination(Context context, String url) {
String destinationName = JMSUtils.getDestination(url);
if (log.isDebugEnabled()) {
log.debug("Lookup the JMS destination " + destinationName + " of type "
+ destinationType + " extracted from the URL " + url);
}
try {
return JMSUtils.lookupDestination(context, destinationName, destinationType);
} catch (NamingException e) {
handleException("Couldn't locate the JMS destination " + destinationName
+ " of type " + destinationType + " extracted from the URL " + url, e);
}
// never executes but keeps the compiler happy
return null;
}
/**
* Get the JMS reply destination specified by the given URL from the context
*
* @param context the Context to lookup
* @param url URL
* @return the JMS destination, or null if it does not exist
*/
private Destination getReplyDestination(Context context, String url) {
String replyDestinationName = properties.get(JMSConstants.PARAM_REPLY_DESTINATION);
if (log.isDebugEnabled()) {
log.debug("Lookup the JMS destination " + replyDestinationName + " of type "
+ replyDestinationType + " extracted from the URL " + url);
}
try {
return JMSUtils.lookupDestination(context, replyDestinationName, replyDestinationType);
} catch (NamingException e) {
handleException("Couldn't locate the JMS destination " + replyDestinationName
+ " of type " + replyDestinationType + " extracted from the URL " + url, e);
}
// never executes but keeps the compiler happy
return null;
}
/**
* Look up for the given destination
* @param replyDest the JNDI name to lookup Destination required
* @return Destination for the JNDI name passed
*/
public Destination getReplyDestination(String replyDest) {
if (log.isDebugEnabled()) {
log.debug("Lookup the JMS destination " + replyDest + " of type "
+ replyDestinationType);
}
try {
return JMSUtils.lookupDestination(
jmsConnectionFactory.getContext(), replyDest, replyDestinationType);
} catch (NamingException e) {
handleException("Couldn't locate the JMS destination " + replyDest
+ " of type " + replyDestinationType, e);
}
// never executes but keeps the compiler happy
return null;
}
private void handleException(String s) {
log.error(s);
throw new AxisJMSException(s);
}
private void handleException(String s, Exception e) {
log.error(s, e);
throw new AxisJMSException(s, e);
}
public Destination getDestination() {
return destination;
}
public ConnectionFactory getConnectionFactory() {
return connectionFactory;
}
public JMSConnectionFactory getJmsConnectionFactory() {
return jmsConnectionFactory;
}
public void setContentType(String contentType) {
// this is a useless Axis2 method imposed by the OutTransportInfo interface :(
}
public Hashtable<String,String> getProperties() {
return properties;
}
public String getTargetEPR() {
return targetEPR;
}
public String getDestinationType() {
return destinationType;
}
public void setDestinationType(String destinationType) {
if (destinationType != null) {
this.destinationType = destinationType;
}
}
public Destination getReplyDestination() {
return replyDestination;
}
public void setReplyDestination(Destination replyDestination) {
this.replyDestination = replyDestination;
}
public String getReplyDestinationType() {
return replyDestinationType;
}
public void setReplyDestinationType(String replyDestinationType) {
this.replyDestinationType = replyDestinationType;
}
public String getReplyDestinationName() {
return replyDestinationName;
}
public void setReplyDestinationName(String replyDestinationName) {
this.replyDestinationName = replyDestinationName;
}
public String getContentTypeProperty() {
return contentTypeProperty;
}
public void setContentTypeProperty(String contentTypeProperty) {
this.contentTypeProperty = contentTypeProperty;
}
/**
* Create a one time MessageProducer for this JMS OutTransport information.
* For simplicity and best compatibility, this method uses only JMS 1.0.2b API.
* Please be cautious when making any changes
*
* @return a JMSSender based on one-time use resources
* @throws JMSException on errors, to be handled and logged by the caller
*/
public JMSMessageSender createJMSSender() throws JMSException {
// digest the targetAddress and locate CF from the EPR
loadConnectionFactoryFromProperies();
// create a one time connection and session to be used
String user = properties != null ? properties.get(JMSConstants.PARAM_JMS_USERNAME) : null;
String pass = properties != null ? properties.get(JMSConstants.PARAM_JMS_PASSWORD) : null;
QueueConnectionFactory qConFac = null;
TopicConnectionFactory tConFac = null;
int destType = -1;
// TODO: there is something missing here for destination type generic
if (JMSConstants.DESTINATION_TYPE_QUEUE.equals(destinationType)) {
destType = JMSConstants.QUEUE;
qConFac = (QueueConnectionFactory) connectionFactory;
} else if (JMSConstants.DESTINATION_TYPE_TOPIC.equals(destinationType)) {
destType = JMSConstants.TOPIC;
tConFac = (TopicConnectionFactory) connectionFactory;
} else{
//treat jmsdestination type=queue(default is queue)
destType = JMSConstants.QUEUE;
qConFac = (QueueConnectionFactory) connectionFactory;
}
Connection connection = null;
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 (connection == null) {
connection = jmsConnectionFactory != null ? jmsConnectionFactory.getConnection() : null;
}
Session session = null;
MessageProducer producer = null;
if (connection != null) {
if (destType == JMSConstants.QUEUE) {
session = ((QueueConnection) connection).
createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
producer = ((QueueSession) session).createSender((Queue) destination);
} else {
session = ((TopicConnection) connection).
createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
producer = ((TopicSession) session).createPublisher((Topic) destination);
}
}
return new JMSMessageSender(
connection,
session,
producer,
destination,
jmsConnectionFactory == null ?
JMSConstants.CACHE_NONE : jmsConnectionFactory.getCacheLevel(),
false,
destType == -1 ?
null : destType == JMSConstants.QUEUE ? Boolean.TRUE : Boolean.FALSE
);
}
}