org.apache.activemq.artemis.jms.client.ActiveMQConnection Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.activemq.artemis.jms.client;
import javax.jms.ConnectionConsumer;
import javax.jms.ConnectionMetaData;
import javax.jms.Destination;
import javax.jms.ExceptionListener;
import javax.jms.IllegalStateException;
import javax.jms.InvalidClientIDException;
import javax.jms.JMSException;
import javax.jms.JMSRuntimeException;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueSession;
import javax.jms.ServerSessionPool;
import javax.jms.Session;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicSession;
import java.lang.ref.WeakReference;
import java.util.HashSet;
import java.util.Set;
import org.apache.activemq.artemis.api.core.ActiveMQException;
import org.apache.activemq.artemis.api.core.ActiveMQExceptionType;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.api.core.client.ClientSession;
import org.apache.activemq.artemis.api.core.client.ClientSessionFactory;
import org.apache.activemq.artemis.api.core.client.FailoverEventListener;
import org.apache.activemq.artemis.api.core.client.FailoverEventType;
import org.apache.activemq.artemis.api.core.client.SessionFailureListener;
import org.apache.activemq.artemis.api.jms.ActiveMQJMSConstants;
import org.apache.activemq.artemis.core.client.impl.ClientSessionInternal;
import org.apache.activemq.artemis.core.version.Version;
import org.apache.activemq.artemis.reader.MessageUtil;
import org.apache.activemq.artemis.utils.ConcurrentHashSet;
import org.apache.activemq.artemis.utils.UUIDGenerator;
import org.apache.activemq.artemis.utils.VersionLoader;
/**
* ActiveMQ Artemis implementation of a JMS Connection.
*
* The flat implementation of {@link TopicConnection} and {@link QueueConnection} is per design,
* following the common usage of these as one flat API in JMS 1.1.
*/
public class ActiveMQConnection extends ActiveMQConnectionForContextImpl implements TopicConnection, QueueConnection {
// Constants ------------------------------------------------------------------------------------
public static final int TYPE_GENERIC_CONNECTION = 0;
public static final int TYPE_QUEUE_CONNECTION = 1;
public static final int TYPE_TOPIC_CONNECTION = 2;
public static final String EXCEPTION_FAILOVER = "FAILOVER";
public static final String EXCEPTION_DISCONNECT = "DISCONNECT";
public static final SimpleString CONNECTION_ID_PROPERTY_NAME = MessageUtil.CONNECTION_ID_PROPERTY_NAME;
// Static ---------------------------------------------------------------------------------------
// Attributes -----------------------------------------------------------------------------------
private final int connectionType;
private final Set sessions = new ConcurrentHashSet();
private final Set tempQueues = new ConcurrentHashSet();
private final Set knownDestinations = new ConcurrentHashSet();
private volatile boolean hasNoLocal;
private volatile ExceptionListener exceptionListener;
private volatile FailoverEventListener failoverEventListener;
private volatile boolean justCreated = true;
private volatile ConnectionMetaData metaData;
private volatile boolean closed;
private volatile boolean started;
private String clientID;
private final ClientSessionFactory sessionFactory;
private final SimpleString uid;
private final String username;
private final String password;
private final SessionFailureListener listener = new JMSFailureListener(this);
private final FailoverEventListener failoverListener = new FailoverEventListenerImpl(this);
private final Version thisVersion;
private final int dupsOKBatchSize;
private final int transactionBatchSize;
private ClientSession initialSession;
private final Exception creationStack;
private ActiveMQConnectionFactory factoryReference;
// Constructors ---------------------------------------------------------------------------------
public ActiveMQConnection(final String username,
final String password,
final int connectionType,
final String clientID,
final int dupsOKBatchSize,
final int transactionBatchSize,
final ClientSessionFactory sessionFactory) {
this.username = username;
this.password = password;
this.connectionType = connectionType;
this.clientID = clientID;
this.sessionFactory = sessionFactory;
uid = UUIDGenerator.getInstance().generateSimpleStringUUID();
thisVersion = VersionLoader.getVersion();
this.dupsOKBatchSize = dupsOKBatchSize;
this.transactionBatchSize = transactionBatchSize;
creationStack = new Exception();
}
/**
* This internal method serves basically the Resource Adapter.
* The resource adapter plays with an XASession and a non XASession.
* When there is no enlisted transaction, the EE specification mandates that the commit should
* be done as if it was a nonXA Session (i.e. SessionTransacted).
* For that reason we have this method to force that nonXASession, since the JMS Javadoc
* mandates createSession to return a XASession.
*/
public Session createNonXASession(final boolean transacted, final int acknowledgeMode) throws JMSException {
checkClosed();
return createSessionInternal(false, transacted, acknowledgeMode, ActiveMQConnection.TYPE_GENERIC_CONNECTION);
}
/**
* This internal method serves basically the Resource Adapter.
* The resource adapter plays with an XASession and a non XASession.
* When there is no enlisted transaction, the EE specification mandates that the commit should
* be done as if it was a nonXA Session (i.e. SessionTransacted).
* For that reason we have this method to force that nonXASession, since the JMS Javadoc
* mandates createSession to return a XASession.
*/
public Session createNonXATopicSession(final boolean transacted, final int acknowledgeMode) throws JMSException {
checkClosed();
return createSessionInternal(false, transacted, acknowledgeMode, ActiveMQConnection.TYPE_TOPIC_CONNECTION);
}
/**
* This internal method serves basically the Resource Adapter.
* The resource adapter plays with an XASession and a non XASession.
* When there is no enlisted transaction, the EE specification mandates that the commit should
* be done as if it was a nonXA Session (i.e. SessionTransacted).
* For that reason we have this method to force that nonXASession, since the JMS Javadoc
* mandates createSession to return a XASession.
*/
public Session createNonXAQueueSession(final boolean transacted, final int acknowledgeMode) throws JMSException {
checkClosed();
return createSessionInternal(false, transacted, acknowledgeMode, ActiveMQConnection.TYPE_QUEUE_CONNECTION);
}
// Connection implementation --------------------------------------------------------------------
public synchronized Session createSession(final boolean transacted, final int acknowledgeMode) throws JMSException {
checkClosed();
return createSessionInternal(false, transacted, checkAck(transacted, acknowledgeMode), ActiveMQConnection.TYPE_GENERIC_CONNECTION);
}
public String getClientID() throws JMSException {
checkClosed();
return clientID;
}
public void setClientID(final String clientID) throws JMSException {
checkClosed();
if (this.clientID != null) {
throw new IllegalStateException("Client id has already been set");
}
if (!justCreated) {
throw new IllegalStateException("setClientID can only be called directly after the connection is created");
}
try {
initialSession.addUniqueMetaData(ClientSession.JMS_SESSION_CLIENT_ID_PROPERTY, clientID);
}
catch (ActiveMQException e) {
if (e.getType() == ActiveMQExceptionType.DUPLICATE_METADATA) {
throw new InvalidClientIDException("clientID=" + clientID + " was already set into another connection");
}
}
this.clientID = clientID;
try {
this.addSessionMetaData(initialSession);
}
catch (ActiveMQException e) {
JMSException ex = new JMSException("Internal error setting metadata jms-client-id");
ex.setLinkedException(e);
ex.initCause(e);
throw ex;
}
justCreated = false;
}
public ConnectionMetaData getMetaData() throws JMSException {
checkClosed();
justCreated = false;
if (metaData == null) {
metaData = new ActiveMQConnectionMetaData(thisVersion);
}
return metaData;
}
public ExceptionListener getExceptionListener() throws JMSException {
checkClosed();
justCreated = false;
return exceptionListener;
}
public void setExceptionListener(final ExceptionListener listener) throws JMSException {
checkClosed();
exceptionListener = listener;
justCreated = false;
}
public synchronized void start() throws JMSException {
checkClosed();
for (ActiveMQSession session : sessions) {
session.start();
}
justCreated = false;
started = true;
}
public synchronized void signalStopToAllSessions() {
for (ActiveMQSession session : sessions) {
ClientSession coreSession = session.getCoreSession();
if (coreSession instanceof ClientSessionInternal) {
ClientSessionInternal internalSession = (ClientSessionInternal) coreSession;
internalSession.setStopSignal();
}
}
}
public synchronized void stop() throws JMSException {
threadAwareContext.assertNotMessageListenerThread();
checkClosed();
for (ActiveMQSession session : sessions) {
session.stop();
}
justCreated = false;
started = false;
}
public final synchronized void close() throws JMSException {
threadAwareContext.assertNotCompletionListenerThread();
threadAwareContext.assertNotMessageListenerThread();
if (closed) {
return;
}
sessionFactory.close();
try {
for (ActiveMQSession session : new HashSet(sessions)) {
session.close();
}
try {
if (!tempQueues.isEmpty()) {
// Remove any temporary queues
for (SimpleString queueName : tempQueues) {
if (!initialSession.isClosed()) {
try {
initialSession.deleteQueue(queueName);
}
catch (ActiveMQException ignore) {
// Exception on deleting queue shouldn't prevent close from completing
}
}
}
}
}
finally {
if (initialSession != null) {
initialSession.close();
}
}
closed = true;
}
catch (ActiveMQException e) {
throw JMSExceptionHelper.convertFromActiveMQException(e);
}
}
public ConnectionConsumer createConnectionConsumer(final Destination destination,
final String messageSelector,
final ServerSessionPool sessionPool,
final int maxMessages) throws JMSException {
checkClosed();
checkTempQueues(destination);
// We offer a RA, so no need to implement this for MDBs
return null;
}
private void checkTempQueues(Destination destination) throws JMSException {
ActiveMQDestination jbdest = (ActiveMQDestination) destination;
if (jbdest.isTemporary() && !containsTemporaryQueue(jbdest.getSimpleAddress())) {
throw new JMSException("Can not create consumer for temporary destination " + destination +
" from another JMS connection");
}
}
public ConnectionConsumer createDurableConnectionConsumer(final Topic topic,
final String subscriptionName,
final String messageSelector,
final ServerSessionPool sessionPool,
final int maxMessages) throws JMSException {
checkClosed();
// As spec. section 4.11
if (connectionType == ActiveMQConnection.TYPE_QUEUE_CONNECTION) {
String msg = "Cannot create a durable connection consumer on a QueueConnection";
throw new javax.jms.IllegalStateException(msg);
}
checkTempQueues(topic);
// We offer RA, so no need for this
return null;
}
@Override
public Session createSession(int sessionMode) throws JMSException {
checkClosed();
return createSessionInternal(false, sessionMode == Session.SESSION_TRANSACTED, sessionMode, ActiveMQSession.TYPE_GENERIC_SESSION);
}
@Override
public Session createSession() throws JMSException {
checkClosed();
return createSessionInternal(false, false, Session.AUTO_ACKNOWLEDGE, ActiveMQSession.TYPE_GENERIC_SESSION);
}
// QueueConnection implementation ---------------------------------------------------------------
public QueueSession createQueueSession(final boolean transacted, int acknowledgeMode) throws JMSException {
checkClosed();
return createSessionInternal(false, transacted, checkAck(transacted, acknowledgeMode), ActiveMQSession.TYPE_QUEUE_SESSION);
}
/**
* I'm keeping this as static as the same check will be done within RA.
* This is to conform with TCK Tests where we must return ackMode exactly as they want if transacted=false
*/
public static int checkAck(boolean transacted, int acknowledgeMode) {
if (!transacted && acknowledgeMode == Session.SESSION_TRANSACTED) {
return Session.AUTO_ACKNOWLEDGE;
}
return acknowledgeMode;
}
public ConnectionConsumer createConnectionConsumer(final Queue queue,
final String messageSelector,
final ServerSessionPool sessionPool,
final int maxMessages) throws JMSException {
checkClosed();
checkTempQueues(queue);
return null;
}
// TopicConnection implementation ---------------------------------------------------------------
public TopicSession createTopicSession(final boolean transacted, final int acknowledgeMode) throws JMSException {
checkClosed();
return createSessionInternal(false, transacted, checkAck(transacted, acknowledgeMode), ActiveMQSession.TYPE_TOPIC_SESSION);
}
public ConnectionConsumer createConnectionConsumer(final Topic topic,
final String messageSelector,
final ServerSessionPool sessionPool,
final int maxMessages) throws JMSException {
checkClosed();
checkTempQueues(topic);
return null;
}
@Override
public ConnectionConsumer createSharedConnectionConsumer(Topic topic,
String subscriptionName,
String messageSelector,
ServerSessionPool sessionPool,
int maxMessages) throws JMSException {
return null; // we offer RA
}
@Override
public ConnectionConsumer createSharedDurableConnectionConsumer(Topic topic,
String subscriptionName,
String messageSelector,
ServerSessionPool sessionPool,
int maxMessages) throws JMSException {
return null; // we offer RA
}
// Public ---------------------------------------------------------------------------------------
/**
* Sets a FailureListener for the session which is notified if a failure occurs on the session.
*
* @param listener the listener to add
* @throws JMSException
*/
public void setFailoverListener(final FailoverEventListener listener) throws JMSException {
checkClosed();
justCreated = false;
this.failoverEventListener = listener;
}
/**
* @return {@link FailoverEventListener} the current failover event listener for this connection
* @throws JMSException
*/
public FailoverEventListener getFailoverListener() throws JMSException {
checkClosed();
justCreated = false;
return failoverEventListener;
}
public void addTemporaryQueue(final SimpleString queueAddress) {
tempQueues.add(queueAddress);
knownDestinations.add(queueAddress);
}
public void removeTemporaryQueue(final SimpleString queueAddress) {
tempQueues.remove(queueAddress);
}
public void addKnownDestination(final SimpleString address) {
knownDestinations.add(address);
}
public boolean containsKnownDestination(final SimpleString address) {
return knownDestinations.contains(address);
}
public boolean containsTemporaryQueue(final SimpleString queueAddress) {
return tempQueues.contains(queueAddress);
}
public boolean hasNoLocal() {
return hasNoLocal;
}
public void setHasNoLocal() {
hasNoLocal = true;
}
public SimpleString getUID() {
return uid;
}
public void removeSession(final ActiveMQSession session) {
sessions.remove(session);
}
public ClientSession getInitialSession() {
return initialSession;
}
// Package protected ----------------------------------------------------------------------------
// Protected ------------------------------------------------------------------------------------
// In case the user forgets to close the connection manually
@Override
protected final void finalize() throws Throwable {
if (!closed) {
ActiveMQJMSClientLogger.LOGGER.connectionLeftOpen(creationStack);
close();
}
}
protected boolean isXA() {
return false;
}
protected final ActiveMQSession createSessionInternal(final boolean isXA,
final boolean transacted,
int acknowledgeMode,
final int type) throws JMSException {
if (transacted) {
acknowledgeMode = Session.SESSION_TRANSACTED;
}
try {
ClientSession session;
if (acknowledgeMode == Session.SESSION_TRANSACTED) {
session = sessionFactory.createSession(username, password, isXA, false, false, sessionFactory.getServerLocator().isPreAcknowledge(), transactionBatchSize);
}
else if (acknowledgeMode == Session.AUTO_ACKNOWLEDGE) {
session = sessionFactory.createSession(username, password, isXA, true, true, sessionFactory.getServerLocator().isPreAcknowledge(), 0);
}
else if (acknowledgeMode == Session.DUPS_OK_ACKNOWLEDGE) {
session = sessionFactory.createSession(username, password, isXA, true, true, sessionFactory.getServerLocator().isPreAcknowledge(), dupsOKBatchSize);
}
else if (acknowledgeMode == Session.CLIENT_ACKNOWLEDGE) {
session = sessionFactory.createSession(username, password, isXA, true, false, sessionFactory.getServerLocator().isPreAcknowledge(), transactionBatchSize);
}
else if (acknowledgeMode == ActiveMQJMSConstants.INDIVIDUAL_ACKNOWLEDGE) {
session = sessionFactory.createSession(username, password, isXA, true, false, false, transactionBatchSize);
}
else if (acknowledgeMode == ActiveMQJMSConstants.PRE_ACKNOWLEDGE) {
session = sessionFactory.createSession(username, password, isXA, true, false, true, transactionBatchSize);
}
else {
throw new JMSRuntimeException("Invalid ackmode: " + acknowledgeMode);
}
justCreated = false;
// Setting multiple times on different sessions doesn't matter since RemotingConnection
// maintains
// a set (no duplicates)
session.addFailureListener(listener);
session.addFailoverListener(failoverListener);
ActiveMQSession jbs = createAMQSession(isXA, transacted, acknowledgeMode, session, type);
sessions.add(jbs);
if (started) {
session.start();
}
this.addSessionMetaData(session);
return jbs;
}
catch (ActiveMQException e) {
throw JMSExceptionHelper.convertFromActiveMQException(e);
}
}
// Private --------------------------------------------------------------------------------------
/**
* @param transacted
* @param acknowledgeMode
* @param session
* @param type
* @return
*/
protected ActiveMQSession createAMQSession(boolean isXA,
boolean transacted,
int acknowledgeMode,
ClientSession session,
int type) {
if (isXA) {
return new ActiveMQXASession(this, transacted, true, acknowledgeMode, session, type);
}
else {
return new ActiveMQSession(this, transacted, false, acknowledgeMode, session, type);
}
}
protected final void checkClosed() throws JMSException {
if (closed) {
throw new IllegalStateException("Connection is closed");
}
}
public void authorize() throws JMSException {
try {
initialSession = sessionFactory.createSession(username, password, false, false, false, false, 0);
addSessionMetaData(initialSession);
initialSession.addFailureListener(listener);
initialSession.addFailoverListener(failoverListener);
}
catch (ActiveMQException me) {
throw JMSExceptionHelper.convertFromActiveMQException(me);
}
}
private void addSessionMetaData(ClientSession session) throws ActiveMQException {
session.addMetaData(ClientSession.JMS_SESSION_IDENTIFIER_PROPERTY, "");
if (clientID != null) {
session.addMetaData(ClientSession.JMS_SESSION_CLIENT_ID_PROPERTY, clientID);
}
}
public void setReference(ActiveMQConnectionFactory factory) {
this.factoryReference = factory;
}
public boolean isStarted() {
return started;
}
// Inner classes --------------------------------------------------------------------------------
private static class JMSFailureListener implements SessionFailureListener {
private final WeakReference connectionRef;
JMSFailureListener(final ActiveMQConnection connection) {
connectionRef = new WeakReference(connection);
}
@Override
public synchronized void connectionFailed(final ActiveMQException me, boolean failedOver) {
if (me == null) {
return;
}
ActiveMQConnection conn = connectionRef.get();
if (conn != null) {
try {
final ExceptionListener exceptionListener = conn.getExceptionListener();
if (exceptionListener != null) {
final JMSException je = new JMSException(me.toString(), failedOver ? EXCEPTION_FAILOVER : EXCEPTION_DISCONNECT);
je.initCause(me);
new Thread(new Runnable() {
public void run() {
exceptionListener.onException(je);
}
}).start();
}
}
catch (JMSException e) {
if (!conn.closed) {
ActiveMQJMSClientLogger.LOGGER.errorCallingExcListener(e);
}
}
}
}
@Override
public void connectionFailed(final ActiveMQException me, boolean failedOver, String scaleDownTargetNodeID) {
connectionFailed(me, failedOver);
}
public void beforeReconnect(final ActiveMQException me) {
}
}
private static class FailoverEventListenerImpl implements FailoverEventListener {
private final WeakReference connectionRef;
FailoverEventListenerImpl(final ActiveMQConnection connection) {
connectionRef = new WeakReference(connection);
}
@Override
public void failoverEvent(final FailoverEventType eventType) {
ActiveMQConnection conn = connectionRef.get();
if (conn != null) {
try {
final FailoverEventListener failoverListener = conn.getFailoverListener();
if (failoverListener != null) {
new Thread(new Runnable() {
public void run() {
failoverListener.failoverEvent(eventType);
}
}).start();
}
}
catch (JMSException e) {
if (!conn.closed) {
ActiveMQJMSClientLogger.LOGGER.errorCallingFailoverListener(e);
}
}
}
}
}
}