activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From clebertsuco...@apache.org
Subject [26/52] [abbrv] [partial] activemq-6 git commit: ACTIVEMQ6-4 Rename HornetQ* classes to ActiveMQ*
Date Tue, 18 Nov 2014 23:38:19 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnection.java
----------------------------------------------------------------------
diff --git a/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnection.java b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnection.java
new file mode 100644
index 0000000..7ec8379
--- /dev/null
+++ b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnection.java
@@ -0,0 +1,921 @@
+/*
+ * Copyright 2005-2014 Red Hat, Inc.
+ * Red Hat 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.activemq.ra;
+
+import javax.jms.ExceptionListener;
+import javax.jms.JMSException;
+import javax.jms.ResourceAllocationException;
+import javax.jms.Session;
+import javax.jms.XASession;
+import javax.resource.ResourceException;
+import javax.resource.spi.ConnectionEvent;
+import javax.resource.spi.ConnectionEventListener;
+import javax.resource.spi.ConnectionRequestInfo;
+import javax.resource.spi.IllegalStateException;
+import javax.resource.spi.LocalTransaction;
+import javax.resource.spi.ManagedConnection;
+import javax.resource.spi.ManagedConnectionMetaData;
+import javax.resource.spi.SecurityException;
+import javax.security.auth.Subject;
+import javax.transaction.Status;
+import javax.transaction.SystemException;
+import javax.transaction.Transaction;
+import javax.transaction.TransactionManager;
+import javax.transaction.xa.XAResource;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.apache.activemq.core.client.impl.ClientSessionInternal;
+import org.apache.activemq.jms.client.ActiveMQConnection;
+import org.apache.activemq.jms.client.ActiveMQConnectionFactory;
+import org.apache.activemq.jms.client.ActiveMQXAConnection;
+
+/**
+ * The managed connection
+ *
+ * @author <a href="mailto:adrian@jboss.com">Adrian Brock</a>
+ * @author <a href="mailto:jesper.pedersen@jboss.org">Jesper Pedersen</a>
+ * @author <a href="mailto:mtaylor@redhat.com">Martyn Taylor</a>
+ */
+public final class ActiveMQRAManagedConnection implements ManagedConnection, ExceptionListener
+{
+   /**
+    * Trace enabled
+    */
+   private static boolean trace = ActiveMQRALogger.LOGGER.isTraceEnabled();
+
+   /**
+    * The managed connection factory
+    */
+   private final ActiveMQRAManagedConnectionFactory mcf;
+
+   /**
+    * The connection request information
+    */
+   private final ActiveMQRAConnectionRequestInfo cri;
+
+   /**
+    * The resource adapter
+    */
+   private final ActiveMQResourceAdapter ra;
+
+   /**
+    * The user name
+    */
+   private final String userName;
+
+   /**
+    * The password
+    */
+   private final String password;
+
+   /**
+    * Has the connection been destroyed
+    */
+   private final AtomicBoolean isDestroyed = new AtomicBoolean(false);
+
+   /**
+    * Event listeners
+    */
+   private final List<ConnectionEventListener> eventListeners;
+
+   /**
+    * Handles
+    */
+   private final Set<ActiveMQRASession> handles;
+
+   /**
+    * Lock
+    */
+   private ReentrantLock lock = new ReentrantLock();
+
+   // Physical connection stuff
+   private ActiveMQConnectionFactory connectionFactory;
+
+   private ActiveMQXAConnection connection;
+
+   // The ManagedConnection will play with a XA and a NonXASession to couple with
+   // cases where a commit is called on a non-XAed (or non-enlisted) case.
+   private Session nonXAsession;
+
+   private XASession xaSession;
+
+   private XAResource xaResource;
+
+   private final TransactionManager tm;
+
+   private boolean inManagedTx;
+
+   /**
+    * Constructor
+    *
+    * @param mcf      The managed connection factory
+    * @param cri      The connection request information
+    * @param userName The user name
+    * @param password The password
+    */
+   public ActiveMQRAManagedConnection(final ActiveMQRAManagedConnectionFactory mcf,
+                                      final ActiveMQRAConnectionRequestInfo cri,
+                                      final ActiveMQResourceAdapter ra,
+                                      final String userName,
+                                      final String password) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("constructor(" + mcf + ", " + cri + ", " + userName + ", ****)");
+      }
+
+      this.mcf = mcf;
+      this.cri = cri;
+      this.tm = ra.getTM();
+      this.ra = ra;
+      this.userName = userName;
+      this.password = password;
+      eventListeners = Collections.synchronizedList(new ArrayList<ConnectionEventListener>());
+      handles = Collections.synchronizedSet(new HashSet<ActiveMQRASession>());
+
+      connection = null;
+      nonXAsession = null;
+      xaSession = null;
+      xaResource = null;
+
+      try
+      {
+         setup();
+      }
+      catch (ResourceException e)
+      {
+         try
+         {
+            destroy();
+         }
+         catch (Throwable ignored)
+         {
+         }
+
+         throw e;
+      }
+      catch (Throwable t)
+      {
+         try
+         {
+            destroy();
+         }
+         catch (Throwable ignored)
+         {
+         }
+         throw new ResourceException("Error during setup", t);
+      }
+   }
+
+   /**
+    * Get a connection
+    *
+    * @param subject       The security subject
+    * @param cxRequestInfo The request info
+    * @return The connection
+    * @throws ResourceException Thrown if an error occurs
+    */
+   public synchronized Object getConnection(final Subject subject, final ConnectionRequestInfo cxRequestInfo) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getConnection(" + subject + ", " + cxRequestInfo + ")");
+      }
+
+      // Check user first
+      ActiveMQRACredential credential = ActiveMQRACredential.getCredential(mcf, subject, cxRequestInfo);
+
+      // Null users are allowed!
+      if (userName != null && !userName.equals(credential.getUserName()))
+      {
+         throw new SecurityException("Password credentials not the same, reauthentication not allowed");
+      }
+
+      if (userName == null && credential.getUserName() != null)
+      {
+         throw new SecurityException("Password credentials not the same, reauthentication not allowed");
+      }
+
+      if (isDestroyed.get())
+      {
+         throw new IllegalStateException("The managed connection is already destroyed");
+      }
+
+      ActiveMQRASession session = new ActiveMQRASession(this, (ActiveMQRAConnectionRequestInfo) cxRequestInfo);
+      handles.add(session);
+      return session;
+   }
+
+   /**
+    * Destroy all handles.
+    *
+    * @throws ResourceException Failed to close one or more handles.
+    */
+   private void destroyHandles() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("destroyHandles()");
+      }
+
+      try
+      {
+
+         if (connection != null)
+         {
+            connection.stop();
+         }
+      }
+      catch (Throwable t)
+      {
+         ActiveMQRALogger.LOGGER.trace("Ignored error stopping connection", t);
+      }
+
+      for (ActiveMQRASession session : handles)
+      {
+         session.destroy();
+      }
+
+      handles.clear();
+   }
+
+   /**
+    * Destroy the physical connection.
+    *
+    * @throws ResourceException Could not property close the session and connection.
+    */
+   public void destroy() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("destroy()");
+      }
+
+      if (isDestroyed.get() || connection == null)
+      {
+         return;
+      }
+
+      isDestroyed.set(true);
+
+      try
+      {
+         connection.setExceptionListener(null);
+      }
+      catch (JMSException e)
+      {
+         ActiveMQRALogger.LOGGER.debug("Error unsetting the exception listener " + this, e);
+      }
+      if (connection != null)
+      {
+         connection.signalStopToAllSessions();
+      }
+
+      destroyHandles();
+
+      try
+      {
+         /**
+          * (xa|nonXA)Session.close() may NOT be called BEFORE connection.close()
+          * <p>
+          * If the ClientSessionFactory is trying to fail-over or reconnect with -1 attempts, and
+          * one calls session.close() it may effectively dead-lock.
+          * <p>
+          * connection close will close the ClientSessionFactory which will close all sessions.
+          */
+         if (connection != null)
+         {
+            connection.close();
+         }
+
+         // The following calls should not be necessary, as the connection should close the
+         // ClientSessionFactory, which will close the sessions.
+         try
+         {
+            if (nonXAsession != null)
+            {
+               nonXAsession.close();
+            }
+
+            if (xaSession != null)
+            {
+               xaSession.close();
+            }
+         }
+         catch (JMSException e)
+         {
+            ActiveMQRALogger.LOGGER.debug("Error closing session " + this, e);
+         }
+
+         // we must close the ActiveMQConnectionFactory because it contains a ServerLocator
+         if (connectionFactory != null)
+         {
+            connectionFactory.close();
+         }
+      }
+      catch (Throwable e)
+      {
+         throw new ResourceException("Could not properly close the session and connection", e);
+      }
+   }
+
+   /**
+    * Cleanup
+    *
+    * @throws ResourceException Thrown if an error occurs
+    */
+   public void cleanup() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("cleanup()");
+      }
+
+      if (isDestroyed.get())
+      {
+         throw new IllegalStateException("ManagedConnection already destroyed");
+      }
+
+      destroyHandles();
+
+      inManagedTx = false;
+
+      inManagedTx = false;
+
+      // I'm recreating the lock object when we return to the pool
+      // because it looks too nasty to expect the connection handle
+      // to unlock properly in certain race conditions
+      // where the dissociation of the managed connection is "random".
+      lock = new ReentrantLock();
+   }
+
+   /**
+    * Move a handler from one mc to this one.
+    *
+    * @param obj An object of type ActiveMQSession.
+    * @throws ResourceException     Failed to associate connection.
+    * @throws IllegalStateException ManagedConnection in an illegal state.
+    */
+   public void associateConnection(final Object obj) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("associateConnection(" + obj + ")");
+      }
+
+      if (!isDestroyed.get() && obj instanceof ActiveMQRASession)
+      {
+         ActiveMQRASession h = (ActiveMQRASession) obj;
+         h.setManagedConnection(this);
+         handles.add(h);
+      }
+      else
+      {
+         throw new IllegalStateException("ManagedConnection in an illegal state");
+      }
+   }
+
+   public void checkTransactionActive() throws JMSException
+   {
+      // don't bother looking at the transaction if there's an active XID
+      if (!inManagedTx && tm != null)
+      {
+         try
+         {
+            Transaction tx = tm.getTransaction();
+            if (tx != null)
+            {
+               int status = tx.getStatus();
+               // Only allow states that will actually succeed
+               if (status != Status.STATUS_ACTIVE && status != Status.STATUS_PREPARING &&
+                  status != Status.STATUS_PREPARED &&
+                  status != Status.STATUS_COMMITTING)
+               {
+                  throw new javax.jms.IllegalStateException("Transaction " + tx + " not active");
+               }
+            }
+         }
+         catch (SystemException e)
+         {
+            JMSException jmsE = new javax.jms.IllegalStateException("Unexpected exception on the Transaction ManagerTransaction");
+            jmsE.initCause(e);
+            throw jmsE;
+         }
+      }
+   }
+
+
+   /**
+    * Aqquire a lock on the managed connection
+    */
+   protected void lock()
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("lock()");
+      }
+
+      lock.lock();
+   }
+
+   /**
+    * Aqquire a lock on the managed connection within the specified period
+    *
+    * @throws JMSException Thrown if an error occurs
+    */
+   protected void tryLock() throws JMSException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("tryLock()");
+      }
+
+      Integer tryLock = mcf.getUseTryLock();
+      if (tryLock == null || tryLock.intValue() <= 0)
+      {
+         lock();
+         return;
+      }
+      try
+      {
+         if (lock.tryLock(tryLock.intValue(), TimeUnit.SECONDS) == false)
+         {
+            throw new ResourceAllocationException("Unable to obtain lock in " + tryLock + " seconds: " + this);
+         }
+      }
+      catch (InterruptedException e)
+      {
+         throw new ResourceAllocationException("Interrupted attempting lock: " + this);
+      }
+   }
+
+   /**
+    * Unlock the managed connection
+    */
+   protected void unlock()
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("unlock()");
+      }
+
+      lock.unlock();
+   }
+
+   /**
+    * Add a connection event listener.
+    *
+    * @param l The connection event listener to be added.
+    */
+   public void addConnectionEventListener(final ConnectionEventListener l)
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("addConnectionEventListener(" + l + ")");
+      }
+
+      eventListeners.add(l);
+   }
+
+   /**
+    * Remove a connection event listener.
+    *
+    * @param l The connection event listener to be removed.
+    */
+   public void removeConnectionEventListener(final ConnectionEventListener l)
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("removeConnectionEventListener(" + l + ")");
+      }
+
+      eventListeners.remove(l);
+   }
+
+   /**
+    * Get the XAResource for the connection.
+    *
+    * @return The XAResource for the connection.
+    * @throws ResourceException XA transaction not supported
+    */
+   public XAResource getXAResource() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getXAResource()");
+      }
+
+      //
+      // Spec says a mc must always return the same XA resource,
+      // so we cache it.
+      //
+      if (xaResource == null)
+      {
+         ClientSessionInternal csi = (ClientSessionInternal) xaSession.getXAResource();
+         ActiveMQRAXAResource activeMQRAXAResource = new ActiveMQRAXAResource(this, xaSession.getXAResource());
+         xaResource = new ActiveMQXAResourceWrapper(activeMQRAXAResource, ra.getJndiName(), csi.getNodeId());
+      }
+
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("XAResource=" + xaResource);
+      }
+
+      return xaResource;
+   }
+
+   /**
+    * Get the location transaction for the connection.
+    *
+    * @return The local transaction for the connection.
+    * @throws ResourceException Thrown if operation fails.
+    */
+   public LocalTransaction getLocalTransaction() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getLocalTransaction()");
+      }
+
+      LocalTransaction tx = new ActiveMQRALocalTransaction(this);
+
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("LocalTransaction=" + tx);
+      }
+
+      return tx;
+   }
+
+   /**
+    * Get the meta data for the connection.
+    *
+    * @return The meta data for the connection.
+    * @throws ResourceException     Thrown if the operation fails.
+    * @throws IllegalStateException Thrown if the managed connection already is destroyed.
+    */
+   public ManagedConnectionMetaData getMetaData() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getMetaData()");
+      }
+
+      if (isDestroyed.get())
+      {
+         throw new IllegalStateException("The managed connection is already destroyed");
+      }
+
+      return new ActiveMQRAMetaData(this);
+   }
+
+   /**
+    * Set the log writer -- NOT SUPPORTED
+    *
+    * @param out The log writer
+    * @throws ResourceException If operation fails
+    */
+   public void setLogWriter(final PrintWriter out) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setLogWriter(" + out + ")");
+      }
+   }
+
+   /**
+    * Get the log writer -- NOT SUPPORTED
+    *
+    * @return Always null
+    * @throws ResourceException If operation fails
+    */
+   public PrintWriter getLogWriter() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getLogWriter()");
+      }
+
+      return null;
+   }
+
+   /**
+    * Notifies user of a JMS exception.
+    *
+    * @param exception The JMS exception
+    */
+   public void onException(final JMSException exception)
+   {
+      if (ActiveMQConnection.EXCEPTION_FAILOVER.equals(exception.getErrorCode()))
+      {
+         return;
+      }
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("onException(" + exception + ")");
+      }
+
+      if (isDestroyed.get())
+      {
+         if (ActiveMQRAManagedConnection.trace)
+         {
+            ActiveMQRALogger.LOGGER.trace("Ignoring error on already destroyed connection " + this, exception);
+         }
+         return;
+      }
+
+      ActiveMQRALogger.LOGGER.handlingJMSFailure(exception);
+
+      try
+      {
+         connection.setExceptionListener(null);
+      }
+      catch (JMSException e)
+      {
+         ActiveMQRALogger.LOGGER.debug("Unable to unset exception listener", e);
+      }
+
+      ConnectionEvent event = new ConnectionEvent(this, ConnectionEvent.CONNECTION_ERROR_OCCURRED, exception);
+      sendEvent(event);
+   }
+
+   /**
+    * Get the session for this connection.
+    *
+    * @return The session
+    * @throws JMSException
+    */
+   protected Session getSession() throws JMSException
+   {
+      if (xaResource != null && inManagedTx)
+      {
+         if (ActiveMQRAManagedConnection.trace)
+         {
+            ActiveMQRALogger.LOGGER.trace("getSession() -> XA session " + xaSession.getSession());
+         }
+
+         return xaSession.getSession();
+      }
+      else
+      {
+         if (ActiveMQRAManagedConnection.trace)
+         {
+            ActiveMQRALogger.LOGGER.trace("getSession() -> non XA session " + nonXAsession);
+         }
+
+         return nonXAsession;
+      }
+   }
+
+   /**
+    * Send an event.
+    *
+    * @param event The event to send.
+    */
+   protected void sendEvent(final ConnectionEvent event)
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("sendEvent(" + event + ")");
+      }
+
+      int type = event.getId();
+
+      // convert to an array to avoid concurrent modification exceptions
+      ConnectionEventListener[] list = eventListeners.toArray(new ConnectionEventListener[eventListeners.size()]);
+
+      for (ConnectionEventListener l : list)
+      {
+         switch (type)
+         {
+            case ConnectionEvent.CONNECTION_CLOSED:
+               l.connectionClosed(event);
+               break;
+
+            case ConnectionEvent.LOCAL_TRANSACTION_STARTED:
+               l.localTransactionStarted(event);
+               break;
+
+            case ConnectionEvent.LOCAL_TRANSACTION_COMMITTED:
+               l.localTransactionCommitted(event);
+               break;
+
+            case ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK:
+               l.localTransactionRolledback(event);
+               break;
+
+            case ConnectionEvent.CONNECTION_ERROR_OCCURRED:
+               l.connectionErrorOccurred(event);
+               break;
+
+            default:
+               throw new IllegalArgumentException("Illegal eventType: " + type);
+         }
+      }
+   }
+
+   /**
+    * Remove a handle from the handle map.
+    *
+    * @param handle The handle to remove.
+    */
+   protected void removeHandle(final ActiveMQRASession handle)
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("removeHandle(" + handle + ")");
+      }
+
+      handles.remove(handle);
+   }
+
+   /**
+    * Get the request info for this connection.
+    *
+    * @return The connection request info for this connection.
+    */
+   protected ActiveMQRAConnectionRequestInfo getCRI()
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getCRI()");
+      }
+
+      return cri;
+   }
+
+   /**
+    * Get the connection factory for this connection.
+    *
+    * @return The connection factory for this connection.
+    */
+   protected ActiveMQRAManagedConnectionFactory getManagedConnectionFactory()
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getManagedConnectionFactory()");
+      }
+
+      return mcf;
+   }
+
+   /**
+    * Start the connection
+    *
+    * @throws JMSException Thrown if the connection can't be started
+    */
+   void start() throws JMSException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("start()");
+      }
+
+      if (connection != null)
+      {
+         connection.start();
+      }
+   }
+
+   /**
+    * Stop the connection
+    *
+    * @throws JMSException Thrown if the connection can't be stopped
+    */
+   void stop() throws JMSException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("stop()");
+      }
+
+      if (connection != null)
+      {
+         connection.stop();
+      }
+   }
+
+   /**
+    * Get the user name
+    *
+    * @return The user name
+    */
+   protected String getUserName()
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getUserName()");
+      }
+
+      return userName;
+   }
+
+   /**
+    * Setup the connection.
+    *
+    * @throws ResourceException Thrown if a connection couldn't be created
+    */
+   private void setup() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnection.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setup()");
+      }
+
+      try
+      {
+
+         createCF();
+
+         boolean transacted = cri.isTransacted();
+         int acknowledgeMode = Session.AUTO_ACKNOWLEDGE;
+         if (cri.getType() == ActiveMQRAConnectionFactory.TOPIC_CONNECTION)
+         {
+            if (userName != null && password != null)
+            {
+               connection = (ActiveMQXAConnection) connectionFactory.createXATopicConnection(userName, password);
+            }
+            else
+            {
+               connection = (ActiveMQXAConnection) connectionFactory.createXATopicConnection();
+            }
+
+            connection.setExceptionListener(this);
+
+            xaSession = connection.createXATopicSession();
+            nonXAsession = connection.createNonXATopicSession(transacted, acknowledgeMode);
+
+         }
+         else if (cri.getType() == ActiveMQRAConnectionFactory.QUEUE_CONNECTION)
+         {
+            if (userName != null && password != null)
+            {
+               connection = (ActiveMQXAConnection) connectionFactory.createXAQueueConnection(userName, password);
+            }
+            else
+            {
+               connection = (ActiveMQXAConnection) connectionFactory.createXAQueueConnection();
+            }
+
+            connection.setExceptionListener(this);
+
+            xaSession = connection.createXAQueueSession();
+            nonXAsession = connection.createNonXAQueueSession(transacted, acknowledgeMode);
+
+         }
+         else
+         {
+            if (userName != null && password != null)
+            {
+               connection = (ActiveMQXAConnection) connectionFactory.createXAConnection(userName, password);
+            }
+            else
+            {
+               connection = (ActiveMQXAConnection) connectionFactory.createXAConnection();
+            }
+
+            connection.setExceptionListener(this);
+
+            xaSession = connection.createXASession();
+            nonXAsession = connection.createNonXASession(transacted, acknowledgeMode);
+         }
+
+      }
+      catch (JMSException je)
+      {
+         throw new ResourceException(je.getMessage(), je);
+      }
+   }
+
+   private void createCF()
+   {
+      if (connectionFactory == null)
+      {
+         connectionFactory = ra.createActiveMQConnectionFactory(mcf.getProperties());
+      }
+   }
+
+   protected void setInManagedTx(boolean inManagedTx)
+   {
+      this.inManagedTx = inManagedTx;
+   }
+
+}

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnectionFactory.java
----------------------------------------------------------------------
diff --git a/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnectionFactory.java b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnectionFactory.java
new file mode 100644
index 0000000..8c40ab9
--- /dev/null
+++ b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAManagedConnectionFactory.java
@@ -0,0 +1,805 @@
+/*
+ * Copyright 2005-2014 Red Hat, Inc.
+ * Red Hat 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.activemq.ra;
+
+import javax.jms.ConnectionMetaData;
+import javax.resource.ResourceException;
+import javax.resource.spi.ConnectionManager;
+import javax.resource.spi.ConnectionRequestInfo;
+import javax.resource.spi.ManagedConnection;
+import javax.resource.spi.ManagedConnectionFactory;
+import javax.resource.spi.ResourceAdapter;
+import javax.resource.spi.ResourceAdapterAssociation;
+import javax.security.auth.Subject;
+import java.io.PrintWriter;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.apache.activemq.jms.client.ActiveMQConnectionFactory;
+import org.apache.activemq.jms.server.recovery.XARecoveryConfig;
+
+/**
+ * ActiveMQ ManagedConnectionFactory
+ *
+ * @author <a href="mailto:adrian@jboss.com">Adrian Brock</a>
+ * @author <a href="mailto:jesper.pedersen@jboss.org">Jesper Pedersen</a>.
+ * @author <a href="mailto:andy.taylor@jboss.org">Andy Taylor</a>
+ */
+public final class ActiveMQRAManagedConnectionFactory implements ManagedConnectionFactory, ResourceAdapterAssociation
+{
+   /**
+    * Serial version UID
+    */
+   static final long serialVersionUID = -1452379518562456741L;
+   /**
+    * Trace enabled
+    */
+   private static boolean trace = ActiveMQRALogger.LOGGER.isTraceEnabled();
+
+   /**
+    * The resource adapter
+    */
+   private ActiveMQResourceAdapter ra;
+
+   /**
+    * Connection manager
+    */
+   private ConnectionManager cm;
+
+   /**
+    * The managed connection factory properties
+    */
+   private final ActiveMQRAMCFProperties mcfProperties;
+
+   /**
+    * Connection Factory used if properties are set
+    */
+   private ActiveMQConnectionFactory recoveryConnectionFactory;
+
+   /*
+   * The resource recovery if there is one
+   * */
+   private XARecoveryConfig resourceRecovery;
+
+   /**
+    * Constructor
+    */
+   public ActiveMQRAManagedConnectionFactory()
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("constructor()");
+      }
+
+      ra = null;
+      cm = null;
+      mcfProperties = new ActiveMQRAMCFProperties();
+   }
+
+   /**
+    * Creates a Connection Factory instance
+    *
+    * @return javax.resource.cci.ConnectionFactory instance
+    * @throws ResourceException Thrown if a connection factory can't be created
+    */
+   public Object createConnectionFactory() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.debug("createConnectionFactory()");
+      }
+
+      return createConnectionFactory(new ActiveMQRAConnectionManager());
+   }
+
+   /**
+    * Creates a Connection Factory instance
+    *
+    * @param cxManager The connection manager
+    * @return javax.resource.cci.ConnectionFactory instance
+    * @throws ResourceException Thrown if a connection factory can't be created
+    */
+   public Object createConnectionFactory(final ConnectionManager cxManager) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("createConnectionFactory(" + cxManager + ")");
+      }
+
+      cm = cxManager;
+
+      ActiveMQRAConnectionFactory cf = new ActiveMQRAConnectionFactoryImpl(this, cm);
+
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("Created connection factory: " + cf +
+                                         ", using connection manager: " +
+                                         cm);
+      }
+      return cf;
+   }
+
+   /**
+    * Creates a new physical connection to the underlying EIS resource manager.
+    *
+    * @param subject       Caller's security information
+    * @param cxRequestInfo Additional resource adapter specific connection request information
+    * @return The managed connection
+    * @throws ResourceException Thrown if a managed connection can't be created
+    */
+   public ManagedConnection createManagedConnection(final Subject subject, final ConnectionRequestInfo cxRequestInfo) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("createManagedConnection(" + subject + ", " + cxRequestInfo + ")");
+      }
+
+      ActiveMQRAConnectionRequestInfo cri = getCRI((ActiveMQRAConnectionRequestInfo) cxRequestInfo);
+
+      ActiveMQRACredential credential = ActiveMQRACredential.getCredential(this, subject, cri);
+
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("jms credential: " + credential);
+      }
+
+      ActiveMQRAManagedConnection mc = new ActiveMQRAManagedConnection(this,
+                                                                     cri,
+                                                                     ra,
+                                                                     credential.getUserName(),
+                                                                     credential.getPassword());
+
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("created new managed connection: " + mc);
+      }
+
+      registerRecovery();
+
+      return mc;
+   }
+
+   private synchronized void registerRecovery()
+   {
+      if (recoveryConnectionFactory == null)
+      {
+         recoveryConnectionFactory = ra.createRecoveryActiveMQConnectionFactory(mcfProperties);
+         resourceRecovery = ra.getRecoveryManager().register(recoveryConnectionFactory, null, null);
+      }
+   }
+
+   public XARecoveryConfig getResourceRecovery()
+   {
+      return resourceRecovery;
+   }
+
+   /**
+    * Returns a matched connection from the candidate set of connections.
+    *
+    * @param connectionSet The candidate connection set
+    * @param subject       Caller's security information
+    * @param cxRequestInfo Additional resource adapter specific connection request information
+    * @return The managed connection
+    * @throws ResourceException Thrown if the managed connection can not be found
+    */
+   public ManagedConnection matchManagedConnections(@SuppressWarnings("rawtypes") final Set connectionSet, final Subject subject, final ConnectionRequestInfo cxRequestInfo) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("matchManagedConnections(" + connectionSet +
+                                         ", " +
+                                         subject +
+                                         ", " +
+                                         cxRequestInfo +
+                                         ")");
+      }
+
+      ActiveMQRAConnectionRequestInfo cri = getCRI((ActiveMQRAConnectionRequestInfo) cxRequestInfo);
+      ActiveMQRACredential credential = ActiveMQRACredential.getCredential(this, subject, cri);
+
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("Looking for connection matching credentials: " + credential);
+      }
+
+      Iterator<?> connections = connectionSet.iterator();
+
+      while (connections.hasNext())
+      {
+         Object obj = connections.next();
+
+         if (obj instanceof ActiveMQRAManagedConnection)
+         {
+            ActiveMQRAManagedConnection mc = (ActiveMQRAManagedConnection) obj;
+            ManagedConnectionFactory mcf = mc.getManagedConnectionFactory();
+
+            if ((mc.getUserName() == null || mc.getUserName() != null && mc.getUserName()
+               .equals(credential.getUserName())) && mcf.equals(this))
+            {
+               if (cri.equals(mc.getCRI()))
+               {
+                  if (ActiveMQRAManagedConnectionFactory.trace)
+                  {
+                     ActiveMQRALogger.LOGGER.trace("Found matching connection: " + mc);
+                  }
+
+                  return mc;
+               }
+            }
+         }
+      }
+
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("No matching connection was found");
+      }
+
+      return null;
+   }
+
+   /**
+    * Set the log writer -- NOT SUPPORTED
+    *
+    * @param out The writer
+    * @throws ResourceException Thrown if the writer can't be set
+    */
+   public void setLogWriter(final PrintWriter out) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setLogWriter(" + out + ")");
+      }
+   }
+
+   /**
+    * Get the log writer -- NOT SUPPORTED
+    *
+    * @return The writer
+    * @throws ResourceException Thrown if the writer can't be retrieved
+    */
+   public PrintWriter getLogWriter() throws ResourceException
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getLogWriter()");
+      }
+
+      return null;
+   }
+
+   /**
+    * Get the resource adapter
+    *
+    * @return The resource adapter
+    */
+   public ResourceAdapter getResourceAdapter()
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getResourceAdapter()");
+      }
+
+      return ra;
+   }
+
+   /**
+    * Set the resource adapter
+    * <p/>
+    * This should ensure that when the RA is stopped, this MCF will be stopped as well.
+    *
+    * @param ra The resource adapter
+    * @throws ResourceException Thrown if incorrect resource adapter
+    */
+   public void setResourceAdapter(final ResourceAdapter ra) throws ResourceException
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setResourceAdapter(" + ra + ")");
+      }
+
+      if (ra == null || !(ra instanceof ActiveMQResourceAdapter))
+      {
+         throw new ResourceException("Resource adapter is " + ra);
+      }
+
+      this.ra = (ActiveMQResourceAdapter) ra;
+      this.ra.setManagedConnectionFactory(this);
+   }
+
+   /**
+    * Indicates whether some other object is "equal to" this one.
+    *
+    * @param obj Object with which to compare
+    * @return True if this object is the same as the obj argument; false otherwise.
+    */
+   @Override
+   public boolean equals(final Object obj)
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("equals(" + obj + ")");
+      }
+
+      if (obj == null)
+      {
+         return false;
+      }
+
+      if (obj instanceof ActiveMQRAManagedConnectionFactory)
+      {
+         ActiveMQRAManagedConnectionFactory other = (ActiveMQRAManagedConnectionFactory) obj;
+
+         return mcfProperties.equals(other.getProperties()) && ra.equals(other.getResourceAdapter());
+      }
+      else
+      {
+         return false;
+      }
+   }
+
+   /**
+    * Return the hash code for the object
+    *
+    * @return The hash code
+    */
+   @Override
+   public int hashCode()
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("hashCode()");
+      }
+
+      int hash = mcfProperties.hashCode();
+      hash += 31 * ra.hashCode();
+
+      return hash;
+   }
+
+   /**
+    * Get the default session type
+    *
+    * @return The value
+    */
+   public String getSessionDefaultType()
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getSessionDefaultType()");
+      }
+
+      return mcfProperties.getSessionDefaultType();
+   }
+
+   /**
+    * Set the default session type
+    *
+    * @param type either javax.jms.Topic or javax.jms.Queue
+    */
+   public void setSessionDefaultType(final String type)
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setSessionDefaultType(" + type + ")");
+      }
+
+      mcfProperties.setSessionDefaultType(type);
+   }
+
+   /**
+    * @return the connectionParameters
+    */
+   public String getConnectionParameters()
+   {
+      return mcfProperties.getStrConnectionParameters();
+   }
+
+   public void setConnectionParameters(final String configuration)
+   {
+      mcfProperties.setConnectionParameters(configuration);
+   }
+
+   /**
+    * @return the transportType
+    */
+   public String getConnectorClassName()
+   {
+      return mcfProperties.getConnectorClassName();
+   }
+
+   public void setConnectorClassName(final String value)
+   {
+      mcfProperties.setConnectorClassName(value);
+   }
+
+   public String getConnectionLoadBalancingPolicyClassName()
+   {
+      return mcfProperties.getConnectionLoadBalancingPolicyClassName();
+   }
+
+   public void setConnectionLoadBalancingPolicyClassName(final String connectionLoadBalancingPolicyClassName)
+   {
+      mcfProperties.setConnectionLoadBalancingPolicyClassName(connectionLoadBalancingPolicyClassName);
+   }
+
+   public String getDiscoveryAddress()
+   {
+      return mcfProperties.getDiscoveryAddress();
+   }
+
+   public void setDiscoveryAddress(final String discoveryAddress)
+   {
+      mcfProperties.setDiscoveryAddress(discoveryAddress);
+   }
+
+   public Integer getDiscoveryPort()
+   {
+      return mcfProperties.getDiscoveryPort();
+   }
+
+   public void setDiscoveryPort(final Integer discoveryPort)
+   {
+      mcfProperties.setDiscoveryPort(discoveryPort);
+   }
+
+   public Long getDiscoveryRefreshTimeout()
+   {
+      return mcfProperties.getDiscoveryRefreshTimeout();
+   }
+
+   public void setDiscoveryRefreshTimeout(final Long discoveryRefreshTimeout)
+   {
+      mcfProperties.setDiscoveryRefreshTimeout(discoveryRefreshTimeout);
+   }
+
+   public Long getDiscoveryInitialWaitTimeout()
+   {
+      return mcfProperties.getDiscoveryInitialWaitTimeout();
+   }
+
+   public void setDiscoveryInitialWaitTimeout(final Long discoveryInitialWaitTimeout)
+   {
+      mcfProperties.setDiscoveryInitialWaitTimeout(discoveryInitialWaitTimeout);
+   }
+
+   public String getClientID()
+   {
+      return mcfProperties.getClientID();
+   }
+
+   public void setClientID(final String clientID)
+   {
+      mcfProperties.setClientID(clientID);
+   }
+
+   public Integer getDupsOKBatchSize()
+   {
+      return mcfProperties.getDupsOKBatchSize();
+   }
+
+   public void setDupsOKBatchSize(final Integer dupsOKBatchSize)
+   {
+      mcfProperties.setDupsOKBatchSize(dupsOKBatchSize);
+   }
+
+   public Integer getTransactionBatchSize()
+   {
+      return mcfProperties.getTransactionBatchSize();
+   }
+
+   public void setTransactionBatchSize(final Integer transactionBatchSize)
+   {
+      mcfProperties.setTransactionBatchSize(transactionBatchSize);
+   }
+
+   public Long getClientFailureCheckPeriod()
+   {
+      return mcfProperties.getClientFailureCheckPeriod();
+   }
+
+   public void setClientFailureCheckPeriod(final Long clientFailureCheckPeriod)
+   {
+      mcfProperties.setClientFailureCheckPeriod(clientFailureCheckPeriod);
+   }
+
+   public Long getConnectionTTL()
+   {
+      return mcfProperties.getConnectionTTL();
+   }
+
+   public void setConnectionTTL(final Long connectionTTL)
+   {
+      mcfProperties.setConnectionTTL(connectionTTL);
+   }
+
+   public Long getCallTimeout()
+   {
+      return mcfProperties.getCallTimeout();
+   }
+
+   public void setCallTimeout(final Long callTimeout)
+   {
+      mcfProperties.setCallTimeout(callTimeout);
+   }
+
+   public Integer getConsumerWindowSize()
+   {
+      return mcfProperties.getConsumerWindowSize();
+   }
+
+   public void setConsumerWindowSize(final Integer consumerWindowSize)
+   {
+      mcfProperties.setConsumerWindowSize(consumerWindowSize);
+   }
+
+   public Integer getConsumerMaxRate()
+   {
+      return mcfProperties.getConsumerMaxRate();
+   }
+
+   public void setConsumerMaxRate(final Integer consumerMaxRate)
+   {
+      mcfProperties.setConsumerMaxRate(consumerMaxRate);
+   }
+
+   public Integer getConfirmationWindowSize()
+   {
+      return mcfProperties.getConfirmationWindowSize();
+   }
+
+   public void setConfirmationWindowSize(final Integer confirmationWindowSize)
+   {
+      mcfProperties.setConfirmationWindowSize(confirmationWindowSize);
+   }
+
+   public Integer getProducerMaxRate()
+   {
+      return mcfProperties.getProducerMaxRate();
+   }
+
+   public void setProducerMaxRate(final Integer producerMaxRate)
+   {
+      mcfProperties.setProducerMaxRate(producerMaxRate);
+   }
+
+   public Integer getMinLargeMessageSize()
+   {
+      return mcfProperties.getMinLargeMessageSize();
+   }
+
+   public void setMinLargeMessageSize(final Integer minLargeMessageSize)
+   {
+      mcfProperties.setMinLargeMessageSize(minLargeMessageSize);
+   }
+
+   public Boolean isBlockOnAcknowledge()
+   {
+      return mcfProperties.isBlockOnAcknowledge();
+   }
+
+   public void setBlockOnAcknowledge(final Boolean blockOnAcknowledge)
+   {
+      mcfProperties.setBlockOnAcknowledge(blockOnAcknowledge);
+   }
+
+   public Boolean isBlockOnNonDurableSend()
+   {
+      return mcfProperties.isBlockOnNonDurableSend();
+   }
+
+   public void setBlockOnNonDurableSend(final Boolean blockOnNonDurableSend)
+   {
+      mcfProperties.setBlockOnNonDurableSend(blockOnNonDurableSend);
+   }
+
+   public Boolean isBlockOnDurableSend()
+   {
+      return mcfProperties.isBlockOnDurableSend();
+   }
+
+   public void setBlockOnDurableSend(final Boolean blockOnDurableSend)
+   {
+      mcfProperties.setBlockOnDurableSend(blockOnDurableSend);
+   }
+
+   public Boolean isAutoGroup()
+   {
+      return mcfProperties.isAutoGroup();
+   }
+
+   public void setAutoGroup(final Boolean autoGroup)
+   {
+      mcfProperties.setAutoGroup(autoGroup);
+   }
+
+   public Boolean isPreAcknowledge()
+   {
+      return mcfProperties.isPreAcknowledge();
+   }
+
+   public void setPreAcknowledge(final Boolean preAcknowledge)
+   {
+      mcfProperties.setPreAcknowledge(preAcknowledge);
+   }
+
+   public Long getRetryInterval()
+   {
+      return mcfProperties.getRetryInterval();
+   }
+
+   public void setRetryInterval(final Long retryInterval)
+   {
+      mcfProperties.setRetryInterval(retryInterval);
+   }
+
+   public Double getRetryIntervalMultiplier()
+   {
+      return mcfProperties.getRetryIntervalMultiplier();
+   }
+
+   public void setRetryIntervalMultiplier(final Double retryIntervalMultiplier)
+   {
+      mcfProperties.setRetryIntervalMultiplier(retryIntervalMultiplier);
+   }
+
+   public Integer getReconnectAttempts()
+   {
+      return mcfProperties.getReconnectAttempts();
+   }
+
+   public void setReconnectAttempts(final Integer reconnectAttempts)
+   {
+      mcfProperties.setReconnectAttempts(reconnectAttempts);
+   }
+
+   public Boolean isUseGlobalPools()
+   {
+      return mcfProperties.isUseGlobalPools();
+   }
+
+   public void setUseGlobalPools(final Boolean useGlobalPools)
+   {
+      mcfProperties.setUseGlobalPools(useGlobalPools);
+   }
+
+   public Integer getScheduledThreadPoolMaxSize()
+   {
+      return mcfProperties.getScheduledThreadPoolMaxSize();
+   }
+
+   public void setScheduledThreadPoolMaxSize(final Integer scheduledThreadPoolMaxSize)
+   {
+      mcfProperties.setScheduledThreadPoolMaxSize(scheduledThreadPoolMaxSize);
+   }
+
+   public Integer getThreadPoolMaxSize()
+   {
+      return mcfProperties.getThreadPoolMaxSize();
+   }
+
+   public void setThreadPoolMaxSize(final Integer threadPoolMaxSize)
+   {
+      mcfProperties.setThreadPoolMaxSize(threadPoolMaxSize);
+   }
+
+   public Boolean isHA()
+   {
+      return mcfProperties.isHA();
+   }
+
+   public void setHA(Boolean ha)
+   {
+      mcfProperties.setHA(ha);
+   }
+
+   /**
+    * Get the useTryLock.
+    *
+    * @return the useTryLock.
+    */
+   public Integer getUseTryLock()
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getUseTryLock()");
+      }
+
+      return mcfProperties.getUseTryLock();
+   }
+
+   /**
+    * Set the useTryLock.
+    *
+    * @param useTryLock the useTryLock.
+    */
+   public void setUseTryLock(final Integer useTryLock)
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setUseTryLock(" + useTryLock + ")");
+      }
+
+      mcfProperties.setUseTryLock(useTryLock);
+   }
+
+   /**
+    * Get the connection metadata
+    *
+    * @return The metadata
+    */
+   public ConnectionMetaData getMetaData()
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getMetadata()");
+      }
+
+      return new ActiveMQRAConnectionMetaData();
+   }
+
+   /**
+    * Get the managed connection factory properties
+    *
+    * @return The properties
+    */
+   protected ActiveMQRAMCFProperties getProperties()
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getProperties()");
+      }
+
+      return mcfProperties;
+   }
+
+   /**
+    * Get a connection request info instance
+    *
+    * @param info The instance that should be updated; may be <code>null</code>
+    * @return The instance
+    */
+   private ActiveMQRAConnectionRequestInfo getCRI(final ActiveMQRAConnectionRequestInfo info)
+   {
+      if (ActiveMQRAManagedConnectionFactory.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getCRI(" + info + ")");
+      }
+
+      if (info == null)
+      {
+         // Create a default one
+         return new ActiveMQRAConnectionRequestInfo(ra.getProperties(), mcfProperties.getType());
+      }
+      else
+      {
+         // Fill the one with any defaults
+         info.setDefaults(ra.getProperties());
+         return info;
+      }
+   }
+
+   // this should be called when ActiveMQResourceAdapter.stop() is called since this MCF is registered with it
+   public void stop()
+   {
+      if (resourceRecovery != null)
+      {
+         ra.getRecoveryManager().unRegister(resourceRecovery);
+      }
+
+      if (recoveryConnectionFactory != null)
+      {
+         recoveryConnectionFactory.close();
+         recoveryConnectionFactory = null;
+      }
+   }
+}

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMapMessage.java
----------------------------------------------------------------------
diff --git a/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMapMessage.java b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMapMessage.java
new file mode 100644
index 0000000..8affe60
--- /dev/null
+++ b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMapMessage.java
@@ -0,0 +1,452 @@
+/*
+ * Copyright 2005-2014 Red Hat, Inc.
+ * Red Hat 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.activemq.ra;
+
+import java.util.Arrays;
+import java.util.Enumeration;
+
+import javax.jms.JMSException;
+import javax.jms.MapMessage;
+
+
+/**
+ * A wrapper for a message
+ *
+ * @author <a href="mailto:adrian@jboss.com">Adrian Brock</a>
+ * @author <a href="mailto:jesper.pedersen@jboss.org">Jesper Pedersen</a>
+ * @version $Revision: 71554 $
+ */
+public class ActiveMQRAMapMessage extends ActiveMQRAMessage implements MapMessage
+{
+   /** Whether trace is enabled */
+   private static boolean trace = ActiveMQRALogger.LOGGER.isTraceEnabled();
+
+   /**
+    * Create a new wrapper
+    *
+    * @param message the message
+    * @param session the session
+    */
+   public ActiveMQRAMapMessage(final MapMessage message, final ActiveMQRASession session)
+   {
+      super(message, session);
+
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("constructor(" + message + ", " + session + ")");
+      }
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public boolean getBoolean(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getBoolean(" + name + ")");
+      }
+
+      return ((MapMessage)message).getBoolean(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public byte getByte(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getByte(" + name + ")");
+      }
+
+      return ((MapMessage)message).getByte(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public byte[] getBytes(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getBytes(" + name + ")");
+      }
+
+      return ((MapMessage)message).getBytes(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public char getChar(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getChar(" + name + ")");
+      }
+
+      return ((MapMessage)message).getChar(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public double getDouble(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getDouble(" + name + ")");
+      }
+
+      return ((MapMessage)message).getDouble(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public float getFloat(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getFloat(" + name + ")");
+      }
+
+      return ((MapMessage)message).getFloat(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public int getInt(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getInt(" + name + ")");
+      }
+
+      return ((MapMessage)message).getInt(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public long getLong(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getLong(" + name + ")");
+      }
+
+      return ((MapMessage)message).getLong(name);
+   }
+
+   /**
+    * Get the map names
+    * @return The values
+    * @exception JMSException Thrown if an error occurs
+    */
+   @SuppressWarnings("rawtypes")
+   public Enumeration getMapNames() throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getMapNames()");
+      }
+
+      return ((MapMessage)message).getMapNames();
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public Object getObject(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getObject(" + name + ")");
+      }
+
+      return ((MapMessage)message).getObject(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public short getShort(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getShort(" + name + ")");
+      }
+
+      return ((MapMessage)message).getShort(name);
+   }
+
+   /**
+    * Get
+    * @param name The name
+    * @return The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public String getString(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getString(" + name + ")");
+      }
+
+      return ((MapMessage)message).getString(name);
+   }
+
+   /**
+    * Does the item exist
+    * @param name The name
+    * @return True / false
+    * @exception JMSException Thrown if an error occurs
+    */
+   public boolean itemExists(final String name) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("itemExists(" + name + ")");
+      }
+
+      return ((MapMessage)message).itemExists(name);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setBoolean(final String name, final boolean value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setBoolean(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setBoolean(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setByte(final String name, final byte value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setByte(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setByte(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @param offset The offset
+    * @param length The length
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setBytes(final String name, final byte[] value, final int offset, final int length) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setBytes(" + name + ", " + Arrays.toString(value) + ", " + offset + ", " +
+                  length + ")");
+      }
+
+      ((MapMessage)message).setBytes(name, value, offset, length);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setBytes(final String name, final byte[] value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setBytes(" + name + ", " + Arrays.toString(value) + ")");
+      }
+
+      ((MapMessage)message).setBytes(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setChar(final String name, final char value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setChar(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setChar(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setDouble(final String name, final double value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setDouble(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setDouble(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setFloat(final String name, final float value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setFloat(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setFloat(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setInt(final String name, final int value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setInt(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setInt(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setLong(final String name, final long value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setLong(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setLong(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setObject(final String name, final Object value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setObject(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setObject(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setShort(final String name, final short value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setShort(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setShort(name, value);
+   }
+
+   /**
+    * Set
+    * @param name The name
+    * @param value The value
+    * @exception JMSException Thrown if an error occurs
+    */
+   public void setString(final String name, final String value) throws JMSException
+   {
+      if (ActiveMQRAMapMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setString(" + name + ", " + value + ")");
+      }
+
+      ((MapMessage)message).setString(name, value);
+   }
+}

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMessage.java
----------------------------------------------------------------------
diff --git a/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMessage.java b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMessage.java
new file mode 100644
index 0000000..565ab15
--- /dev/null
+++ b/activemq-ra/src/main/java/org/apache/activemq/ra/ActiveMQRAMessage.java
@@ -0,0 +1,897 @@
+/*
+ * Copyright 2005-2014 Red Hat, Inc.
+ * Red Hat 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.activemq.ra;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import java.util.Arrays;
+import java.util.Enumeration;
+
+
+/**
+ * A wrapper for a message
+ *
+ * @author <a href="mailto:adrian@jboss.com">Adrian Brock</a>
+ * @author <a href="mailto:jesper.pedersen@jboss.org">Jesper Pedersen</a>
+ */
+public class ActiveMQRAMessage implements Message
+{
+   /**
+    * Whether trace is enabled
+    */
+   private static boolean trace = ActiveMQRALogger.LOGGER.isTraceEnabled();
+
+   /**
+    * The message
+    */
+   protected Message message;
+
+   /**
+    * The session
+    */
+   protected ActiveMQRASession session;
+
+   /**
+    * Create a new wrapper
+    *
+    * @param message the message
+    * @param session the session
+    */
+   public ActiveMQRAMessage(final Message message, final ActiveMQRASession session)
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("constructor(" + message + ", " + session + ")");
+      }
+
+      this.message = message;
+      this.session = session;
+   }
+
+   /**
+    * Acknowledge
+    *
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void acknowledge() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("acknowledge()");
+      }
+
+      session.getSession(); // Check for closed
+      message.acknowledge();
+   }
+
+   /**
+    * Clear body
+    *
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void clearBody() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("clearBody()");
+      }
+
+      message.clearBody();
+   }
+
+   /**
+    * Clear properties
+    *
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void clearProperties() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("clearProperties()");
+      }
+
+      message.clearProperties();
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public boolean getBooleanProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getBooleanProperty(" + name + ")");
+      }
+
+      return message.getBooleanProperty(name);
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public byte getByteProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getByteProperty(" + name + ")");
+      }
+
+      return message.getByteProperty(name);
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public double getDoubleProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getDoubleProperty(" + name + ")");
+      }
+
+      return message.getDoubleProperty(name);
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public float getFloatProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getFloatProperty(" + name + ")");
+      }
+
+      return message.getFloatProperty(name);
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public int getIntProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getIntProperty(" + name + ")");
+      }
+
+      return message.getIntProperty(name);
+   }
+
+   /**
+    * Get correlation id
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public String getJMSCorrelationID() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSCorrelationID()");
+      }
+
+      return message.getJMSCorrelationID();
+   }
+
+   /**
+    * Get correlation id
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public byte[] getJMSCorrelationIDAsBytes() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSCorrelationIDAsBytes()");
+      }
+
+      return message.getJMSCorrelationIDAsBytes();
+   }
+
+   /**
+    * Get delivery mode
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public int getJMSDeliveryMode() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSDeliveryMode()");
+      }
+
+      return message.getJMSDeliveryMode();
+   }
+
+   /**
+    * Get destination
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public Destination getJMSDestination() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSDestination()");
+      }
+
+      return message.getJMSDestination();
+   }
+
+   /**
+    * Get expiration
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public long getJMSExpiration() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSExpiration()");
+      }
+
+      return message.getJMSExpiration();
+   }
+
+   /**
+    * Get message id
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public String getJMSMessageID() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSMessageID()");
+      }
+
+      return message.getJMSMessageID();
+   }
+
+   /**
+    * Get priority
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public int getJMSPriority() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSPriority()");
+      }
+
+      return message.getJMSPriority();
+   }
+
+   /**
+    * Get redelivered status
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public boolean getJMSRedelivered() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSRedelivered()");
+      }
+
+      return message.getJMSRedelivered();
+   }
+
+   /**
+    * Get reply to destination
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public Destination getJMSReplyTo() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSReplyTo()");
+      }
+
+      return message.getJMSReplyTo();
+   }
+
+   /**
+    * Get timestamp
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public long getJMSTimestamp() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSTimestamp()");
+      }
+
+      return message.getJMSTimestamp();
+   }
+
+   /**
+    * Get type
+    *
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public String getJMSType() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSType()");
+      }
+
+      return message.getJMSType();
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public long getLongProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getLongProperty(" + name + ")");
+      }
+
+      return message.getLongProperty(name);
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public Object getObjectProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getObjectProperty(" + name + ")");
+      }
+
+      return message.getObjectProperty(name);
+   }
+
+   /**
+    * Get property names
+    *
+    * @return The values
+    * @throws JMSException Thrown if an error occurs
+    */
+   @SuppressWarnings("rawtypes")
+   public Enumeration getPropertyNames() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getPropertyNames()");
+      }
+
+      return message.getPropertyNames();
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public short getShortProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getShortProperty(" + name + ")");
+      }
+
+      return message.getShortProperty(name);
+   }
+
+   /**
+    * Get property
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public String getStringProperty(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getStringProperty(" + name + ")");
+      }
+
+      return message.getStringProperty(name);
+   }
+
+   /**
+    * Do property exist
+    *
+    * @param name The name
+    * @return The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public boolean propertyExists(final String name) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("propertyExists(" + name + ")");
+      }
+
+      return message.propertyExists(name);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setBooleanProperty(final String name, final boolean value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setBooleanProperty(" + name + ", " + value + ")");
+      }
+
+      message.setBooleanProperty(name, value);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setByteProperty(final String name, final byte value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setByteProperty(" + name + ", " + value + ")");
+      }
+
+      message.setByteProperty(name, value);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setDoubleProperty(final String name, final double value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setDoubleProperty(" + name + ", " + value + ")");
+      }
+
+      message.setDoubleProperty(name, value);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setFloatProperty(final String name, final float value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setFloatProperty(" + name + ", " + value + ")");
+      }
+
+      message.setFloatProperty(name, value);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setIntProperty(final String name, final int value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setIntProperty(" + name + ", " + value + ")");
+      }
+
+      message.setIntProperty(name, value);
+   }
+
+   /**
+    * Set correlation id
+    *
+    * @param correlationID The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSCorrelationID(final String correlationID) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSCorrelationID(" + correlationID + ")");
+      }
+
+      message.setJMSCorrelationID(correlationID);
+   }
+
+   /**
+    * Set correlation id
+    *
+    * @param correlationID The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSCorrelationIDAsBytes(final byte[] correlationID) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSCorrelationIDAsBytes(" + Arrays.toString(correlationID) + ")");
+      }
+
+      message.setJMSCorrelationIDAsBytes(correlationID);
+   }
+
+   /**
+    * Set delivery mode
+    *
+    * @param deliveryMode The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSDeliveryMode(final int deliveryMode) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSDeliveryMode(" + deliveryMode + ")");
+      }
+
+      message.setJMSDeliveryMode(deliveryMode);
+   }
+
+   /**
+    * Set destination
+    *
+    * @param destination The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSDestination(final Destination destination) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSDestination(" + destination + ")");
+      }
+
+      message.setJMSDestination(destination);
+   }
+
+   /**
+    * Set expiration
+    *
+    * @param expiration The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSExpiration(final long expiration) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSExpiration(" + expiration + ")");
+      }
+
+      message.setJMSExpiration(expiration);
+   }
+
+   /**
+    * Set message id
+    *
+    * @param id The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSMessageID(final String id) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSMessageID(" + id + ")");
+      }
+
+      message.setJMSMessageID(id);
+   }
+
+   /**
+    * Set priority
+    *
+    * @param priority The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSPriority(final int priority) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSPriority(" + priority + ")");
+      }
+
+      message.setJMSPriority(priority);
+   }
+
+   /**
+    * Set redelivered status
+    *
+    * @param redelivered The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSRedelivered(final boolean redelivered) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSRedelivered(" + redelivered + ")");
+      }
+
+      message.setJMSRedelivered(redelivered);
+   }
+
+   /**
+    * Set reply to
+    *
+    * @param replyTo The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSReplyTo(final Destination replyTo) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSReplyTo(" + replyTo + ")");
+      }
+
+      message.setJMSReplyTo(replyTo);
+   }
+
+   /**
+    * Set timestamp
+    *
+    * @param timestamp The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSTimestamp(final long timestamp) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSTimestamp(" + timestamp + ")");
+      }
+
+      message.setJMSTimestamp(timestamp);
+   }
+
+   /**
+    * Set type
+    *
+    * @param type The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setJMSType(final String type) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSType(" + type + ")");
+      }
+
+      message.setJMSType(type);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setLongProperty(final String name, final long value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setLongProperty(" + name + ", " + value + ")");
+      }
+
+      message.setLongProperty(name, value);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setObjectProperty(final String name, final Object value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setObjectProperty(" + name + ", " + value + ")");
+      }
+
+      message.setObjectProperty(name, value);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setShortProperty(final String name, final short value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setShortProperty(" + name + ", " + value + ")");
+      }
+
+      message.setShortProperty(name, value);
+   }
+
+   /**
+    * Set property
+    *
+    * @param name  The name
+    * @param value The value
+    * @throws JMSException Thrown if an error occurs
+    */
+   public void setStringProperty(final String name, final String value) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setStringProperty(" + name + ", " + value + ")");
+      }
+
+      message.setStringProperty(name, value);
+   }
+
+   @Override
+   public long getJMSDeliveryTime() throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getJMSDeliveryTime()");
+      }
+      return message.getJMSDeliveryTime();
+   }
+
+   @Override
+   public void setJMSDeliveryTime(long deliveryTime) throws JMSException
+   {
+
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("setJMSDeliveryTime(" + deliveryTime + ")");
+      }
+      message.setJMSDeliveryTime(deliveryTime);
+   }
+
+   @Override
+   public <T> T getBody(Class<T> c) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("getBody(" + c + ")");
+      }
+      return message.getBody(c);
+   }
+
+   @Override
+   public boolean isBodyAssignableTo(@SuppressWarnings("rawtypes")
+                                     Class c) throws JMSException
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("isBodyAssignableTo(" + c + ")");
+      }
+      return message.isBodyAssignableTo(c);
+   }
+
+   /**
+    * Return the hash code
+    *
+    * @return The hash code
+    */
+   @Override
+   public int hashCode()
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("hashCode()");
+      }
+
+      return message.hashCode();
+   }
+
+   /**
+    * Check for equality
+    *
+    * @param object The other object
+    * @return True / false
+    */
+   @Override
+   public boolean equals(final Object object)
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("equals(" + object + ")");
+      }
+
+      if (object != null && object instanceof ActiveMQRAMessage)
+      {
+         return message.equals(((ActiveMQRAMessage)object).message);
+      }
+      else
+      {
+         return message.equals(object);
+      }
+   }
+
+   /**
+    * Return string representation
+    *
+    * @return The string
+    */
+   @Override
+   public String toString()
+   {
+      if (ActiveMQRAMessage.trace)
+      {
+         ActiveMQRALogger.LOGGER.trace("toString()");
+      }
+
+      return message.toString();
+   }
+}


Mime
View raw message