Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF 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.apache.axis2.transport.jms; import org.apache.axis2.transport.base.BaseConstants; import org.apache.axis2.transport.base.threads.WorkerPool; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.jms.*; import javax.jms.IllegalStateException; import javax.naming.InitialContext; import javax.naming.Context; import javax.naming.NamingException; import javax.transaction.UserTransaction; import javax.transaction.NotSupportedException; import javax.transaction.SystemException; import javax.transaction.Status; import java.util.*; import java.util.concurrent.atomic.AtomicInteger; /** * Each service will have one ServiceTaskManager instance that will create, manage and also destroy * idle tasks created for it, for message receipt. This will also allow individual tasks to cache * the Connection, Session or Consumer as necessary, considering the transactionality required and * user preference. * * This also acts as the ExceptionListener for all JMS connections made on behalf of the service. * Since the ExceptionListener is notified by a JMS provider on a "serious" error, we simply try * to re-connect. Thus a connection failure for a single task, will re-initialize the state afresh * for the service, by discarding all connections. */ public class ServiceTaskManager { /** The logger */ private static final Log log = LogFactory.getLog(ServiceTaskManager.class); /** The Task manager is stopped or has not started */ private static final int STATE_STOPPED = 0; /** The Task manager is started and active */ private static final int STATE_STARTED = 1; /** The Task manager is paused temporarily */ private static final int STATE_PAUSED = 2; /** The Task manager is started, but a shutdown has been requested */ private static final int STATE_SHUTTING_DOWN = 3; /** The Task manager has encountered an error */ private static final int STATE_FAILURE = 4; /** The name of the service managed by this instance */ private String serviceName; /** The ConnectionFactory MUST refer to an XAConnectionFactory to use JTA */ private String connFactoryJNDIName; /** The JNDI name of the Destination Queue or Topic */ // TODO: this overlaps with JMSEndpoint#jndiDestinationName; needs to be clarified private String destinationJNDIName; /** JNDI location for the JTA UserTransaction */ private String userTransactionJNDIName = "java:comp/UserTransaction"; /** The type of destination - P2P or PubSub (or JMS 1.1 API generic?) */ // TODO: this overlaps with JMSEndpoint#destinationType; needs to be clarified private int destinationType = JMSConstants.GENERIC; /** An optional message selector */ private String messageSelector = null; /** Should tasks run without transactions, using transacted Sessions (i.e. local), or JTA */ private int transactionality = BaseConstants.TRANSACTION_NONE; /** Should created Sessions be transactional ? - should be false when using JTA */ private boolean sessionTransacted = true; /** Session acknowledgement mode when transacted Sessions (i.e. local transactions) are used */ private int sessionAckMode = Session.AUTO_ACKNOWLEDGE; /** Is the subscription durable ? */ private boolean subscriptionDurable = false; /** The name of the durable subscriber for this client */ private String durableSubscriberName = null; /** In PubSub mode, should I receive messages sent by me / my connection ? */ private boolean pubSubNoLocal = false; /** Number of concurrent consumers - for PubSub, this should be 1 to prevent multiple receipt */ private int concurrentConsumers = 1; /** Maximum number of consumers to create - see @concurrentConsumers */ private int maxConcurrentConsumers = 1; /** The number of idle (i.e. message-less) attempts to be tried before suicide, to scale down */ private int idleTaskExecutionLimit = 10; /** The maximum number of successful message receipts for a task - to limit thread life span */ private int maxMessagesPerTask = -1; // default is unlimited /** The default receive timeout - a negative value means wait forever, zero dont wait at all */ private int receiveTimeout = 1000; /** JMS Resource cache level - Connection, Session, Consumer. Auto will select safe default */ private int cacheLevel = JMSConstants.CACHE_AUTO; /** Should we cache the UserTransaction handle from JNDI - true for almost all app servers */ private boolean cacheUserTransaction = true; /** Shared UserTransactionHandle */ private UserTransaction sharedUserTransaction = null; /** Should this service use JMS 1.1 ? (when false, defaults to 1.0.2b) */ private boolean jmsSpec11 = true; /** Initial duration to attempt re-connection to JMS provider after failure */ private int initialReconnectDuration = 10000; /** Progression factory for geometric series that calculates re-connection times */ private double reconnectionProgressionFactor = 2.0; // default to [bounded] exponential /** Upper limit on reconnection attempt duration */ private long maxReconnectDuration = 1000 * 60 * 60; // 1 hour /** The JNDI context properties and other general properties */ private Hashtable<String, String> jmsProperties = new Hashtable<String, String>(); /** The JNDI Context acuired */ private Context context = null; /** The ConnectionFactory to be used */ private ConnectionFactory conFactory = null; /** The JMS Destination */ private Destination destination = null; /** The list of active tasks thats managed by this instance */ private final List<MessageListenerTask> pollingTasks = Collections .synchronizedList(new ArrayList<MessageListenerTask>()); /** The per-service JMS message receiver to be invoked after receipt of messages */ private JMSMessageReceiver jmsMessageReceiver = null; /** State of this Task Manager */ private volatile int serviceTaskManagerState = STATE_STOPPED; /** Number of invoker tasks active */ private volatile int activeTaskCount = 0; /** The number of existing JMS message consumers. */ private final AtomicInteger consumerCount = new AtomicInteger(); /** The shared thread pool from the Listener */ private WorkerPool workerPool = null; /** The JMS Connection shared between multiple polling tasks - when enabled (reccomended) */ private Connection sharedConnection = null; /** Is this error triggers a JMS onException ?*/ private volatile boolean isOnExceptionError = false; /** * Start or re-start the Task Manager by shutting down any existing worker tasks and * re-creating them. However, if this is STM is PAUSED, a start request is ignored. * This applies for any connection failures during paused state as well, which then will * not try to auto recover */ public synchronized void start() { if (serviceTaskManagerState == STATE_PAUSED) { log.info("Attempt to re-start paused TaskManager is ignored. Please use resume instead"); return; } // if any tasks are running, stop whats running now if (!pollingTasks.isEmpty()) { stop(); } if (cacheLevel == JMSConstants.CACHE_AUTO) { cacheLevel = transactionality == BaseConstants.TRANSACTION_NONE ? JMSConstants.CACHE_CONSUMER : JMSConstants.CACHE_NONE; } switch (cacheLevel) { case JMSConstants.CACHE_NONE: log.debug("No JMS resources will be cached/shared between poller " + "worker tasks of service : " + serviceName); break; case JMSConstants.CACHE_CONNECTION: log.debug( "Only the JMS Connection will be cached and shared between *all* " + "poller task invocations"); break; case JMSConstants.CACHE_SESSION: log.debug("The JMS Connection and Session will be cached and shared between " + "successive poller task invocations"); break; case JMSConstants.CACHE_CONSUMER: log.debug("The JMS Connection, Session and MessageConsumer will be cached and " + "shared between successive poller task invocations"); break; default: { handleException("Invalid cache level : " + cacheLevel + " for service : " + serviceName); } } for (int i = 0; i < concurrentConsumers; i++) { workerPool.execute(new MessageListenerTask()); } serviceTaskManagerState = STATE_STARTED; log.info("Task manager for service : " + serviceName + " [re-]initialized"); } /** * Shutdown the tasks and release any shared resources */ public synchronized void stop() { if (log.isDebugEnabled()) { log.debug("Stopping ServiceTaskManager for service : " + serviceName); } if (serviceTaskManagerState != STATE_FAILURE) { serviceTaskManagerState = STATE_SHUTTING_DOWN; } synchronized (pollingTasks) { for (MessageListenerTask lstTask : pollingTasks) { lstTask.requestShutdown(); } } // try to wait a bit for task shutdown for (int i = 0; i < 5; i++) { if (activeTaskCount == 0) { break; } try { Thread.sleep(1000); } catch (InterruptedException ignore) { } } if (sharedConnection != null) { try { sharedConnection.close(); } catch (JMSException e) { logError("Error closing shared Connection", e); } finally { sharedConnection = null; } } if (activeTaskCount > 0) { log.warn("Unable to shutdown all polling tasks of service : " + serviceName); } if (serviceTaskManagerState != STATE_FAILURE) { serviceTaskManagerState = STATE_STOPPED; } log.info("Task manager for service : " + serviceName + " shutdown"); } /** * Temporarily suspend receipt and processing of messages. Accomplished by stopping the * connection / or connections used by the poller tasks */ public synchronized void pause() { for (MessageListenerTask lstTask : pollingTasks) { lstTask.pause(); } if (sharedConnection != null) { try { sharedConnection.stop(); } catch (JMSException e) { logError("Error pausing shared Connection", e); } } } /** * Resume receipt and processing of messages of paused tasks */ public synchronized void resume() { for (MessageListenerTask lstTask : pollingTasks) { lstTask.resume(); } if (sharedConnection != null) { try { sharedConnection.start(); } catch (JMSException e) { logError("Error resuming shared Connection", e); } } } /** * Start a new MessageListenerTask if we are still active, the threshold is not reached, and w * e do not have any idle tasks - i.e. scale up listening */ private void scheduleNewTaskIfAppropriate() { if (serviceTaskManagerState == STATE_STARTED && pollingTasks.size() < getMaxConcurrentConsumers() && getIdleTaskCount() == 0) { workerPool.execute(new MessageListenerTask()); } } /** * Get the number of MessageListenerTasks that are currently idle * @return idle task count */ private int getIdleTaskCount() { int count = 0; for (MessageListenerTask lstTask : pollingTasks) { if (lstTask.isTaskIdle()) { count++; } } return count; } /** * Get the number of MessageListenerTasks that are currently connected to the JMS provider * @return connected task count */ private int getConnectedTaskCount() { int count = 0; for (MessageListenerTask lstTask : pollingTasks) { if (lstTask.isConnected()) { count++; } } return count; } /** * The actual threads/tasks that perform message polling */ private class MessageListenerTask implements Runnable, ExceptionListener { /** The Connection used by the polling task */ private Connection connection = null; /** The Sesson used by the polling task */ private Session session = null; /** The MessageConsumer used by the polling task */ private MessageConsumer consumer = null; /** State of the worker polling task */ private volatile int workerState = STATE_STOPPED; /** The number of idle (i.e. without fetching a message) polls for this task */ private int idleExecutionCount = 0; /** Is this task idle right now? */ private volatile boolean idle = false; /** Is this task connected to the JMS provider successfully? */ private volatile boolean connected = false; /** As soon as we create a new polling task, add it to the STM for control later */ MessageListenerTask() { synchronized (pollingTasks) { pollingTasks.add(this); } } /** * Pause this polling worker task */ public void pause() { if (isActive()) { if (connection != null && cacheLevel < JMSConstants.CACHE_CONNECTION) { try { connection.stop(); } catch (JMSException e) { log.warn("Error pausing Message Listener task for service : " + serviceName); } } workerState = STATE_PAUSED; } } /** * Resume this polling task */ public void resume() { if (connection != null && cacheLevel < JMSConstants.CACHE_CONNECTION) { try { connection.start(); } catch (JMSException e) { log.warn("Error resuming Message Listener task for service : " + serviceName); } } workerState = STATE_STARTED; } /** * Execute the polling worker task */ public void run() { workerState = STATE_STARTED; activeTaskCount++; int messageCount = 0; if (log.isDebugEnabled()) { log.debug("New poll task starting : thread id = " + Thread.currentThread().getId()); } try { while (isActive() && (getMaxMessagesPerTask() < 0 || messageCount < getMaxMessagesPerTask()) && (getConcurrentConsumers() == 1 || idleExecutionCount < getIdleTaskExecutionLimit())) { UserTransaction ut = null; try { if (transactionality == BaseConstants.TRANSACTION_JTA) { ut = getUserTransaction(); // We will only create a new tx if there is no tx alive if (ut.getStatus() == Status.STATUS_NO_TRANSACTION) { ut.begin(); } } } catch (NotSupportedException e) { handleException("Listener Task is already associated with a transaction", e); } catch (SystemException e) { handleException("Error starting a JTA transaction", e); } // Get a message by polling, or receive null Message message = receiveMessage(); if (log.isTraceEnabled()) { if (message != null) { try { log.trace("<<<<<<< READ message with Message ID : " + message.getJMSMessageID() + " from : " + destination + " by Thread ID : " + Thread.currentThread().getId()); } catch (JMSException ignore) { } } else { log.trace("No message received by Thread ID : " + Thread.currentThread().getId() + " for destination : " + destination); } } if (message != null) { idle = false; idleExecutionCount = 0; messageCount++; // I will be busy now while processing this message, so start another if needed scheduleNewTaskIfAppropriate(); handleMessage(message, ut); } else { idle = true; idleExecutionCount++; } } } finally { if (log.isTraceEnabled()) { log.trace("Listener task with Thread ID : " + Thread.currentThread().getId() + " is stopping after processing : " + messageCount + " messages :: " + " isActive : " + isActive() + " maxMessagesPerTask : " + getMaxMessagesPerTask() + " concurrentConsumers : " + getConcurrentConsumers() + " idleExecutionCount : " + idleExecutionCount + " idleTaskExecutionLimit : " + getIdleTaskExecutionLimit()); } else if (log.isDebugEnabled()) { log.debug("Listener task with Thread ID : " + Thread.currentThread().getId() + " is stopping after processing : " + messageCount + " messages"); } // Close the consumer and session before decrementing activeTaskCount. // (If we have a shared connection, Qpid deadlocks if the shared connection // is closed on another thread while closing the session) closeConsumer(true); closeSession(true); closeConnection(); workerState = STATE_STOPPED; activeTaskCount--; synchronized (pollingTasks) { pollingTasks.remove(this); } // if this is a JMS onException, ServiceTaskManager#onException will schedule // a new polling task if (!isOnExceptionError) { // My time is up, so if I am going away, create another scheduleNewTaskIfAppropriate(); } } } /** * Poll for and return a message if available * * @return a message read, or null */ private Message receiveMessage() { // get a new connection, session and consumer to prevent a conflict. // If idle, it means we can re-use what we already have if (consumer == null) { connection = getConnection(); session = getSession(); consumer = getMessageConsumer(); if (log.isDebugEnabled()) { log.debug("Preparing a Connection, Session and Consumer to read messages"); } } if (log.isDebugEnabled()) { log.debug("Waiting for a message for service : " + serviceName + " - duration : " + (getReceiveTimeout() < 0 ? "unlimited" : (getReceiveTimeout() + "ms"))); } try { if (getReceiveTimeout() < 0) { return consumer.receive(); } else { return consumer.receive(getReceiveTimeout()); } } catch (IllegalStateException ignore) { // probably the consumer (shared) was closed.. which is still ok.. as we didn't read } catch (JMSException e) { logError("Error receiving message for service : " + serviceName, e); } return null; } /** * Invoke ultimate message handler/listener and ack message and/or * commit/rollback transactions * @param message the JMS message received * @param ut the UserTransaction used to receive this message, or null */ private void handleMessage(Message message, UserTransaction ut) { String messageId = null; try { messageId = message.getJMSMessageID(); } catch (JMSException ignore) { } boolean commitOrAck = true; try { commitOrAck = jmsMessageReceiver.onMessage(message, ut); } finally { // if client acknowledgement is selected, and processing requested ACK if (commitOrAck && getSessionAckMode() == Session.CLIENT_ACKNOWLEDGE) { try { message.acknowledge(); if (log.isDebugEnabled()) { log.debug("Message : " + messageId + " acknowledged"); } } catch (JMSException e) { logError("Error acknowledging message : " + messageId, e); } } // if session was transacted, commit it or rollback try { if (session.getTransacted()) { if (commitOrAck) { session.commit(); if (log.isDebugEnabled()) { log.debug("Session for message : " + messageId + " committed"); } } else { session.rollback(); if (log.isDebugEnabled()) { log.debug("Session for message : " + messageId + " rolled back"); } } } } catch (JMSException e) { logError("Error " + (commitOrAck ? "committing" : "rolling back") + " local session txn for message : " + messageId, e); } // if a JTA transaction was being used, commit it or rollback try { if (ut != null) { if (commitOrAck) { ut.commit(); if (log.isDebugEnabled()) { log.debug("JTA txn for message : " + messageId + " committed"); } } else { ut.rollback(); if (log.isDebugEnabled()) { log.debug("JTA txn for message : " + messageId + " rolled back"); } } } } catch (Exception e) { logError("Error " + (commitOrAck ? "committing" : "rolling back") + " JTA txn for message : " + messageId + " from the session", e); } // close the consumer closeConsumer(false); closeSession(false); closeConnection(); } } /** Handle JMS Connection exceptions by re-initializing. A single connection failure could * cause re-initialization of multiple MessageListenerTasks / Connections */ public void onException(JMSException j) { isOnExceptionError = true; if (!isSTMActive()) { requestShutdown(); return; } log.warn("JMS Connection failure : " + j.getMessage()); setConnected(false); if (cacheLevel < JMSConstants.CACHE_CONNECTION) { // failed Connection was not shared, thus no need to restart the whole STM requestShutdown(); return; } // if we failed while active, update state to show failure setServiceTaskManagerState(STATE_FAILURE); log.error("JMS Connection failed : " + j.getMessage() + " - shutting down worker tasks"); int r = 1; long retryDuration = initialReconnectDuration; do { try { log.info("Reconnection attempt : " + r + " for service : " + serviceName); start(); } catch (Exception ignore) { } boolean connected = false; for (int i = 0; i < 5; i++) { if (getConnectedTaskCount() == concurrentConsumers) { connected = true; break; } try { Thread.sleep(1000); } catch (InterruptedException ignore) { } } if (!connected) { retryDuration = (long) (retryDuration * reconnectionProgressionFactor); log.error("Reconnection attempt : " + (r++) + " for service : " + serviceName + " failed. Next retry in " + (retryDuration / 1000) + "seconds"); if (retryDuration > maxReconnectDuration) { retryDuration = maxReconnectDuration; } try { Thread.sleep(retryDuration); } catch (InterruptedException ignore) { } } else { isOnExceptionError = false; log.info("Reconnection attempt: " + r + " for service: " + serviceName + " was successful!"); } } while (!isSTMActive() || getConnectedTaskCount() < concurrentConsumers); } protected void requestShutdown() { workerState = STATE_SHUTTING_DOWN; } private boolean isActive() { return workerState == STATE_STARTED; } protected boolean isTaskIdle() { return idle; } public boolean isConnected() { return connected; } public void setConnected(boolean connected) { this.connected = connected; } /** * Get a Connection that could/should be used by this task - depends on the cache level to reuse * @return the shared Connection if cache level is higher than CACHE_NONE, or a new Connection */ private Connection getConnection() { if (cacheLevel < JMSConstants.CACHE_CONNECTION) { // Connection is not shared if (connection == null) { connection = createConnection(); setConnected(true); } } else if (connection == null) { // Connection is shared, but may not have been created synchronized (ServiceTaskManager.this) { if (sharedConnection == null) { sharedConnection = createConnection(); } } connection = sharedConnection; setConnected(true); } // else: Connection is shared and is already referenced by this.connection return connection; } /** * Get a Session that could/should be used by this task - depends on the cache level to reuse * @param connection the connection (could be the shared connection) to use to create a Session * @return the shared Session if cache level is higher than CACHE_CONNECTION, or a new Session * created using the Connection passed, or a new/shared connection */ private Session getSession() { if (session == null || cacheLevel < JMSConstants.CACHE_SESSION) { session = createSession(); } return session; } /** * Get a MessageConsumer that chould/should be used by this task - depends on the cache * level to reuse * @param connection option Connection to be used * @param session optional Session to be used * @return the shared MessageConsumer if cache level is higher than CACHE_SESSION, or a new * MessageConsumer possibly using the Connection and Session passed in */ private MessageConsumer getMessageConsumer() { if (consumer == null || cacheLevel < JMSConstants.CACHE_CONSUMER) { consumer = createConsumer(); } return consumer; } /** * Close the given Connection, hiding exceptions if any which are logged * @param connection the Connection to be closed */ private void closeConnection() { if (connection != null && cacheLevel < JMSConstants.CACHE_CONNECTION) { try { if (log.isDebugEnabled()) { log.debug("Closing non-shared JMS connection for service : " + serviceName); } connection.close(); } catch (JMSException e) { logError("Error closing JMS connection", e); } finally { connection = null; } } } /** * Close the given Session, hiding exceptions if any which are logged * @param session the Session to be closed */ private void closeSession(boolean forced) { if (session != null && (cacheLevel < JMSConstants.CACHE_SESSION || forced)) { try { if (log.isDebugEnabled()) { log.debug("Closing non-shared JMS session for service : " + serviceName); } session.close(); } catch (JMSException e) { logError("Error closing JMS session", e); } finally { session = null; } } } /** * Close the given Consumer, hiding exceptions if any which are logged * @param consumer the Consumer to be closed */ private void closeConsumer(boolean forced) { if (consumer != null && (cacheLevel < JMSConstants.CACHE_CONSUMER || forced)) { try { if (log.isDebugEnabled()) { log.debug("Closing non-shared JMS consumer for service : " + serviceName); } consumerCount.decrementAndGet(); consumer.close(); } catch (JMSException e) { logError("Error closing JMS consumer", e); } finally { consumer = null; } } } /** * Create a new Connection for this STM, using JNDI properties and credentials provided * @return a new Connection for this STM, using JNDI properties and credentials provided */ private Connection createConnection() { try { conFactory = JMSUtils.lookup(getInitialContext(), ConnectionFactory.class, getConnFactoryJNDIName()); log.debug("Connected to the JMS connection factory : " + getConnFactoryJNDIName()); } catch (NamingException e) { handleException("Error looking up connection factory : " + getConnFactoryJNDIName() + " using JNDI properties : " + jmsProperties, e); } Connection connection = null; try { connection = JMSUtils.createConnection(conFactory, jmsProperties.get(JMSConstants.PARAM_JMS_USERNAME), jmsProperties.get(JMSConstants.PARAM_JMS_PASSWORD), isJmsSpec11(), isQueue()); connection.setExceptionListener(this); connection.start(); log.debug("JMS Connection for service : " + serviceName + " created and started"); } catch (JMSException e) { handleException("Error acquiring a JMS connection to : " + getConnFactoryJNDIName() + " using JNDI properties : " + jmsProperties, e); } return connection; } /** * Create a new Session for this STM * @param connection the Connection to be used * @return a new Session created using the Connection passed in */ private Session createSession() { try { if (log.isDebugEnabled()) { log.debug("Creating a new JMS Session for service : " + serviceName); } return JMSUtils.createSession(connection, isSessionTransacted(), getSessionAckMode(), isJmsSpec11(), isQueue()); } catch (JMSException e) { handleException("Error creating JMS session for service : " + serviceName, e); } return null; } /** * Create a new MessageConsumer for this STM * @param session the Session to be used * @return a new MessageConsumer created using the Session passed in */ private MessageConsumer createConsumer() { try { if (log.isDebugEnabled()) { log.debug("Creating a new JMS MessageConsumer for service : " + serviceName); } MessageConsumer consumer = JMSUtils.createConsumer(session, getDestination(session), isQueue(), (isSubscriptionDurable() && getDurableSubscriberName() == null ? getDurableSubscriberName() : serviceName), getMessageSelector(), isPubSubNoLocal(), isSubscriptionDurable(), isJmsSpec11()); consumerCount.incrementAndGet(); return consumer; } catch (JMSException e) { handleException("Error creating JMS consumer for service : " + serviceName, e); } return null; } } // -------------- mundane private methods ---------------- /** * Get the InitialContext for lookup using the JNDI parameters applicable to the service * @return the InitialContext to be used * @throws NamingException */ private Context getInitialContext() throws NamingException { if (context == null) { context = new InitialContext(jmsProperties); } return context; } /** * Return the JMS Destination for the JNDI name of the Destination from the InitialContext * @param session which is used to create the destinations if not present and if possible * @return the JMS Destination to which this STM listens for messages */ private Destination getDestination(Session session) { if (destination == null) { try { context = getInitialContext(); destination = JMSUtils.lookupDestination(context, getDestinationJNDIName(), JMSUtils.getDestinationTypeAsString(destinationType)); if (log.isDebugEnabled()) { log.debug("JMS Destination with JNDI name : " + getDestinationJNDIName() + " found for service " + serviceName); } } catch (NamingException e) { try { switch (destinationType) { case JMSConstants.QUEUE: { destination = session.createQueue(getDestinationJNDIName()); break; } case JMSConstants.TOPIC: { destination = session.createTopic(getDestinationJNDIName()); break; } default: { handleException("Error looking up JMS destination : " + getDestinationJNDIName() + " using JNDI properties : " + jmsProperties, e); } } } catch (JMSException j) { handleException("Error looking up JMS destination and auto " + "creating JMS destination : " + getDestinationJNDIName() + " using JNDI properties : " + jmsProperties, e); } } } return destination; } /** * The UserTransaction to be used, looked up from the JNDI * @return The UserTransaction to be used, looked up from the JNDI */ private UserTransaction getUserTransaction() { if (!cacheUserTransaction) { if (log.isDebugEnabled()) { log.debug("Acquiring a new UserTransaction for service : " + serviceName); } try { context = getInitialContext(); return JMSUtils.lookup(context, UserTransaction.class, getUserTransactionJNDIName()); } catch (NamingException e) { handleException("Error looking up UserTransaction : " + getUserTransactionJNDIName() + " using JNDI properties : " + jmsProperties, e); } } if (sharedUserTransaction == null) { try { context = getInitialContext(); sharedUserTransaction = JMSUtils.lookup(context, UserTransaction.class, getUserTransactionJNDIName()); if (log.isDebugEnabled()) { log.debug("Acquired shared UserTransaction for service : " + serviceName); } } catch (NamingException e) { handleException("Error looking up UserTransaction : " + getUserTransactionJNDIName() + " using JNDI properties : " + jmsProperties, e); } } return sharedUserTransaction; } // -------------------- trivial methods --------------------- private boolean isSTMActive() { return serviceTaskManagerState == STATE_STARTED; } /** * Is this STM bound to a Queue, Topic or a JMS 1.1 Generic Destination? * @return TRUE for a Queue, FALSE for a Topic and NULL for a Generic Destination */ private Boolean isQueue() { if (destinationType == JMSConstants.GENERIC) { return null; } else { return destinationType == JMSConstants.QUEUE; } } private void logError(String msg, Exception e) { log.error(msg, e); } private void handleException(String msg, Exception e) { log.error(msg, e); throw new AxisJMSException(msg, e); } private void handleException(String msg) { log.error(msg); throw new AxisJMSException(msg); } // -------------- getters and setters ------------------ public String getServiceName() { return serviceName; } public void setServiceName(String serviceName) { this.serviceName = serviceName; } public String getConnFactoryJNDIName() { return connFactoryJNDIName; } public void setConnFactoryJNDIName(String connFactoryJNDIName) { this.connFactoryJNDIName = connFactoryJNDIName; } public String getDestinationJNDIName() { return destinationJNDIName; } public void setDestinationJNDIName(String destinationJNDIName) { this.destinationJNDIName = destinationJNDIName; } public int getDestinationType() { return destinationType; } public void setDestinationType(int destinationType) { this.destinationType = destinationType; } public String getMessageSelector() { return messageSelector; } public void setMessageSelector(String messageSelector) { this.messageSelector = messageSelector; } public int getTransactionality() { return transactionality; } public void setTransactionality(int transactionality) { this.transactionality = transactionality; sessionTransacted = (transactionality == BaseConstants.TRANSACTION_LOCAL); } public boolean isSessionTransacted() { return sessionTransacted; } public void setSessionTransacted(Boolean sessionTransacted) { if (sessionTransacted != null) { this.sessionTransacted = sessionTransacted; // sesstionTransacted means local transactions are used, however !sessionTransacted does // not mean that JTA is used if (sessionTransacted) { transactionality = BaseConstants.TRANSACTION_LOCAL; } } } public int getSessionAckMode() { return sessionAckMode; } public void setSessionAckMode(int sessionAckMode) { this.sessionAckMode = sessionAckMode; } public boolean isSubscriptionDurable() { return subscriptionDurable; } public void setSubscriptionDurable(Boolean subscriptionDurable) { if (subscriptionDurable != null) { this.subscriptionDurable = subscriptionDurable; } } public String getDurableSubscriberName() { return durableSubscriberName; } public void setDurableSubscriberName(String durableSubscriberName) { this.durableSubscriberName = durableSubscriberName; } public boolean isPubSubNoLocal() { return pubSubNoLocal; } public void setPubSubNoLocal(Boolean pubSubNoLocal) { if (pubSubNoLocal != null) { this.pubSubNoLocal = pubSubNoLocal; } } public int getConcurrentConsumers() { return concurrentConsumers; } public void setConcurrentConsumers(int concurrentConsumers) { this.concurrentConsumers = concurrentConsumers; } public int getMaxConcurrentConsumers() { return maxConcurrentConsumers; } public void setMaxConcurrentConsumers(int maxConcurrentConsumers) { this.maxConcurrentConsumers = maxConcurrentConsumers; } public int getIdleTaskExecutionLimit() { return idleTaskExecutionLimit; } public void setIdleTaskExecutionLimit(int idleTaskExecutionLimit) { this.idleTaskExecutionLimit = idleTaskExecutionLimit; } public int getReceiveTimeout() { return receiveTimeout; } public void setReceiveTimeout(int receiveTimeout) { this.receiveTimeout = receiveTimeout; } public int getCacheLevel() { return cacheLevel; } public void setCacheLevel(int cacheLevel) { this.cacheLevel = cacheLevel; } public int getInitialReconnectDuration() { return initialReconnectDuration; } public void setInitialReconnectDuration(int initialReconnectDuration) { this.initialReconnectDuration = initialReconnectDuration; } public double getReconnectionProgressionFactor() { return reconnectionProgressionFactor; } public void setReconnectionProgressionFactor(double reconnectionProgressionFactor) { this.reconnectionProgressionFactor = reconnectionProgressionFactor; } public long getMaxReconnectDuration() { return maxReconnectDuration; } public void setMaxReconnectDuration(long maxReconnectDuration) { this.maxReconnectDuration = maxReconnectDuration; } public int getMaxMessagesPerTask() { return maxMessagesPerTask; } public void setMaxMessagesPerTask(int maxMessagesPerTask) { this.maxMessagesPerTask = maxMessagesPerTask; } public String getUserTransactionJNDIName() { return userTransactionJNDIName; } public void setUserTransactionJNDIName(String userTransactionJNDIName) { if (userTransactionJNDIName != null) { this.userTransactionJNDIName = userTransactionJNDIName; } } public boolean isCacheUserTransaction() { return cacheUserTransaction; } public void setCacheUserTransaction(Boolean cacheUserTransaction) { if (cacheUserTransaction != null) { this.cacheUserTransaction = cacheUserTransaction; } } public boolean isJmsSpec11() { return jmsSpec11; } public void setJmsSpec11(boolean jmsSpec11) { this.jmsSpec11 = jmsSpec11; } public Hashtable<String, String> getJmsProperties() { return jmsProperties; } public void addJmsProperties(Map<String, String> jmsProperties) { this.jmsProperties.putAll(jmsProperties); } public void removeJmsProperties(String key) { this.jmsProperties.remove(key); } public Context getContext() { return context; } public ConnectionFactory getConnectionFactory() { return conFactory; } public List<MessageListenerTask> getPollingTasks() { return pollingTasks; } public void setJmsMessageReceiver(JMSMessageReceiver jmsMessageReceiver) { this.jmsMessageReceiver = jmsMessageReceiver; } public void setWorkerPool(WorkerPool workerPool) { this.workerPool = workerPool; } public int getActiveTaskCount() { return activeTaskCount; } /** * Get the number of existing JMS message consumers. * * @return the number of consumers */ public int getConsumerCount() { return consumerCount.get(); } public void setServiceTaskManagerState(int serviceTaskManagerState) { this.serviceTaskManagerState = serviceTaskManagerState; } }