You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by an...@apache.org on 2014/11/11 19:41:46 UTC
[16/51] [abbrv] [partial] activemq-6 git commit: ACTIVEMQ6-4 - Rename
packages to ActiveMQ
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/23e8edd9/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JMSBridgeImpl.java
----------------------------------------------------------------------
diff --git a/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JMSBridgeImpl.java b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JMSBridgeImpl.java
new file mode 100644
index 0000000..be78986
--- /dev/null
+++ b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JMSBridgeImpl.java
@@ -0,0 +1,2438 @@
+/*
+ * 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.activemq6.jms.bridge.impl;
+
+import javax.jms.Connection;
+import javax.jms.ConnectionFactory;
+import javax.jms.Destination;
+import javax.jms.ExceptionListener;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.Topic;
+import javax.jms.XAConnection;
+import javax.jms.XAConnectionFactory;
+import javax.jms.XASession;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+import javax.management.StandardMBean;
+import javax.transaction.Transaction;
+import javax.transaction.TransactionManager;
+import javax.transaction.TransactionRolledbackException;
+import javax.transaction.xa.XAResource;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.activemq6.api.core.HornetQException;
+import org.apache.activemq6.api.core.HornetQInterruptedException;
+import org.apache.activemq6.api.core.client.FailoverEventListener;
+import org.apache.activemq6.api.core.client.FailoverEventType;
+import org.apache.activemq6.api.jms.HornetQJMSConstants;
+import org.apache.activemq6.jms.bridge.ConnectionFactoryFactory;
+import org.apache.activemq6.jms.bridge.DestinationFactory;
+import org.apache.activemq6.jms.bridge.HornetQJMSBridgeLogger;
+import org.apache.activemq6.jms.bridge.JMSBridge;
+import org.apache.activemq6.jms.bridge.JMSBridgeControl;
+import org.apache.activemq6.jms.bridge.QualityOfServiceMode;
+import org.apache.activemq6.jms.client.HornetQConnection;
+import org.apache.activemq6.jms.client.HornetQConnectionFactory;
+import org.apache.activemq6.jms.client.HornetQMessage;
+import org.apache.activemq6.jms.server.HornetQJMSServerBundle;
+import org.apache.activemq6.jms.server.recovery.HornetQRegistryBase;
+import org.apache.activemq6.jms.server.recovery.XARecoveryConfig;
+import org.apache.activemq6.utils.ClassloadingUtil;
+import org.apache.activemq6.utils.DefaultSensitiveStringCodec;
+import org.apache.activemq6.utils.PasswordMaskingUtil;
+import org.apache.activemq6.utils.SensitiveDataCodec;
+
+/**
+ * A JMSBridge
+ *
+ * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>
+ * @author <a href="mailto:mtaylor@redhat.com">Martyn Taylor</a>
+ * @version <tt>$Revision:4566 $</tt>
+ */
+public final class JMSBridgeImpl implements JMSBridge
+{
+ private static final String[] RESOURCE_RECOVERY_CLASS_NAMES = new String[]{"org.jboss.as.messaging.jms.AS7RecoveryRegistry"};
+
+ private static boolean trace = HornetQJMSBridgeLogger.LOGGER.isTraceEnabled();
+
+ private static final int TEN_YEARS = 60 * 60 * 24 * 365 * 10; // in ms
+
+ private static final long DEFAULT_FAILOVER_TIMEOUT = 60 * 1000;
+
+ private final Object lock = new Object();
+
+ private String sourceUsername;
+
+ private String sourcePassword;
+
+ private String targetUsername;
+
+ private String targetPassword;
+
+ private TransactionManager tm;
+
+ private String selector;
+
+ private long failureRetryInterval;
+
+ private int maxRetries;
+
+ private QualityOfServiceMode qualityOfServiceMode;
+
+ private int maxBatchSize;
+
+ private long maxBatchTime;
+
+ private String subName;
+
+ private String clientID;
+
+ private volatile boolean addMessageIDInHeader;
+
+ private boolean started;
+
+ private final Object stoppingGuard = new Object();
+ private boolean stopping = false;
+
+ private final LinkedList<Message> messages;
+
+ private ConnectionFactoryFactory sourceCff;
+
+ private ConnectionFactoryFactory targetCff;
+
+ private DestinationFactory sourceDestinationFactory;
+
+ private DestinationFactory targetDestinationFactory;
+
+ private Connection sourceConn;
+
+ private Connection targetConn;
+
+ private Destination sourceDestination;
+
+ private Destination targetDestination;
+
+ private Session sourceSession;
+
+ private Session targetSession;
+
+ private MessageConsumer sourceConsumer;
+
+ private MessageProducer targetProducer;
+
+ private BatchTimeChecker timeChecker;
+
+ private ExecutorService executor;
+
+ private long batchExpiryTime;
+
+ private boolean paused;
+
+ private Transaction tx;
+
+ private boolean failed;
+
+ private boolean connectedSource = false;
+
+ private boolean connectedTarget = false;
+
+ private int forwardMode;
+
+ private String transactionManagerLocatorClass = "org.apache.activemq6.integration.jboss.tm.JBoss5TransactionManagerLocator";
+
+ private String transactionManagerLocatorMethod = "getTm";
+
+ private MBeanServer mbeanServer;
+
+ private ObjectName objectName;
+
+ private boolean useMaskedPassword = false;
+
+ private String passwordCodec;
+
+ private long failoverTimeout;
+
+ private static final int FORWARD_MODE_XA = 0;
+
+ private static final int FORWARD_MODE_LOCALTX = 1;
+
+ private static final int FORWARD_MODE_NONTX = 2;
+
+ private HornetQRegistryBase registry;
+
+ /*
+ * Constructor for MBean
+ */
+ public JMSBridgeImpl()
+ {
+ messages = new LinkedList<Message>();
+ executor = createExecutor();
+ }
+
+ public JMSBridgeImpl(final ConnectionFactoryFactory sourceCff,
+ final ConnectionFactoryFactory targetCff,
+ final DestinationFactory sourceDestinationFactory,
+ final DestinationFactory targetDestinationFactory,
+ final String sourceUsername,
+ final String sourcePassword,
+ final String targetUsername,
+ final String targetPassword,
+ final String selector,
+ final long failureRetryInterval,
+ final int maxRetries,
+ final QualityOfServiceMode qosMode,
+ final int maxBatchSize,
+ final long maxBatchTime,
+ final String subName,
+ final String clientID,
+ final boolean addMessageIDInHeader)
+ {
+
+ this(sourceCff,
+ targetCff,
+ sourceDestinationFactory,
+ targetDestinationFactory,
+ sourceUsername,
+ sourcePassword,
+ targetUsername,
+ targetPassword,
+ selector,
+ failureRetryInterval,
+ maxRetries,
+ qosMode,
+ maxBatchSize,
+ maxBatchTime,
+ subName,
+ clientID,
+ addMessageIDInHeader,
+ null,
+ null);
+ }
+
+ public JMSBridgeImpl(final ConnectionFactoryFactory sourceCff,
+ final ConnectionFactoryFactory targetCff,
+ final DestinationFactory sourceDestinationFactory,
+ final DestinationFactory targetDestinationFactory,
+ final String sourceUsername,
+ final String sourcePassword,
+ final String targetUsername,
+ final String targetPassword,
+ final String selector,
+ final long failureRetryInterval,
+ final int maxRetries,
+ final QualityOfServiceMode qosMode,
+ final int maxBatchSize,
+ final long maxBatchTime,
+ final String subName,
+ final String clientID,
+ final boolean addMessageIDInHeader,
+ final MBeanServer mbeanServer,
+ final String objectName)
+ {
+ this(sourceCff,
+ targetCff,
+ sourceDestinationFactory,
+ targetDestinationFactory,
+ sourceUsername,
+ sourcePassword,
+ targetUsername,
+ targetPassword,
+ selector,
+ failureRetryInterval,
+ maxRetries,
+ qosMode,
+ maxBatchSize,
+ maxBatchTime,
+ subName,
+ clientID,
+ addMessageIDInHeader,
+ mbeanServer,
+ objectName,
+ DEFAULT_FAILOVER_TIMEOUT);
+ }
+
+ public JMSBridgeImpl(final ConnectionFactoryFactory sourceCff,
+ final ConnectionFactoryFactory targetCff,
+ final DestinationFactory sourceDestinationFactory,
+ final DestinationFactory targetDestinationFactory,
+ final String sourceUsername,
+ final String sourcePassword,
+ final String targetUsername,
+ final String targetPassword,
+ final String selector,
+ final long failureRetryInterval,
+ final int maxRetries,
+ final QualityOfServiceMode qosMode,
+ final int maxBatchSize,
+ final long maxBatchTime,
+ final String subName,
+ final String clientID,
+ final boolean addMessageIDInHeader,
+ final MBeanServer mbeanServer,
+ final String objectName,
+ final long failoverTimeout)
+ {
+ this();
+
+ this.sourceCff = sourceCff;
+
+ this.targetCff = targetCff;
+
+ this.sourceDestinationFactory = sourceDestinationFactory;
+
+ this.targetDestinationFactory = targetDestinationFactory;
+
+ this.sourceUsername = sourceUsername;
+
+ this.sourcePassword = sourcePassword;
+
+ this.targetUsername = targetUsername;
+
+ this.targetPassword = targetPassword;
+
+ this.selector = selector;
+
+ this.failureRetryInterval = failureRetryInterval;
+
+ this.maxRetries = maxRetries;
+
+ qualityOfServiceMode = qosMode;
+
+ this.maxBatchSize = maxBatchSize;
+
+ this.maxBatchTime = maxBatchTime;
+
+ this.subName = subName;
+
+ this.clientID = clientID;
+
+ this.addMessageIDInHeader = addMessageIDInHeader;
+
+ this.failoverTimeout = failoverTimeout;
+
+ checkParams();
+
+ if (mbeanServer != null)
+ {
+ if (objectName != null)
+ {
+ this.mbeanServer = mbeanServer;
+
+ try
+ {
+ JMSBridgeControlImpl controlBean = new JMSBridgeControlImpl(this);
+ this.objectName = ObjectName.getInstance(objectName);
+ StandardMBean mbean = new StandardMBean(controlBean, JMSBridgeControl.class);
+ mbeanServer.registerMBean(mbean, this.objectName);
+ HornetQJMSBridgeLogger.LOGGER.debug("Registered JMSBridge instance as: " + this.objectName.getCanonicalName());
+ }
+ catch (Exception e)
+ {
+ throw new IllegalStateException("Failed to register JMSBridge MBean", e);
+ }
+ }
+ else
+ {
+ throw new IllegalArgumentException("objectName is required when specifying an MBeanServer");
+ }
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Created " + this);
+ }
+ }
+
+ // HornetQComponent overrides --------------------------------------------------
+
+ public synchronized void start() throws Exception
+ {
+ synchronized (stoppingGuard)
+ {
+ stopping = false;
+ }
+
+ locateRecoveryRegistry();
+
+ if (started)
+ {
+ HornetQJMSBridgeLogger.LOGGER.errorBridgeAlreadyStarted();
+ return;
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Starting " + this);
+ }
+
+ // bridge has been stopped and is restarted
+ if (executor.isShutdown())
+ {
+ executor = createExecutor();
+ }
+
+ initPasswords();
+
+ checkParams();
+
+ TransactionManager tm = getTm();
+
+ // There may already be a JTA transaction associated to the thread
+
+ boolean ok;
+
+ Transaction toResume = null;
+ try
+ {
+ toResume = tm.suspend();
+
+ ok = setupJMSObjects();
+ }
+ finally
+ {
+ if (toResume != null)
+ {
+ tm.resume(toResume);
+ }
+ }
+
+ if (ok)
+ {
+ connectedSource = true;
+ connectedTarget = true;
+ startSource();
+ }
+ else
+ {
+ HornetQJMSBridgeLogger.LOGGER.errorStartingBridge();
+ handleFailureOnStartup();
+ }
+
+ }
+
+ private void startSource() throws JMSException
+ {
+ // start the source connection
+
+ sourceConn.start();
+
+ started = true;
+
+ if (maxBatchTime != -1)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Starting time checker thread");
+ }
+
+ timeChecker = new BatchTimeChecker();
+
+ executor.execute(timeChecker);
+ batchExpiryTime = System.currentTimeMillis() + maxBatchTime;
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Started time checker thread");
+ }
+ }
+
+ executor.execute(new SourceReceiver());
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Started " + this);
+ }
+ }
+
+ private void initPasswords() throws HornetQException
+ {
+ if (useMaskedPassword)
+ {
+ SensitiveDataCodec<String> codecInstance = new DefaultSensitiveStringCodec();
+
+ if (passwordCodec != null)
+ {
+ codecInstance = PasswordMaskingUtil.getCodec(passwordCodec);
+ }
+
+ try
+ {
+ if (this.sourcePassword != null)
+ {
+ sourcePassword = codecInstance.decode(sourcePassword);
+ }
+
+ if (this.targetPassword != null)
+ {
+ targetPassword = codecInstance.decode(targetPassword);
+ }
+ }
+ catch (Exception e)
+ {
+ throw HornetQJMSServerBundle.BUNDLE.errorDecodingPassword(e);
+ }
+
+ }
+ }
+
+ public void stop() throws Exception
+ {
+ synchronized (stoppingGuard)
+ {
+ if (stopping) return;
+ stopping = true;
+ }
+
+ synchronized (this)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Stopping " + this);
+ }
+ if (!connectedSource && sourceConn != null)
+ {
+ sourceConn.close();
+ }
+ if (!connectedTarget && targetConn != null)
+ {
+ targetConn.close();
+ }
+ synchronized (lock)
+ {
+ started = false;
+
+ executor.shutdownNow();
+ }
+
+ boolean ok = executor.awaitTermination(60, TimeUnit.SECONDS);
+
+ if (!ok)
+ {
+ throw new Exception("fail to stop JMS Bridge");
+ }
+
+ if (tx != null)
+ {
+ // Terminate any transaction
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Rolling back remaining tx");
+ }
+
+ try
+ {
+ tx.rollback();
+ }
+ catch (Exception ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to rollback", ignore);
+ }
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Rolled back remaining tx");
+ }
+ }
+
+ try
+ {
+ sourceConn.close();
+ }
+ catch (Exception ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to close source conn", ignore);
+ }
+ }
+
+ if (targetConn != null)
+ {
+ try
+ {
+ targetConn.close();
+ }
+ catch (Exception ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to close target conn", ignore);
+ }
+ }
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Stopped " + this);
+ }
+ }
+ }
+
+ public synchronized boolean isStarted()
+ {
+ return started;
+ }
+
+ public void destroy()
+ {
+ if (mbeanServer != null && objectName != null)
+ {
+ try
+ {
+ mbeanServer.unregisterMBean(objectName);
+ }
+ catch (Exception e)
+ {
+ HornetQJMSBridgeLogger.LOGGER.errorUnregisteringBridge(objectName);
+ }
+ }
+ }
+
+ // JMSBridge implementation ------------------------------------------------------------
+
+ public synchronized void pause() throws Exception
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Pausing " + this);
+ }
+
+ synchronized (lock)
+ {
+ paused = true;
+
+ sourceConn.stop();
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Paused " + this);
+ }
+ }
+
+ public synchronized void resume() throws Exception
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Resuming " + this);
+ }
+
+ synchronized (lock)
+ {
+ paused = false;
+
+ sourceConn.start();
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Resumed " + this);
+ }
+ }
+
+ public DestinationFactory getSourceDestinationFactory()
+ {
+ return sourceDestinationFactory;
+ }
+
+ public void setSourceDestinationFactory(final DestinationFactory dest)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkNotNull(dest, "TargetDestinationFactory");
+
+ sourceDestinationFactory = dest;
+ }
+
+ public DestinationFactory getTargetDestinationFactory()
+ {
+ return targetDestinationFactory;
+ }
+
+ public void setTargetDestinationFactory(final DestinationFactory dest)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkNotNull(dest, "TargetDestinationFactory");
+
+ targetDestinationFactory = dest;
+ }
+
+ public synchronized String getSourceUsername()
+ {
+ return sourceUsername;
+ }
+
+ public synchronized void setSourceUsername(final String name)
+ {
+ checkBridgeNotStarted();
+
+ sourceUsername = name;
+ }
+
+ public synchronized String getSourcePassword()
+ {
+ return sourcePassword;
+ }
+
+ public synchronized void setSourcePassword(final String pwd)
+ {
+ checkBridgeNotStarted();
+
+ sourcePassword = pwd;
+ }
+
+ public synchronized String getTargetUsername()
+ {
+ return targetUsername;
+ }
+
+ public synchronized void setTargetUsername(final String name)
+ {
+ checkBridgeNotStarted();
+
+ targetUsername = name;
+ }
+
+ public synchronized String getTargetPassword()
+ {
+ return targetPassword;
+ }
+
+ public synchronized void setTargetPassword(final String pwd)
+ {
+ checkBridgeNotStarted();
+
+ targetPassword = pwd;
+ }
+
+ public synchronized String getSelector()
+ {
+ return selector;
+ }
+
+ public synchronized void setSelector(final String selector)
+ {
+ checkBridgeNotStarted();
+
+ this.selector = selector;
+ }
+
+ public synchronized long getFailureRetryInterval()
+ {
+ return failureRetryInterval;
+ }
+
+ public synchronized void setFailureRetryInterval(final long interval)
+ {
+ checkBridgeNotStarted();
+ if (interval < 1)
+ {
+ throw new IllegalArgumentException("FailureRetryInterval must be >= 1");
+ }
+
+ failureRetryInterval = interval;
+ }
+
+ public synchronized int getMaxRetries()
+ {
+ return maxRetries;
+ }
+
+ public synchronized void setMaxRetries(final int retries)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkValidValue(retries, "MaxRetries");
+
+ maxRetries = retries;
+ }
+
+ public synchronized QualityOfServiceMode getQualityOfServiceMode()
+ {
+ return qualityOfServiceMode;
+ }
+
+ public synchronized void setQualityOfServiceMode(final QualityOfServiceMode mode)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkNotNull(mode, "QualityOfServiceMode");
+
+ qualityOfServiceMode = mode;
+ }
+
+ public synchronized int getMaxBatchSize()
+ {
+ return maxBatchSize;
+ }
+
+ public synchronized void setMaxBatchSize(final int size)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkMaxBatchSize(size);
+
+ maxBatchSize = size;
+ }
+
+ public synchronized long getMaxBatchTime()
+ {
+ return maxBatchTime;
+ }
+
+ public synchronized void setMaxBatchTime(final long time)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkValidValue(time, "MaxBatchTime");
+
+ maxBatchTime = time;
+ }
+
+ public synchronized String getSubscriptionName()
+ {
+ return subName;
+ }
+
+ public synchronized void setSubscriptionName(final String subname)
+ {
+ checkBridgeNotStarted();
+ subName = subname;
+ }
+
+ public synchronized String getClientID()
+ {
+ return clientID;
+ }
+
+ public synchronized void setClientID(final String clientID)
+ {
+ checkBridgeNotStarted();
+
+ this.clientID = clientID;
+ }
+
+ public String getTransactionManagerLocatorClass()
+ {
+ return transactionManagerLocatorClass;
+ }
+
+ public void setTransactionManagerLocatorClass(final String transactionManagerLocatorClass)
+ {
+ checkBridgeNotStarted();
+ this.transactionManagerLocatorClass = transactionManagerLocatorClass;
+ }
+
+ public String getTransactionManagerLocatorMethod()
+ {
+ return transactionManagerLocatorMethod;
+ }
+
+ public void setTransactionManagerLocatorMethod(final String transactionManagerLocatorMethod)
+ {
+ this.transactionManagerLocatorMethod = transactionManagerLocatorMethod;
+ }
+
+ public boolean isAddMessageIDInHeader()
+ {
+ return addMessageIDInHeader;
+ }
+
+ public void setAddMessageIDInHeader(final boolean value)
+ {
+ addMessageIDInHeader = value;
+ }
+
+ public synchronized boolean isPaused()
+ {
+ return paused;
+ }
+
+ public synchronized boolean isFailed()
+ {
+ return failed;
+ }
+
+ public synchronized void setSourceConnectionFactoryFactory(final ConnectionFactoryFactory cff)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkNotNull(cff, "SourceConnectionFactoryFactory");
+
+ sourceCff = cff;
+ }
+
+ public synchronized void setTargetConnectionFactoryFactory(final ConnectionFactoryFactory cff)
+ {
+ checkBridgeNotStarted();
+ JMSBridgeImpl.checkNotNull(cff, "TargetConnectionFactoryFactory");
+
+ targetCff = cff;
+ }
+
+ public void setTransactionManager(final TransactionManager tm)
+ {
+ this.tm = tm;
+ }
+
+ // Public ---------------------------------------------------------------------------
+
+ // Private -------------------------------------------------------------------
+
+ private synchronized void checkParams()
+ {
+ checkNotNull(sourceCff, "sourceCff");
+ checkNotNull(targetCff, "targetCff");
+ checkNotNull(sourceDestinationFactory, "sourceDestinationFactory");
+ checkNotNull(targetDestinationFactory, "targetDestinationFactory");
+ checkValidValue(failureRetryInterval, "failureRetryInterval");
+ checkValidValue(maxRetries, "maxRetries");
+ if (failureRetryInterval == -1 && maxRetries > 0)
+ {
+ throw new IllegalArgumentException("If failureRetryInterval == -1 maxRetries must be set to -1");
+ }
+ checkMaxBatchSize(maxBatchSize);
+ checkValidValue(maxBatchTime, "maxBatchTime");
+ checkNotNull(qualityOfServiceMode, "qualityOfServiceMode");
+ }
+
+ /**
+ * Check the object is not null
+ *
+ * @throws IllegalArgumentException if the object is null
+ */
+ private static void checkNotNull(final Object obj, final String name)
+ {
+ if (obj == null)
+ {
+ throw new IllegalArgumentException(name + " cannot be null");
+ }
+ }
+
+ /**
+ * Check the bridge is not started
+ *
+ * @throws IllegalStateException if the bridge is started
+ */
+ private void checkBridgeNotStarted()
+ {
+ if (started)
+ {
+ throw new IllegalStateException("Cannot set bridge attributes while it is started");
+ }
+ }
+
+ /**
+ * Check that value is either equals to -1 or greater than 0
+ *
+ * @throws IllegalArgumentException if the value is not valid
+ */
+ private static void checkValidValue(final long value, final String name)
+ {
+ if (!(value == -1 || value > 0))
+ {
+ throw new IllegalArgumentException(name + " must be > 0 or -1");
+ }
+ }
+
+ private static void checkMaxBatchSize(final int size)
+ {
+ if (!(size >= 1))
+ {
+ throw new IllegalArgumentException("maxBatchSize must be >= 1");
+ }
+ }
+
+ private void enlistResources(final Transaction tx) throws Exception
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Enlisting resources in tx");
+ }
+
+ XAResource resSource = ((XASession) sourceSession).getXAResource();
+
+ tx.enlistResource(resSource);
+
+ XAResource resDest = ((XASession) targetSession).getXAResource();
+
+ tx.enlistResource(resDest);
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Enlisted resources in tx");
+ }
+ }
+
+ private void delistResources(final Transaction tx)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Delisting resources from tx");
+ }
+
+ XAResource resSource = ((XASession) sourceSession).getXAResource();
+
+ try
+ {
+ tx.delistResource(resSource, XAResource.TMSUCCESS);
+ }
+ catch (Exception e)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to delist source resource", e);
+ }
+ }
+
+ XAResource resDest = ((XASession) targetSession).getXAResource();
+
+ try
+ {
+ tx.delistResource(resDest, XAResource.TMSUCCESS);
+ }
+ catch (Exception e)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to delist target resource", e);
+ }
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Delisted resources from tx");
+ }
+ }
+
+ private Transaction startTx() throws Exception
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Starting JTA transaction");
+ }
+
+ TransactionManager tm = getTm();
+
+ // Set timeout to a large value since we do not want to time out while waiting for messages
+ // to arrive - 10 years should be enough
+ tm.setTransactionTimeout(JMSBridgeImpl.TEN_YEARS);
+
+ tm.begin();
+
+ Transaction tx = tm.getTransaction();
+
+ // Remove the association between current thread - we don't want it
+ // we will be committing /rolling back directly on the transaction object
+
+ tm.suspend();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Started JTA transaction");
+ }
+
+ return tx;
+ }
+
+ private TransactionManager getTm()
+ {
+ if (tm == null)
+ {
+ try
+ {
+ Object o = safeInitNewInstance(transactionManagerLocatorClass);
+ Method m = o.getClass().getMethod(transactionManagerLocatorMethod);
+ tm = (TransactionManager) m.invoke(o);
+ }
+ catch (Exception e)
+ {
+ throw new IllegalStateException("unable to create TransactionManager from " + transactionManagerLocatorClass +
+ "." +
+ transactionManagerLocatorMethod,
+ e);
+ }
+
+ if (tm == null)
+ {
+ throw new IllegalStateException("Cannot locate a transaction manager");
+ }
+ }
+
+ return tm;
+ }
+
+ private Connection createConnection(final String username, final String password,
+ final ConnectionFactoryFactory cff,
+ final String clientID,
+ final boolean isXA,
+ boolean isSource) throws Exception
+ {
+ Connection conn;
+
+ Object cf = cff.createConnectionFactory();
+
+ if (cf instanceof HornetQConnectionFactory && registry != null)
+ {
+ registry.register(XARecoveryConfig.newConfig((HornetQConnectionFactory) cf, username, password));
+ }
+
+ if (qualityOfServiceMode == QualityOfServiceMode.ONCE_AND_ONLY_ONCE && !(cf instanceof XAConnectionFactory))
+ {
+ throw new IllegalArgumentException("Connection factory must be XAConnectionFactory");
+ }
+
+ if (username == null)
+ {
+ if (isXA)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating an XA connection");
+ }
+ conn = ((XAConnectionFactory) cf).createXAConnection();
+ }
+ else
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating a non XA connection");
+ }
+ conn = ((ConnectionFactory) cf).createConnection();
+ }
+ }
+ else
+ {
+ if (isXA)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating an XA connection");
+ }
+ conn = ((XAConnectionFactory) cf).createXAConnection(username, password);
+ }
+ else
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating a non XA connection");
+ }
+ conn = ((ConnectionFactory) cf).createConnection(username, password);
+ }
+ }
+
+ if (clientID != null)
+ {
+ conn.setClientID(clientID);
+ }
+
+ boolean ha = false;
+ BridgeFailoverListener failoverListener = null;
+
+ if (conn instanceof HornetQConnection)
+ {
+ HornetQConnectionFactory hornetQCF = (HornetQConnectionFactory) cf;
+ ha = hornetQCF.isHA();
+
+ if (ha)
+ {
+ HornetQConnection hornetQConn = (HornetQConnection) conn;
+ failoverListener = new BridgeFailoverListener(isSource);
+ hornetQConn.setFailoverListener(failoverListener);
+ }
+ }
+
+ conn.setExceptionListener(new BridgeExceptionListener(ha, failoverListener, isSource));
+
+ return conn;
+ }
+
+ /*
+ * Source and target on same server
+ * --------------------------------
+ * If the source and target destinations are on the same server (same resource manager) then,
+ * in order to get ONCE_AND_ONLY_ONCE, we simply need to consuming and send in a single
+ * local JMS transaction.
+ *
+ * We actually use a single local transacted session for the other QoS modes too since this
+ * is more performant than using DUPS_OK_ACKNOWLEDGE or AUTO_ACKNOWLEDGE session ack modes, so effectively
+ * the QoS is upgraded.
+ *
+ * Source and target on different server
+ * -------------------------------------
+ * If the source and target destinations are on a different servers (different resource managers) then:
+ *
+ * If desired QoS is ONCE_AND_ONLY_ONCE, then we start a JTA transaction and enlist the consuming and sending
+ * XAResources in that.
+ *
+ * If desired QoS is DUPLICATES_OK then, we use CLIENT_ACKNOWLEDGE for the consuming session and
+ * AUTO_ACKNOWLEDGE (this is ignored) for the sending session if the maxBatchSize == 1, otherwise we
+ * use a local transacted session for the sending session where maxBatchSize > 1, since this is more performant
+ * When bridging a batch, we make sure to manually acknowledge the consuming session, if it is CLIENT_ACKNOWLEDGE
+ * *after* the batch has been sent
+ *
+ * If desired QoS is AT_MOST_ONCE then, if maxBatchSize == 1, we use AUTO_ACKNOWLEDGE for the consuming session,
+ * and AUTO_ACKNOWLEDGE for the sending session.
+ * If maxBatchSize > 1, we use CLIENT_ACKNOWLEDGE for the consuming session and a local transacted session for the
+ * sending session.
+ *
+ * When bridging a batch, we make sure to manually acknowledge the consuming session, if it is CLIENT_ACKNOWLEDGE
+ * *before* the batch has been sent
+ *
+ */
+ private boolean setupJMSObjects()
+ {
+ try
+ {
+ if (sourceCff == targetCff)
+ {
+ // Source and target destinations are on the server - we can get once and only once
+ // just using a local transacted session
+ // everything becomes once and only once
+
+ forwardMode = JMSBridgeImpl.FORWARD_MODE_LOCALTX;
+ }
+ else
+ {
+ // Different servers
+ if (qualityOfServiceMode == QualityOfServiceMode.ONCE_AND_ONLY_ONCE)
+ {
+ // Use XA
+ forwardMode = JMSBridgeImpl.FORWARD_MODE_XA;
+ }
+ else
+ {
+ forwardMode = JMSBridgeImpl.FORWARD_MODE_NONTX;
+ }
+ }
+
+ // Lookup the destinations
+ sourceDestination = sourceDestinationFactory.createDestination();
+
+ targetDestination = targetDestinationFactory.createDestination();
+
+ // bridging on the same server
+ if (forwardMode == JMSBridgeImpl.FORWARD_MODE_LOCALTX)
+ {
+ // We simply use a single local transacted session for consuming and sending
+
+ sourceConn = createConnection(sourceUsername, sourcePassword, sourceCff, clientID, false, true);
+ sourceSession = sourceConn.createSession(true, Session.SESSION_TRANSACTED);
+ }
+ else // bridging across different servers
+ {
+ // QoS = ONCE_AND_ONLY_ONCE
+ if (forwardMode == JMSBridgeImpl.FORWARD_MODE_XA)
+ {
+ // Create an XASession for consuming from the source
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating XA source session");
+ }
+
+ sourceConn = createConnection(sourceUsername, sourcePassword, sourceCff, clientID, true, true);
+ sourceSession = ((XAConnection) sourceConn).createXASession();
+ }
+ else // QoS = DUPLICATES_OK || AT_MOST_ONCE
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating non XA source session");
+ }
+
+ sourceConn = createConnection(sourceUsername, sourcePassword, sourceCff, clientID, false, true);
+ if (qualityOfServiceMode == QualityOfServiceMode.AT_MOST_ONCE && maxBatchSize == 1)
+ {
+ sourceSession = sourceConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
+ }
+ else
+ {
+ sourceSession = sourceConn.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+ }
+ }
+ }
+
+ if (subName == null)
+ {
+ if (selector == null)
+ {
+ sourceConsumer = sourceSession.createConsumer(sourceDestination);
+ }
+ else
+ {
+ sourceConsumer = sourceSession.createConsumer(sourceDestination, selector, false);
+ }
+ }
+ else
+ {
+ // Durable subscription
+ if (selector == null)
+ {
+ sourceConsumer = sourceSession.createDurableSubscriber((Topic) sourceDestination, subName);
+ }
+ else
+ {
+ sourceConsumer = sourceSession.createDurableSubscriber((Topic) sourceDestination, subName, selector, false);
+ }
+ }
+
+ // Now the sending session
+
+ // bridging on the same server
+ if (forwardMode == JMSBridgeImpl.FORWARD_MODE_LOCALTX)
+ {
+ targetConn = sourceConn;
+ targetSession = sourceSession;
+ }
+ else // bridging across different servers
+ {
+ // QoS = ONCE_AND_ONLY_ONCE
+ if (forwardMode == JMSBridgeImpl.FORWARD_MODE_XA)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating XA dest session");
+ }
+
+ // Create an XA session for sending to the destination
+
+ targetConn = createConnection(targetUsername, targetPassword, targetCff, null, true, false);
+
+ targetSession = ((XAConnection) targetConn).createXASession();
+ }
+ else // QoS = DUPLICATES_OK || AT_MOST_ONCE
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Creating non XA dest session");
+ }
+
+ // Create a standard session for sending to the target
+
+ // If batch size > 1 we use a transacted session since is more efficient
+
+ boolean transacted = maxBatchSize > 1;
+
+ targetConn = createConnection(targetUsername, targetPassword, targetCff, null, false, false);
+
+ targetSession = targetConn.createSession(transacted, transacted ? Session.SESSION_TRANSACTED
+ : Session.AUTO_ACKNOWLEDGE);
+ }
+ }
+
+ if (forwardMode == JMSBridgeImpl.FORWARD_MODE_XA)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Starting JTA transaction");
+ }
+
+ tx = startTx();
+
+ enlistResources(tx);
+ }
+
+ targetProducer = targetSession.createProducer(null);
+
+ return true;
+ }
+ catch (Exception e)
+ {
+ // We shouldn't log this, as it's expected when trying to connect when target/source is not available
+
+ // If this fails we should attempt to cleanup or we might end up in some weird state
+
+ // Adding a log.warn, so the use may see the cause of the failure and take actions
+ HornetQJMSBridgeLogger.LOGGER.bridgeConnectError(e);
+
+ cleanup();
+
+ return false;
+ }
+ }
+
+ private void cleanup()
+ {
+ // Stop the source connection
+ try
+ {
+ sourceConn.stop();
+ }
+ catch (Throwable ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to stop source connection", ignore);
+ }
+ }
+
+ if (tx != null)
+ {
+ try
+ {
+ delistResources(tx);
+ }
+ catch (Throwable ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to delist resources", ignore);
+ }
+ }
+ try
+ {
+ // Terminate the tx
+ tx.rollback();
+ }
+ catch (Throwable ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to rollback", ignore);
+ }
+ }
+ }
+
+ // Close the old objects
+ try
+ {
+ sourceConn.close();
+ }
+ catch (Throwable ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to close source connection", ignore);
+ }
+ }
+ try
+ {
+ if (targetConn != null)
+ {
+ targetConn.close();
+ }
+ }
+ catch (Throwable ignore)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failed to close target connection", ignore);
+ }
+ }
+ }
+
+ private void pause(final long interval)
+ {
+ long start = System.currentTimeMillis();
+ while (System.currentTimeMillis() - start < failureRetryInterval)
+ {
+ try
+ {
+ Thread.sleep(failureRetryInterval);
+ }
+ catch (InterruptedException ex)
+ {
+ }
+ }
+ }
+
+ private boolean setupJMSObjectsWithRetry()
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Setting up connections");
+ }
+
+ int count = 0;
+
+ while (true && !stopping)
+ {
+ boolean ok = setupJMSObjects();
+
+ if (ok)
+ {
+ return true;
+ }
+
+ count++;
+
+ if (maxRetries != -1 && count == maxRetries)
+ {
+ break;
+ }
+
+ HornetQJMSBridgeLogger.LOGGER.failedToSetUpBridge(failureRetryInterval);
+
+ pause(failureRetryInterval);
+ }
+
+ // If we get here then we exceeded maxRetries
+ return false;
+ }
+
+ private void sendBatch()
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Sending batch of " + messages.size() + " messages");
+ }
+
+ if (paused)
+ {
+ // Don't send now
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Paused, so not sending now");
+ }
+
+ return;
+ }
+
+ if (forwardMode == JMSBridgeImpl.FORWARD_MODE_LOCALTX)
+ {
+ sendBatchLocalTx();
+ }
+ else if (forwardMode == JMSBridgeImpl.FORWARD_MODE_XA)
+ {
+ sendBatchXA();
+ }
+ else
+ {
+ sendBatchNonTransacted();
+ }
+ }
+
+ private void sendBatchNonTransacted()
+ {
+ try
+ {
+ if (qualityOfServiceMode == QualityOfServiceMode.ONCE_AND_ONLY_ONCE ||
+ (qualityOfServiceMode == QualityOfServiceMode.AT_MOST_ONCE && maxBatchSize > 1))
+ {
+ // We client ack before sending
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Client acking source session");
+ }
+
+ messages.getLast().acknowledge();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Client acked source session");
+ }
+ }
+
+ boolean exHappened;
+
+ do
+ {
+ exHappened = false;
+ try
+ {
+ sendMessages();
+ }
+ catch (TransactionRolledbackException e)
+ {
+ HornetQJMSBridgeLogger.LOGGER.warn(e.getMessage() + ", retrying TX", e);
+ exHappened = true;
+ }
+ }
+ while (exHappened);
+
+ if (maxBatchSize > 1)
+ {
+ // The sending session is transacted - we need to commit it
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Committing target session");
+ }
+
+ targetSession.commit();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Committed target session");
+ }
+ }
+
+ if (qualityOfServiceMode == QualityOfServiceMode.DUPLICATES_OK)
+ {
+ // We client ack after sending
+
+ // Note we could actually use Session.DUPS_OK_ACKNOWLEDGE here
+ // For a slightly less strong delivery guarantee
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Client acking source session");
+ }
+
+ messages.getLast().acknowledge();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Client acked source session");
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ if (!stopping)
+ {
+ HornetQJMSBridgeLogger.LOGGER.bridgeAckError(e);
+ }
+
+ // We don't call failure otherwise failover would be broken with HornetQ
+ // We let the ExceptionListener to deal with failures
+
+ if (connectedSource)
+ {
+ try
+ {
+ sourceSession.recover();
+ }
+ catch (Throwable ignored)
+ {
+ }
+ }
+
+ }
+ finally
+ {
+ // Clear the messages
+ messages.clear();
+
+ }
+ }
+
+ private void sendBatchXA()
+ {
+ try
+ {
+ sendMessages();
+
+ // Commit the JTA transaction and start another
+ delistResources(tx);
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Committing JTA transaction");
+ }
+
+ tx.commit();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Committed JTA transaction");
+ }
+ }
+ catch (Exception e)
+ {
+ try
+ {
+ // we call this just in case there is a failure other than failover
+ tx.rollback();
+ }
+ catch (Throwable ignored)
+ {
+ }
+
+ HornetQJMSBridgeLogger.LOGGER.bridgeAckError(e);
+
+ //we don't do handle failure here because the tx
+ //may be rolledback due to failover. All failure handling
+ //will be done through exception listener.
+ //handleFailureOnSend();
+ }
+ finally
+ {
+ try
+ {
+ tx = startTx();
+
+ enlistResources(tx);
+
+ // Clear the messages
+ messages.clear();
+
+ }
+ catch (Exception e)
+ {
+ HornetQJMSBridgeLogger.LOGGER.bridgeAckError(e);
+
+ handleFailureOnSend();
+ }
+ }
+ }
+
+ private void sendBatchLocalTx()
+ {
+ try
+ {
+ sendMessages();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Committing source session");
+ }
+
+ sourceSession.commit();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Committed source session");
+ }
+
+ }
+ catch (Exception e)
+ {
+ HornetQJMSBridgeLogger.LOGGER.bridgeAckError(e);
+
+ try
+ {
+ sourceSession.rollback();
+ }
+ catch (Throwable ignored)
+ {
+ }
+ try
+ {
+ targetSession.rollback();
+ }
+ catch (Throwable ignored)
+ {
+ }
+
+ // We don't call failure here, we let the exception listener to deal with it
+ }
+ finally
+ {
+ messages.clear();
+ }
+ }
+
+ private void sendMessages() throws Exception
+ {
+ Iterator<Message> iter = messages.iterator();
+
+ Message msg = null;
+
+ while (iter.hasNext())
+ {
+ msg = iter.next();
+
+ if (addMessageIDInHeader)
+ {
+ addMessageIDInHeader(msg);
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Sending message " + msg);
+ }
+
+ // Make sure the correct time to live gets propagated
+
+ long timeToLive = msg.getJMSExpiration();
+
+ if (timeToLive != 0)
+ {
+ timeToLive -= System.currentTimeMillis();
+
+ if (timeToLive <= 0)
+ {
+ timeToLive = 1; // Should have already expired - set to 1 so it expires when it is consumed or delivered
+ }
+ }
+
+ targetProducer.send(targetDestination, msg, msg.getJMSDeliveryMode(), msg.getJMSPriority(), timeToLive);
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Sent message " + msg);
+ }
+ }
+ }
+
+ private void handleFailureOnSend()
+ {
+ handleFailure(new FailureHandler());
+ }
+
+ private void handleFailureOnStartup()
+ {
+ handleFailure(new StartupFailureHandler());
+ }
+
+ private void handleFailure(final Runnable failureHandler)
+ {
+ failed = true;
+
+ // Failure must be handled on a separate thread to the calling thread (either onMessage or start).
+ // In the case of onMessage we can't close the connection from inside the onMessage method
+ // since it will block waiting for onMessage to complete. In the case of start we want to return
+ // from the call before the connections are reestablished so that the caller is not blocked unnecessarily.
+ executor.execute(failureHandler);
+ }
+
+ private void addMessageIDInHeader(final Message msg) throws Exception
+ {
+ // We concatenate the old message id as a header in the message
+ // This allows the target to then use this as the JMSCorrelationID of any response message
+ // thus enabling a distributed request-response pattern.
+ // Each bridge (if there are more than one) in the chain can concatenate the message id
+ // So in the case of multiple bridges having routed the message this can be used in a multi-hop
+ // distributed request/response
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Adding old message id in Message header");
+ }
+
+ JMSBridgeImpl.copyProperties(msg);
+
+ String val = null;
+
+ val = msg.getStringProperty(HornetQJMSConstants.JBOSS_MESSAGING_BRIDGE_MESSAGE_ID_LIST);
+
+ if (val == null)
+ {
+ val = msg.getJMSMessageID();
+ }
+ else
+ {
+ StringBuffer sb = new StringBuffer(val);
+
+ sb.append(",").append(msg.getJMSMessageID());
+
+ val = sb.toString();
+ }
+
+ msg.setStringProperty(HornetQJMSConstants.JBOSS_MESSAGING_BRIDGE_MESSAGE_ID_LIST, val);
+ }
+
+ /*
+ * JMS does not let you add a property on received message without first
+ * calling clearProperties, so we need to save and re-add all the old properties so we
+ * don't lose them!!
+ */
+ private static void copyProperties(final Message msg) throws JMSException
+ {
+ @SuppressWarnings("unchecked")
+ Enumeration<String> en = msg.getPropertyNames();
+
+ Map<String, Object> oldProps = null;
+
+ while (en.hasMoreElements())
+ {
+ String propName = en.nextElement();
+
+ if (oldProps == null)
+ {
+ oldProps = new HashMap<String, Object>();
+ }
+
+ oldProps.put(propName, msg.getObjectProperty(propName));
+ }
+
+ msg.clearProperties();
+
+ if (oldProps != null)
+ {
+ Iterator<Entry<String, Object>> oldPropsIter = oldProps.entrySet().iterator();
+
+ while (oldPropsIter.hasNext())
+ {
+ Entry<String, Object> entry = oldPropsIter.next();
+
+ String propName = entry.getKey();
+
+ Object val = entry.getValue();
+
+ if (val instanceof byte[] == false)
+ {
+ //Can't set byte[] array props through the JMS API - if we're bridging a HornetQ message it might have such props
+ msg.setObjectProperty(propName, entry.getValue());
+ }
+ else if (msg instanceof HornetQMessage)
+ {
+ ((HornetQMessage) msg).getCoreMessage().putBytesProperty(propName, (byte[]) val);
+ }
+ }
+ }
+ }
+
+ /**
+ * Creates a 3-sized thread pool executor (1 thread for the sourceReceiver, 1 for the timeChecker
+ * and 1 for the eventual failureHandler)
+ */
+ private ExecutorService createExecutor()
+ {
+ return Executors.newFixedThreadPool(3);
+ }
+
+ // Inner classes ---------------------------------------------------------------
+
+ /**
+ * We use a Thread which polls the sourceDestination instead of a MessageListener
+ * to ensure that message delivery does not happen concurrently with
+ * transaction enlistment of the XAResource (see HORNETQ-27)
+ */
+ private final class SourceReceiver extends Thread
+ {
+ SourceReceiver()
+ {
+ super("jmsbridge-source-receiver-thread");
+ }
+
+ @Override
+ public void run()
+ {
+ while (started)
+ {
+ if (stopping)
+ {
+ return;
+ }
+ synchronized (lock)
+ {
+ if (paused || failed)
+ {
+ try
+ {
+ lock.wait(500);
+ }
+ catch (InterruptedException e)
+ {
+ if (stopping)
+ {
+ return;
+ }
+ throw new HornetQInterruptedException(e);
+ }
+ continue;
+ }
+
+ Message msg = null;
+ try
+ {
+ msg = sourceConsumer.receive(1000);
+
+ if (msg instanceof HornetQMessage)
+ {
+ // We need to check the buffer mainly in the case of LargeMessages
+ // As we need to reconstruct the buffer before resending the message
+ ((HornetQMessage) msg).checkBuffer();
+ }
+ }
+ catch (JMSException jmse)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " exception while receiving a message", jmse);
+ }
+ }
+
+ if (msg == null)
+ {
+ try
+ {
+ lock.wait(500);
+ }
+ catch (InterruptedException e)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " thread was interrupted");
+ }
+ if (stopping)
+ {
+ return;
+ }
+ throw new HornetQInterruptedException(e);
+ }
+ continue;
+ }
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " received message " + msg);
+ }
+
+ messages.add(msg);
+
+ batchExpiryTime = System.currentTimeMillis() + maxBatchTime;
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " rescheduled batchExpiryTime to " + batchExpiryTime);
+ }
+
+ if (maxBatchSize != -1 && messages.size() >= maxBatchSize)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " maxBatchSize has been reached so sending batch");
+ }
+
+ sendBatch();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " sent batch");
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private class FailureHandler implements Runnable
+ {
+ /**
+ * Start the source connection - note the source connection must not be started before
+ * otherwise messages will be received and ignored
+ */
+ protected void startSourceConnection()
+ {
+ try
+ {
+ sourceConn.start();
+ }
+ catch (JMSException e)
+ {
+ HornetQJMSBridgeLogger.LOGGER.jmsBridgeSrcConnectError(e);
+ }
+ }
+
+ protected void succeeded()
+ {
+ HornetQJMSBridgeLogger.LOGGER.bridgeReconnected();
+ connectedSource = true;
+ connectedTarget = true;
+ synchronized (lock)
+ {
+ failed = false;
+
+ startSourceConnection();
+ }
+ }
+
+ protected void failed()
+ {
+ // We haven't managed to recreate connections or maxRetries = 0
+ HornetQJMSBridgeLogger.LOGGER.errorConnectingBridge();
+
+ try
+ {
+ stop();
+ }
+ catch (Exception ignore)
+ {
+ }
+ }
+
+ public void run()
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failure handler running");
+ }
+
+ // Clear the messages
+ messages.clear();
+
+ cleanup();
+
+ boolean ok = false;
+
+ if (maxRetries > 0 || maxRetries == -1)
+ {
+ HornetQJMSBridgeLogger.LOGGER.bridgeRetry(failureRetryInterval);
+
+ pause(failureRetryInterval);
+
+ // Now we try
+ ok = setupJMSObjectsWithRetry();
+ }
+
+ if (!ok)
+ {
+ failed();
+ }
+ else
+ {
+ succeeded();
+ }
+ }
+ }
+
+ private class StartupFailureHandler extends FailureHandler
+ {
+ @Override
+ protected void failed()
+ {
+ // Don't call super
+ HornetQJMSBridgeLogger.LOGGER.bridgeNotStarted();
+ }
+
+ @Override
+ protected void succeeded()
+ {
+ // Don't call super - a bit ugly in this case but better than taking the lock twice.
+ HornetQJMSBridgeLogger.LOGGER.bridgeConnected();
+
+ synchronized (lock)
+ {
+
+ connectedSource = true;
+ connectedTarget = true;
+ failed = false;
+ started = true;
+
+ // Start the source connection - note the source connection must not be started before
+ // otherwise messages will be received and ignored
+
+ try
+ {
+ startSource();
+ }
+ catch (JMSException e)
+ {
+ HornetQJMSBridgeLogger.LOGGER.jmsBridgeSrcConnectError(e);
+ }
+ }
+ }
+ }
+
+ private class BatchTimeChecker implements Runnable
+ {
+ public void run()
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " running");
+ }
+
+ synchronized (lock)
+ {
+ while (started)
+ {
+ long toWait = batchExpiryTime - System.currentTimeMillis();
+
+ if (toWait <= 0)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " waited enough");
+ }
+
+ synchronized (lock)
+ {
+ if (!failed && !messages.isEmpty())
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " got some messages so sending batch");
+ }
+
+ sendBatch();
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " sent batch");
+ }
+ }
+ }
+
+ batchExpiryTime = System.currentTimeMillis() + maxBatchTime;
+ }
+ else
+ {
+ try
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " waiting for " + toWait);
+ }
+
+ lock.wait(toWait);
+
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " woke up");
+ }
+ }
+ catch (InterruptedException e)
+ {
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace(this + " thread was interrupted");
+ }
+ if (stopping)
+ {
+ return;
+ }
+ throw new HornetQInterruptedException(e);
+ }
+
+ }
+ }
+ }
+ }
+ }
+
+ private class BridgeExceptionListener implements ExceptionListener
+ {
+ boolean ha;
+ BridgeFailoverListener failoverListener;
+ private final boolean isSource;
+
+ public BridgeExceptionListener(boolean ha, BridgeFailoverListener failoverListener, boolean isSource)
+ {
+ this.ha = ha;
+ this.failoverListener = failoverListener;
+ this.isSource = isSource;
+ }
+
+ public void onException(final JMSException e)
+ {
+ if (stopping)
+ {
+ return;
+ }
+ HornetQJMSBridgeLogger.LOGGER.bridgeFailure(e);
+ if (isSource)
+ {
+ connectedSource = false;
+ }
+ else
+ {
+ connectedTarget = false;
+ }
+
+ synchronized (lock)
+ {
+ if (stopping)
+ {
+ return;
+ }
+ if (failed)
+ {
+ // The failure has already been detected and is being handled
+ if (JMSBridgeImpl.trace)
+ {
+ HornetQJMSBridgeLogger.LOGGER.trace("Failure recovery already in progress");
+ }
+ }
+ else
+ {
+ boolean shouldHandleFailure = true;
+ if (ha)
+ {
+ //make sure failover happened
+ shouldHandleFailure = !failoverListener.waitForFailover();
+ }
+
+ if (shouldHandleFailure)
+ {
+ handleFailure(new FailureHandler());
+ }
+ }
+ }
+ }
+ }
+
+
+ private void locateRecoveryRegistry()
+ {
+ if (registry == null)
+ {
+ for (String locatorClasse : RESOURCE_RECOVERY_CLASS_NAMES)
+ {
+ try
+ {
+ registry = (HornetQRegistryBase) safeInitNewInstance(locatorClasse);
+ }
+ catch (Throwable e)
+ {
+ HornetQJMSBridgeLogger.LOGGER.debug("unable to load recovery registry " + locatorClasse, e);
+ }
+ if (registry != null)
+ {
+ break;
+ }
+ }
+
+ if (registry != null)
+ {
+ HornetQJMSBridgeLogger.LOGGER.debug("Recovery Registry located = " + registry);
+ }
+ }
+ }
+
+ /**
+ * This seems duplicate code all over the place, but for security reasons we can't let something like this to be open in a
+ * utility class, as it would be a door to load anything you like in a safe VM.
+ * For that reason any class trying to do a privileged block should do with the AccessController directly.
+ */
+ private static Object safeInitNewInstance(final String className)
+ {
+ return AccessController.doPrivileged(new PrivilegedAction<Object>()
+ {
+ public Object run()
+ {
+ return ClassloadingUtil.newInstanceFromClassLoader(className);
+ }
+ });
+ }
+
+ public boolean isUseMaskedPassword()
+ {
+ return useMaskedPassword;
+ }
+
+ public void setUseMaskedPassword(boolean maskPassword)
+ {
+ this.useMaskedPassword = maskPassword;
+ }
+
+ public String getPasswordCodec()
+ {
+ return passwordCodec;
+ }
+
+ public void setPasswordCodec(String passwordCodec)
+ {
+ this.passwordCodec = passwordCodec;
+ }
+
+ private class BridgeFailoverListener implements FailoverEventListener
+ {
+ private final boolean isSource;
+ volatile FailoverEventType lastEvent;
+
+ public BridgeFailoverListener(boolean isSource)
+ {
+ this.isSource = isSource;
+ }
+
+ @Override
+ public void failoverEvent(FailoverEventType eventType)
+ {
+ synchronized (this)
+ {
+ lastEvent = eventType;
+ if (eventType == FailoverEventType.FAILURE_DETECTED)
+ {
+ if (isSource)
+ {
+ connectedSource = false;
+ }
+ else
+ {
+ connectedTarget = false;
+ }
+ }
+ this.notify();
+ }
+ }
+
+ //return true if failover completed successfully
+ public boolean waitForFailover()
+ {
+ long toWait = failoverTimeout;
+ long start = 0;
+ long waited = 0;
+ boolean timedOut = false;
+ FailoverEventType result = null;
+ synchronized (this)
+ {
+ while ((lastEvent == null || lastEvent == FailoverEventType.FAILURE_DETECTED))
+ {
+ try
+ {
+ if (toWait <= 0)
+ {
+ timedOut = true;
+ break;
+ }
+ start = System.currentTimeMillis();
+ this.wait(toWait);
+ }
+ catch (InterruptedException e)
+ {
+ }
+ finally
+ {
+ waited = System.currentTimeMillis() - start;
+ toWait = failoverTimeout - waited;
+ }
+ }
+ result = lastEvent;
+ lastEvent = null;
+ }
+
+ if (timedOut)
+ {
+ //timeout, presumably failover failed.
+ HornetQJMSBridgeLogger.LOGGER.debug("Timed out waiting for failover completion " + this);
+ return false;
+ }
+
+ /*
+ * make sure we reset the connected flags
+ * */
+ if (result == FailoverEventType.FAILOVER_COMPLETED)
+ {
+ if (isSource)
+ {
+ connectedSource = true;
+ }
+ else
+ {
+ connectedTarget = true;
+ }
+ return true;
+ }
+ //failover failed, need retry.
+ return false;
+ }
+ }
+
+ public long getFailoverTimeout()
+ {
+ return failoverTimeout;
+ }
+
+ public void setFailoverTimeout(long failoverTimeout)
+ {
+ this.failoverTimeout = failoverTimeout;
+ }
+
+
+}
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/23e8edd9/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIConnectionFactoryFactory.java
----------------------------------------------------------------------
diff --git a/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIConnectionFactoryFactory.java b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIConnectionFactoryFactory.java
new file mode 100644
index 0000000..8f0d1a7
--- /dev/null
+++ b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIConnectionFactoryFactory.java
@@ -0,0 +1,40 @@
+/*
+ * 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.activemq6.jms.bridge.impl;
+
+import java.util.Hashtable;
+
+import org.apache.activemq6.jms.bridge.ConnectionFactoryFactory;
+
+
+/**
+ * A JNDIConnectionFactoryFactory
+ *
+ * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>
+ * @version <tt>$Revision:4566 $</tt>
+ *
+ *
+ */
+public class JNDIConnectionFactoryFactory extends JNDIFactorySupport implements ConnectionFactoryFactory
+{
+ public JNDIConnectionFactoryFactory(final Hashtable jndiProperties, final String lookup)
+ {
+ super(jndiProperties, lookup);
+ }
+
+ public Object createConnectionFactory() throws Exception
+ {
+ return createObject();
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/23e8edd9/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIDestinationFactory.java
----------------------------------------------------------------------
diff --git a/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIDestinationFactory.java b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIDestinationFactory.java
new file mode 100644
index 0000000..ee41965
--- /dev/null
+++ b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIDestinationFactory.java
@@ -0,0 +1,40 @@
+/*
+ * 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.activemq6.jms.bridge.impl;
+
+import java.util.Hashtable;
+
+import javax.jms.Destination;
+
+import org.apache.activemq6.jms.bridge.DestinationFactory;
+
+
+/**
+ *
+ * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>
+ * @version <tt>$Revision: $</tt>10 Oct 2007
+ *
+ *
+ */
+public class JNDIDestinationFactory extends JNDIFactorySupport implements DestinationFactory
+{
+ public JNDIDestinationFactory(final Hashtable jndiProperties, final String lookup)
+ {
+ super(jndiProperties, lookup);
+ }
+
+ public Destination createDestination() throws Exception
+ {
+ return (Destination)createObject();
+ }
+}
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/23e8edd9/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIFactorySupport.java
----------------------------------------------------------------------
diff --git a/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIFactorySupport.java b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIFactorySupport.java
new file mode 100644
index 0000000..46fa3ce
--- /dev/null
+++ b/activemq6-jms-server/src/main/java/org/apache/activemq6/jms/bridge/impl/JNDIFactorySupport.java
@@ -0,0 +1,67 @@
+/*
+ * 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.activemq6.jms.bridge.impl;
+
+import java.util.Hashtable;
+
+import javax.naming.InitialContext;
+
+/**
+ *
+ * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>
+ * @version <tt>$Revision: $</tt>10 Oct 2007
+ *
+ *
+ */
+public abstract class JNDIFactorySupport
+{
+ protected Hashtable jndiProperties;
+
+ protected String lookup;
+
+ protected JNDIFactorySupport(final Hashtable jndiProperties, final String lookup)
+ {
+ this.jndiProperties = jndiProperties;
+
+ this.lookup = lookup;
+ }
+
+ protected Object createObject() throws Exception
+ {
+ InitialContext ic = null;
+
+ Object obj = null;
+
+ try
+ {
+ if (jndiProperties == null)
+ {
+ ic = new InitialContext();
+ }
+ else
+ {
+ ic = new InitialContext(jndiProperties);
+ }
+
+ obj = ic.lookup(lookup);
+ }
+ finally
+ {
+ if (ic != null)
+ {
+ ic.close();
+ }
+ }
+ return obj;
+ }
+}