DefaultHermesImpl.java

/* 
 * Copyright 2003,2004 Colin Crist
 *
 * 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 hermes.impl;

import hermes.Domain;
import hermes.Hermes;
import hermes.HermesAuditLog;
import hermes.HermesDispatcher;
import hermes.HermesException;
import hermes.HermesRuntimeException;
import hermes.ProviderMetaData;
import hermes.browser.HermesBrowser;
import hermes.browser.MessageRenderer;
import hermes.config.DestinationConfig;
import hermes.config.HermesConfig;
import hermes.config.ProviderExtConfig;
import hermes.config.SessionConfig;
import hermes.util.JMSUtils;
import hermes.util.MessageUtils;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

import javax.jms.BytesMessage;
import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageEOFException;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.QueueBrowser;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.Session;
import javax.jms.StreamMessage;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicPublisher;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.swing.ProgressMonitor;

import org.apache.log4j.Logger;

/**
 * Default implementation for the Hermes interface. Its role is to delegate to
 * the SessionManager and implement the reconnection policy.
 * 
 * @author colincrist@hermesjms.com
 * @version $Id: DefaultHermesImpl.java,v 1.18 2004/10/28 21:34:01 colincrist
 *          Exp $
 */

public class DefaultHermesImpl implements Hermes {

	private static final Logger log = Logger.getLogger(DefaultHermesImpl.class);
	private static final String DEFAULT_DISPATCHER = "defaultHermesDispatcher";
	private static final Timer timer = new Timer();

	private XMLHelper xmlSupport = new DefaultXMLHelper();
	private SessionManager sessionManager;
	private ProviderMetaData metaData;
	private Map dispatchers = new HashMap();
	private Map timerMap = new HashMap();
	private DefaultHermesDispatcherImpl defaultDespatcher;
	private ThreadLocal auditLogTL = new ThreadLocal();
	private boolean readOnly = false;
	private final boolean reconnecting = false;
	private ProviderExtConfig extConfig;
	private HermesAdminAdapter adminAdapter;
	private ClassLoader contextClassLoader;

	/**
	 * DefaultHermesImpl constructor with a SessionManager.
	 */
	public DefaultHermesImpl(ProviderExtConfig extConfig, SessionManager sessionManager, ClassLoader contextClassLoader) throws JMSException, IOException {
		super();

		this.extConfig = extConfig;
		this.sessionManager = sessionManager;
		this.defaultDespatcher = _getDispatcher(DEFAULT_DISPATCHER);
		this.contextClassLoader = contextClassLoader;

		try {
			getAdminAdapter();
		} catch (JMSException ex) {
			log.error("cannot bootstrap AdminAdapter: " + ex.getMessage(), ex);
		}
	}

	public void reconnect(String username, String password) throws JMSException {
		sessionManager.reconnect(username, password);
	}

	public SessionConfig getSessionConfig() {
		return sessionManager.getConfig();
	}

	private synchronized HermesAdminAdapter getAdminAdapter() throws JMSException {
		if (adminAdapter == null) {
			adminAdapter = new HermesAdminAdapter(this, sessionManager.getConnectionFactoryManager().getExtension(extConfig));
		}

		return adminAdapter;
	}

	/**
	 * Is this hermes transacted?
	 */
	public boolean getTransacted() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().getTransacted();
	}

	/**
	 * Close any consumer open...
	 */
	public void close(Destination destination, String selector) throws JMSException {
		sessionManager.closeConsumer(destination, selector);
	}

	public void closeConsumer(Destination d) throws JMSException {
		sessionManager.closeConsumer(d, null);
	}

	public Session getSession() throws JMSException {
		return sessionManager.getSession();
	}

	/**
	 * close resources. any reuse of this object will reacquie the resoures.
	 */
	public synchronized void close() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		sessionManager.close();

		if (adminAdapter != null) {
			adminAdapter.close();
		}

		getAuditLog().rollback();
	}

	public synchronized boolean isOpen() {
		return sessionManager.isOpen();
	}

	/**
	 * commit the current transaction.
	 */
	public void commit() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (sessionManager.getSession().getTransacted()) {
			sessionManager.getSession().commit();
		} else {
			log.warn("session " + getId() + " is not transacted");
		}

		try {
			if (isAudit()) {
				getAuditLog().commit();
			}
		} catch (JMSException ex) {
			log.error("cannot log audit during commit: " + ex.getMessage(), ex);
		}
	}

	public QueueBrowser createBrowser(DestinationConfig config) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (config.getDomain() == Domain.TOPIC.getId() && config.isDurable()) {
			return getAdminAdapter().createDurableSubscriptionBrowser(config);
		} else {
			return sessionManager.createBrowser(this, config);
		}
	}

	/**
	 * Create a browser.
	 */
	public QueueBrowser createBrowser(Destination destination) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.createBrowser(this, destination, null);
	}

	/**
	 * Create a browser.
	 */
	public QueueBrowser createBrowser(Destination destination, String selector) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.createBrowser(this, destination, selector);
	}

	/**
	 * createBytesMessage.
	 */
	public final BytesMessage createBytesMessage() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().createBytesMessage();
	}

	/**
	 * createMapMessage.
	 */
	public final MapMessage createMapMessage() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().createMapMessage();
	}

	/**
	 * createObjectMessage.
	 */
	public final ObjectMessage createObjectMessage() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().createObjectMessage();
	}

	/**
	 * createStreamMessage.
	 */
	public final StreamMessage createStreamMessage() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().createStreamMessage();
	}

	/**
	 * createTextMessage.
	 */
	public final TextMessage createTextMessage() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().createTextMessage();
	}

	/**
	 * Create a javax.jms.Message
	 */
	public Message createMessage() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().createMessage();
	}

	/**
	 * createTextMessage.
	 */
	public final TextMessage createTextMessage(String s) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getSession().createTextMessage(s);
	}

	/**
	 * Get the ConnectionFactory associted with this instance.
	 */
	public final javax.jms.ConnectionFactory getConnectionFactory() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getConnectionFactory();
	}

	/**
	 * Get the Connection associated with this Hermes
	 */
	public Connection getConnection() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getConnection();
	}

	/**
	 * Get a JMS destination.
	 */
	public final Destination getDestination(String name, Domain domain) throws JMSException, NamingException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		final DestinationConfig dConfig = getDestinationConfig(name, domain);

		if (dConfig != null) {
			if (dConfig.getUsername() != null) {
				reconnect(dConfig.getUsername(), dConfig.getPassword());
			}

			return sessionManager.getDestination(name, Domain.getDomain(dConfig.getDomain()));
		} else {
			if (getConnectionFactory() instanceof QueueConnectionFactory) {
				return sessionManager.getDestination(name, Domain.QUEUE);
			} else {
				return sessionManager.getDestination(name, Domain.TOPIC);
			}
		}
	}

	/**
	 * Get the domain from any static configuration, falling back to instanceof
	 * if that does not exist.
	 */
	public Domain getDomain(Destination destination) throws JMSException {
		final DestinationConfig dConfig = getDestinationConfig(getDestinationName(destination), Domain.UNKNOWN);

		if (dConfig != null) {
			if (dConfig.getDomain() == Domain.QUEUE.getId()) {
				return Domain.QUEUE;
			} else {
				return Domain.TOPIC;
			}
		}

		if (destination instanceof Queue) {
			return Domain.QUEUE;
		} else {
			return Domain.TOPIC;
		}
	}

	/**
	 * List all destinations that have been pre-configured
	 */
	public final Iterator getDestinations() {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getDestinations().iterator();
	}

	/**
	 * Get my identifier
	 */
	public final String getId() {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getId();
	}

	/**
	 * receive.
	 */
	public Message receive(Destination d) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		final Message m = sessionManager.getConsumer(d).receive();

		if (m != null && isAudit()) {
			getAuditLog().onRead(d, m);
		}

		return m;
	}

	public Message receive(Destination d, String selector) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		final Message m = sessionManager.getConsumer(d, selector).receive();

		if (m != null && isAudit()) {
			getAuditLog().onRead(d, m);
		}

		return m;
	}

	public Message receive(Destination d, long ms, String selector) throws javax.jms.JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		final Message m = sessionManager.getConsumer(d, selector).receive(ms);

		if (m != null && isAudit()) {
			getAuditLog().onRead(d, m);
		}

		return m;
	}

	/**
	 * Receive a message with a timeout.
	 */
	public Message receive(Destination d, long ms) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		final Message m = sessionManager.getConsumer(d).receive(ms);

		if (m != null && isAudit()) {
			getAuditLog().onRead(d, m);
		}

		return m;
	}

	/**
	 * Receive a message if one is waiting otherwise returns null of no message
	 * available.
	 */
	public Message receiveNoWait(Destination d) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		final Message m = sessionManager.getConsumer(d).receiveNoWait();

		if (m != null && isAudit()) {
			getAuditLog().onRead(d, m);
		}

		return m;
	}

	/**
	 * Receive a message with a selector if one is waiting otherwise returns
	 * null of no message available.
	 */
	public Message receiveNoWait(Destination d, String selector) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		final Message m = sessionManager.getConsumer(d, selector).receiveNoWait();

		if (m != null && isAudit()) {
			getAuditLog().onRead(d, m);
		}

		return m;

	}

	/**
	 * Rollback everything since last commit or rollback.
	 */
	public void rollback() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (sessionManager.getSession().getTransacted()) {
			sessionManager.getSession().rollback();
		} else {
			log.warn("session " + getId() + " is not transacted");
		}

		if (isAudit()) {
			getAuditLog().rollback();
		}
	}

	/**
	 * Send messge to destination
	 */
	public void send(Destination d, Message m) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);
		boolean try102 = false;

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		// http://hermesjms.com/jira/browse/HJMS-86
		// http://hermesjms.com/jira/browse/HJMS-50

		if (Hermes.ui.getConfig().isDeliveryModePersistent()) {
			m.setJMSDeliveryMode(DeliveryMode.PERSISTENT);
		} else {
			m.setJMSDeliveryMode(DeliveryMode.NON_PERSISTENT);
		}

		MessageProducer producer = sessionManager.getProducer();

		// http://hermesjms.com/jira/browse/HJMS-11

		if (m.getJMSPriority() < 0) {
			m.setJMSPriority(0);
		}

		if (m.getJMSExpiration() < 0) {
			m.setJMSExpiration(0);
		}

		try {
			producer.send(d, m, m.getJMSDeliveryMode(), m.getJMSPriority(), m.getJMSExpiration());
		} catch (NoSuchMethodError ex) {
			try102 = true;
		} catch (AbstractMethodError ex) {
			try102 = true;
		}

		/*
		 * Try JMS 1.0.2b interface
		 */
		if (try102) {
			if (JMSUtils.isQueue(d)) {
				final QueueSender sender = (QueueSender) producer;

				if (d != null) {
					sender.send((Queue) d, m, m.getJMSDeliveryMode(), m.getJMSPriority(), m.getJMSExpiration());
				} else {
					sender.send(m, m.getJMSDeliveryMode(), m.getJMSPriority(), m.getJMSExpiration());
				}
			} else {
				final TopicPublisher publisher = (TopicPublisher) producer;

				if (d != null) {
					publisher.publish((Topic) d, m, m.getJMSDeliveryMode(), m.getJMSPriority(), m.getJMSExpiration());
				} else {
					publisher.publish(m, m.getJMSDeliveryMode(), m.getJMSPriority(), m.getJMSExpiration());
				}
			}
		}

		if (isAudit()) {
			getAuditLog().onWrite(d, m);
		}
	}

	public Context createContext() throws NamingException, JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getConnectionFactoryManager().createContext();
	}

	/**
	 * Set the callback listener for a destination.
	 */
	public void setMessageListener(final javax.jms.Destination d, final javax.jms.MessageListener l) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (isReadOnly()) {
			throw new JMSException("Hermes is in read-only mode");
		}

		if (isAudit()) {
			MessageListener auditListener = new MessageListener() {
				public void onMessage(Message arg0) {
					try {
						getAuditLog().onRead(d, arg0);
					} catch (JMSException e) {
						log.error(e.getMessage(), e);
					}

					l.onMessage(arg0);
				}
			};

			defaultDespatcher.setMessageListener(d, auditListener);
		} else {
			defaultDespatcher.setMessageListener(d, l);
		}
	}

	/**
	 * Get a long description of this Hermes, suitable for use in debugging
	 */
	public String toString() {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.toString();
	}

	/**
	 * Is the javax.jms.ConnectionFactory in the Queue domain?
	 */
	public final boolean isQueue() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return JMSUtils.isQueue(getConnectionFactory());
	}

	/**
	 * Is the javax.jms.ConnectionFactory in the Topic domain?
	 */
	public final boolean isTopic() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return !JMSUtils.isQueue(getConnectionFactory());
	}

	/**
	 * Get the meta data
	 */
	public ProviderMetaData getMetaData() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		if (metaData == null) {
			metaData = new DefaultProviderMetaData(this, sessionManager.getFactoryConfig(), true);
		}

		return metaData;
	}

	/**
	 * Create a copy of a message
	 */
	public Message duplicate(Destination to, Message in) throws JMSException {
		HermesConfig config = HermesBrowser.getBrowser().getConfig();

		Thread.currentThread().setContextClassLoader(contextClassLoader);

		Message out = null;

		if (in instanceof TextMessage) {
			out = createTextMessage(((TextMessage) in).getText());
		} else if (in instanceof ObjectMessage) {
			out = createObjectMessage();
			((ObjectMessage) out).setObject(((ObjectMessage) in).getObject());

		} else if (in instanceof MapMessage) {
			out = createMapMessage();
			final MapMessage inMap = (MapMessage) in;
			final MapMessage outMap = (MapMessage) out;

			for (Enumeration iter = inMap.getMapNames(); iter.hasMoreElements();) {
				String key = (String) iter.nextElement();

				outMap.setObject(key, inMap.getObject(key));
			}
		} else if (in instanceof StreamMessage) {
			out = createStreamMessage();
			final StreamMessage inS = (StreamMessage) in;
			final StreamMessage outS = (StreamMessage) out;

			try {
				for (;;) {
					outS.writeObject(inS.readObject());
				}
			} catch (MessageEOFException ex2) {
				// NOP
			}
		} else if (in instanceof BytesMessage) {
			out = createBytesMessage();
			final BytesMessage inBytes = (BytesMessage) in;
			final BytesMessage outBytes = (BytesMessage) out;
			inBytes.reset();
			try {
				outBytes.writeBytes(MessageUtils.asBytes(inBytes));
			} catch (MessageEOFException ex2) {
				// NOP
			}
		} else if (in instanceof Message) {
			out = createMessage();
		} else {
			throw new HermesException("Cannot handle " + in.getClass().getName());
		}

		try {
			out.setJMSDestination(to);
		} catch (Exception ex) {
			log.error(ex.getMessage(), ex);
		}
		//
		// Header properties

		if (config.isCopyJMSCorrelationID()) {
			try {
				out.setJMSCorrelationID(in.getJMSCorrelationID());
			} catch (JMSException ex) {
				log.error(ex.getMessage(), ex);
			}
		}

		if (config.isCopyJMSExpiration()) {
			try {
				out.setJMSExpiration(in.getJMSExpiration());
			} catch (JMSException ex) {
				log.error(ex.getMessage(), ex);
			}
		}

		if (config.isCopyJMSPriority()) {
			try {
				out.setJMSPriority(in.getJMSPriority());
			} catch (JMSException ex) {
				log.error(ex.getMessage(), ex);
			}
		}

		if (config.isCopyJMSReplyTo()) {
			try {
				if (in.getJMSReplyTo() != null) {
					out.setJMSReplyTo(getDestination(getDestinationName(in.getJMSReplyTo()), Domain.getDomain(in.getJMSReplyTo())));
				}
			}

			catch (JMSException ex) {
				log.error(ex.getMessage(), ex);
			} catch (NamingException ex) {
				throw new HermesRuntimeException(ex);
			}
		}

		if (config.isCopyJMSType()) {
			try {
				out.setJMSType(in.getJMSType());
			} catch (JMSException ex) {
				log.error(ex.getMessage(), ex);
			}
		}

		if (in.getPropertyNames() != null) {
			for (final Enumeration iter = in.getPropertyNames(); iter.hasMoreElements();) {
				final String key = (String) iter.nextElement();

				//
				// Dont copy over provider properties unless
				// copyJMSProviderProperties
				// is set.

				if (!key.startsWith("JMS") || config.isCopyJMSProviderProperties()) {
					out.setObjectProperty(key, in.getObjectProperty(key));
				}
			}
		}

		return out;
	}

	/**
	 * Create a copy of a message
	 */
	public Message duplicate(Message in) throws JMSException {
		return duplicate(null, in);
	}

	/**
	 * Get my session manager
	 */
	protected SessionManager getSessionManager() {
		return sessionManager;
	}

	/**
	 * @see hermes.Hermes#schedule(TimerTask, long, boolean)
	 */
	public void schedule(final TimerTask task, final long delay, final boolean repeating) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		TimerTask timerTask = new TimerTask() {
			public void run() {
				try {
					invoke(task);
				} catch (JMSException ex) {
					log.error(ex.getMessage(), ex);
				}
			}
		};

		timerMap.put(task, timerTask);

		if (repeating) {
			timer.schedule(task, delay, delay);
		} else {
			timer.schedule(task, delay);
		}
	}

	/**
	 * @see hermes.Hermes#cancel(TimerTask)
	 */
	public void cancel(TimerTask task) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		TimerTask timerTask;

		if ((timerTask = (TimerTask) timerMap.remove(task)) == null) {
			throw new JMSException("Unknown timer");
		}

		timerTask.cancel();

	}

	public String getDestinationName(Destination to) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return JMSUtils.getDestinationName(to);
	}

	/**
	 * @see hermes.Hermes#getDestinationConfig(Destination)
	 */
	public DestinationConfig getDestinationConfig(String d, Domain domain) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return sessionManager.getDestinationConfig(d, domain);
	}

	/**
	 * @see hermes.Hermes#getDispatcher(String)
	 */
	public HermesDispatcher getDispatcher(String name) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return _getDispatcher(name);
	}

	private final DefaultHermesDispatcherImpl _getDispatcher(String name) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		DefaultHermesDispatcherImpl dispatcher;

		synchronized (dispatchers) {
			if (dispatchers.containsKey(name)) {
				dispatcher = (DefaultHermesDispatcherImpl) dispatchers.get(name);
			} else {
				dispatcher = new DefaultHermesDispatcherImpl(this);
				dispatchers.put(name, dispatcher);
			}
		}

		return dispatcher;
	}

	/**
	 * Clean up the dispatcher, called from HermesDispatcher.close() ;
	 */
	final void removeDispatcher(HermesDispatcher dispatcher) {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		synchronized (dispatchers) {
			dispatchers.remove(dispatcher);
		}
	}

	/**
	 * @see hermes.Hermes#setMessageListener(HermesDispatcher, Destination,
	 *      MessageListener)
	 */
	public void setMessageListener(HermesDispatcher dispatcher, Destination d, MessageListener ml) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		dispatcher.setMessageListener(d, ml);
	}

	/**
	 * @see hermes.Hermes#invoke(Runnable)
	 */
	public void invoke(Runnable runnable) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		defaultDespatcher.invoke(runnable);
	}

	/**
	 * @see hermes.Hermes#invokeAll(Runnable)
	 */
	public void invokeAll(Runnable runnable) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		synchronized (dispatchers) {
			for (Iterator iter = dispatchers.entrySet().iterator(); iter.hasNext();) {
				Map.Entry entry = (Map.Entry) iter.next();
				HermesDispatcher dispatcher = (HermesDispatcher) entry.getValue();

				dispatcher.invoke(runnable);
			}
		}
	}

	/**
	 * @see hermes.Hermes#invokeAllAndWait(Runnable)
	 */
	public void invokeAllAndWait(Runnable runnable) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		synchronized (dispatchers) {
			for (Iterator iter = dispatchers.entrySet().iterator(); iter.hasNext();) {
				Map.Entry entry = (Map.Entry) iter.next();
				HermesDispatcher dispatcher = (HermesDispatcher) entry.getValue();

				dispatcher.invokeAndWait(runnable);
			}
		}
	}

	/**
	 * @see hermes.Hermes#invokeAndWait(Runnable)
	 */
	public void invokeAndWait(Runnable runnable) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		defaultDespatcher.invokeAndWait(runnable);
	}

	/**
	 * @return
	 */
	public boolean isReadOnly() {
		return readOnly;
	}

	/**
	 * @param b
	 */
	public void setReadOnly(boolean b) {
		readOnly = b;
	}

	public Queue createQueue(String queueName) throws JMSException, NamingException {
		return (Queue) getDestination(queueName, Domain.QUEUE);
	}

	public Topic createTopic(String topicName) throws JMSException, NamingException {
		return (Topic) getDestination(topicName, Domain.TOPIC);
	}

	public boolean isAudit() throws JMSException {
		return sessionManager.isAudit() && getTransacted();
	}

	public HermesAuditLog getAuditLog() throws JMSException {
		try {
			HermesAuditLog rval = (HermesAuditLog) auditLogTL.get();

			if (rval == null) {
				rval = new DefaultHermesLogImpl(this, sessionManager.getAuditDirectory(), true, true);
				auditLogTL.set(rval);
			}

			return rval;
		} catch (IOException e) {
			throw new HermesException(e);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#fromXML(java.io.InputStream)
	 */
	public Collection fromXML(InputStream istream) throws JMSException, IOException {
		return xmlSupport.fromXML(this, istream);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#fromXML(java.lang.String)
	 */
	public Collection fromXML(String document) throws JMSException {
		return xmlSupport.fromXML(this, document);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#toXML(java.util.Collection, java.io.OutputStream)
	 */
	public void toXML(Collection messages, OutputStream ostream) throws JMSException, IOException {
		xmlSupport.toXML(messages, ostream);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#toXML(java.util.Collection)
	 */
	public String toXML(Collection messages) throws JMSException {
		return xmlSupport.toXML(messages);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.MessageFactory#createObjectMessage(java.io.Serializable)
	 */
	public ObjectMessage createObjectMessage(Serializable object) throws JMSException {
		return sessionManager.getSession().createObjectMessage(object);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#isConnectable()
	 */
	public boolean isConnectable() throws JMSException {
		sessionManager.getSession();

		sessionManager.close();

		return true;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#toXML(javax.jms.Message, java.io.OutputStream)
	 */
	public void toXML(Message message, OutputStream ostream) throws JMSException, IOException {
		Collection c = new ArrayList();
		c.add(message);

		toXML(c, ostream);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#toXML(javax.jms.Message)
	 */
	public String toXML(Message message) throws JMSException {
		Collection c = new ArrayList();
		c.add(message);

		return toXML(c);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see hermes.Hermes#addDestinationConfig(hermes.config.DestinationConfig)
	 */
	public void addDestinationConfig(DestinationConfig dConfig) throws JMSException {
		sessionManager.getConnectionFactoryManager().addDestinationConfig(dConfig);
	}

	/**
	 * Remove a destination configuration
	 */
	public void removeDestinationConfig(DestinationConfig dConfig) throws JMSException {
		sessionManager.getConnectionFactoryManager().removeDestinationConfig(dConfig);
	}

	public long getAge(DestinationConfig dest) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().getAge(dest);
	}

	public MessageRenderer getMessageRenderer() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().getMessageRenderer();
	}

	public int getDepth(DestinationConfig dest) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().getDepth(dest);
	}

	public Collection getStatistics(Collection destinations) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().getStatistics(destinations);
	}

	public Map getStatistics(DestinationConfig dConfig) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().getStatistics(dConfig);
	}

	public QueueBrowser createDurableSubscriptionBrowser(DestinationConfig dConfig) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().createDurableSubscriptionBrowser(dConfig);
	}

	public void delete(DestinationConfig dConfig, Collection<String> messageIds, ProgressMonitor progress) throws JMSException, NamingException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		getAdminAdapter().delete(dConfig, messageIds, progress);

	}

	public void delete(DestinationConfig dConfig, Collection<String> messageIds) throws JMSException, NamingException {
		delete(dConfig, messageIds, null);
	}

	public Collection discoverDestinationConfigs() throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().discoverDestinationConfigs();
	}

	public int truncate(DestinationConfig dest) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().truncate(dest);
	}

	public Enumeration createBrowserProxy(Enumeration iter) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return getAdminAdapter().createBrowserProxy(iter);
	}

	public QueueBrowser createRegexBrowser(Destination d, String selector, String regex) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return new RegexQueueBrowser(createBrowser(d, selector), regex, false, true);
	}

	public QueueBrowser createRegexBrowser(Destination d, String regex) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		return new RegexQueueBrowser(createBrowser(d), regex, false, true);
	}

	public void unsubscribe(String name) throws JMSException {
		Thread.currentThread().setContextClassLoader(contextClassLoader);

		getSessionManager().unsubscribe(name);

	}

	public DestinationManager getDestinationManager() {
		return getSessionManager().getDestinationManager();
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Hermes) {
			Hermes other = (Hermes) obj;

			return getId().equals(other.getId());
		} else {
			return false;
		}
	}
}