/**
* 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.ra;
import javax.jms.JMSException;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.ActiveMQSslConnectionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Abstract base class providing support for creating physical connections to an
* ActiveMQ instance.
*
*
*/
public class ActiveMQConnectionSupport {
private ActiveMQConnectionRequestInfo info = new ActiveMQConnectionRequestInfo();
protected Logger log = LoggerFactory.getLogger(getClass());
/**
* Creates a factory for obtaining physical connections to an Active MQ
* broker. The factory is configured with the given configuration
* information.
*
* @param connectionRequestInfo
* the configuration request information
* @param activationSpec
* @return the connection factory
* @throws java.lang.IllegalArgumentException
* if the server URL given in the configuration information is not a
* valid URL
*/
protected ActiveMQConnectionFactory createConnectionFactory(ActiveMQConnectionRequestInfo connectionRequestInfo, MessageActivationSpec activationSpec) {
// ActiveMQSslConnectionFactory defaults to TCP anyway
ActiveMQConnectionFactory factory = new ActiveMQSslConnectionFactory();
connectionRequestInfo.configure(factory, activationSpec);
return factory;
}
/**
* Creates a new physical connection to an Active MQ broker identified by
* given connection request information.
*
* @param connectionRequestInfo
* the connection request information identifying the broker and any
* required connection parameters, e.g. username/password
* @return the physical connection
* @throws JMSException
* if the connection could not be established
*/
public ActiveMQConnection makeConnection(ActiveMQConnectionRequestInfo connectionRequestInfo) throws JMSException {
return makeConnection(connectionRequestInfo, createConnectionFactory(connectionRequestInfo, null));
}
/**
* Creates a new physical connection to an Active MQ broker using a given
* connection factory and credentials supplied in connection request
* information.
*
* @param connectionRequestInfo
* the connection request information containing the credentials to
* use for the connection request
* @return the physical connection
* @throws JMSException
* if the connection could not be established
*/
public ActiveMQConnection makeConnection(ActiveMQConnectionRequestInfo connectionRequestInfo, ActiveMQConnectionFactory connectionFactory)
throws JMSException {
String userName = connectionRequestInfo.getUserName();
String password = connectionRequestInfo.getPassword();
ActiveMQConnection physicalConnection = (ActiveMQConnection) connectionFactory.createConnection(userName, password);
String clientId = connectionRequestInfo.getClientid();
if (clientId != null && clientId.length() > 0) {
physicalConnection.setClientID(clientId);
}
return physicalConnection;
}
/**
* Gets the connection request information.
*
* @return the connection request information
*/
public ActiveMQConnectionRequestInfo getInfo() {
return info;
}
/**
* Sets the connection request information as a whole.
*
* @param connectionRequestInfo
* the connection request information
*/
protected void setInfo(ActiveMQConnectionRequestInfo connectionRequestInfo) {
info = connectionRequestInfo;
if (log.isDebugEnabled()) {
log.debug(this + ", setting [info] to: " + info);
}
}
protected boolean notEqual(Object o1, Object o2) {
return (o1 == null ^ o2 == null) || (o1 != null && !o1.equals(o2));
}
protected String emptyToNull(String value) {
if (value == null || value.length() == 0) {
return null;
} else {
return value;
}
}
protected String defaultValue(String value, String defaultValue) {
if (value != null) {
return value;
}
return defaultValue;
}
// ///////////////////////////////////////////////////////////////////////
//
// Java Bean getters and setters for this ResourceAdapter class.
//
// ///////////////////////////////////////////////////////////////////////
/**
* @return client id
*/
public String getClientid() {
return emptyToNull(info.getClientid());
}
/**
* @param clientid
*/
public void setClientid(String clientid) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [clientid] to: " + clientid);
}
info.setClientid(clientid);
}
/**
* @return password
*/
public String getPassword() {
return emptyToNull(info.getPassword());
}
/**
* @param password
*/
public void setPassword(String password) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [password] property");
}
info.setPassword(password);
}
/**
* @return server URL
*/
public String getServerUrl() {
return info.getServerUrl();
}
/**
* @param url
*/
public void setServerUrl(String url) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [serverUrl] to: " + url);
}
info.setServerUrl(url);
}
public void setTrustStore(String trustStore) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [trustStore] to: " + trustStore);
}
info.setTrustStore(trustStore);
}
public void setTrustStorePassword(String trustStorePassword) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [trustStorePassword] to: " + trustStorePassword);
}
info.setTrustStorePassword(trustStorePassword);
}
public void setKeyStore(String keyStore) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [keyStore] to: " + keyStore);
}
info.setKeyStore(keyStore);
}
public void setKeyStorePassword(String keyStorePassword) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [keyStorePassword] to: " + keyStorePassword);
}
info.setKeyStorePassword(keyStorePassword);
}
public void setKeyStoreKeyPassword(String keyStoreKeyPassword) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [keyStoreKeyPassword] to: " + keyStoreKeyPassword);
}
info.setKeyStoreKeyPassword(keyStoreKeyPassword);
}
/**
* @return user name
*/
public String getUserName() {
return emptyToNull(info.getUserName());
}
/**
* @param userid
*/
public void setUserName(String userid) {
if (log.isDebugEnabled()) {
log.debug("setting [userName] to: " + userid);
}
info.setUserName(userid);
}
/**
* @return durable topic prefetch
*/
public Integer getDurableTopicPrefetch() {
return info.getDurableTopicPrefetch();
}
/**
* @param optimizeDurableTopicPrefetch
*/
public void setOptimizeDurableTopicPrefetch(Integer optimizeDurableTopicPrefetch) {
if (log.isDebugEnabled()) {
log.debug("setting [optimizeDurableTopicPrefetch] to: " + optimizeDurableTopicPrefetch);
}
info.setOptimizeDurableTopicPrefetch(optimizeDurableTopicPrefetch);
}
/**
* @return durable topic prefetch
*/
public Integer getOptimizeDurableTopicPrefetch() {
return info.getOptimizeDurableTopicPrefetch();
}
/**
* @param durableTopicPrefetch
*/
public void setDurableTopicPrefetch(Integer durableTopicPrefetch) {
if (log.isDebugEnabled()) {
log.debug("setting [durableTopicPrefetch] to: " + durableTopicPrefetch);
}
info.setDurableTopicPrefetch(durableTopicPrefetch);
}
/**
* @return initial redelivery delay
*/
public Long getInitialRedeliveryDelay() {
return info.getInitialRedeliveryDelay();
}
/**
* @param value
*/
public void setInitialRedeliveryDelay(Long value) {
if (log.isDebugEnabled()) {
log.debug("setting [initialRedeliveryDelay] to: " + value);
}
info.setInitialRedeliveryDelay(value);
}
/**
* @return initial redelivery delay
*/
public Long getMaximumRedeliveryDelay() {
return info.getMaximumRedeliveryDelay();
}
/**
* @param value
*/
public void setMaximumRedeliveryDelay(Long value) {
if (log.isDebugEnabled()) {
log.debug("setting [maximumRedeliveryDelay] to: " + value);
}
info.setMaximumRedeliveryDelay(value);
}
/**
* @return input stream prefetch
*/
@Deprecated
public Integer getInputStreamPrefetch() {
return 0;
}
/**
* @return maximum redeliveries
*/
public Integer getMaximumRedeliveries() {
return info.getMaximumRedeliveries();
}
/**
* @param value
*/
public void setMaximumRedeliveries(Integer value) {
if (log.isDebugEnabled()) {
log.debug("setting [maximumRedeliveries] to: " + value);
}
info.setMaximumRedeliveries(value);
}
/**
* @return queue browser prefetch
*/
public Integer getQueueBrowserPrefetch() {
return info.getQueueBrowserPrefetch();
}
/**
* @param queueBrowserPrefetch
*/
public void setQueueBrowserPrefetch(Integer queueBrowserPrefetch) {
if (log.isDebugEnabled()) {
log.debug("setting [queueBrowserPrefetch] to: " + queueBrowserPrefetch);
}
info.setQueueBrowserPrefetch(queueBrowserPrefetch);
}
/**
* @return queue prefetch
*/
public Integer getQueuePrefetch() {
return info.getQueuePrefetch();
}
/**
* @param queuePrefetch
*/
public void setQueuePrefetch(Integer queuePrefetch) {
if (log.isDebugEnabled()) {
log.debug("setting [queuePrefetch] to: " + queuePrefetch);
}
info.setQueuePrefetch(queuePrefetch);
}
/**
* @return redelivery backoff multiplier
*/
public Double getRedeliveryBackOffMultiplier() {
return info.getRedeliveryBackOffMultiplier();
}
/**
* @param value
*/
public void setRedeliveryBackOffMultiplier(Double value) {
if (log.isDebugEnabled()) {
log.debug("setting [redeliveryBackOffMultiplier] to: " + value);
}
info.setRedeliveryBackOffMultiplier(value);
}
/**
* @return redelivery use exponential backoff
*/
public Boolean getRedeliveryUseExponentialBackOff() {
return info.getRedeliveryUseExponentialBackOff();
}
/**
* @param value
*/
public void setRedeliveryUseExponentialBackOff(Boolean value) {
if (log.isDebugEnabled()) {
log.debug("setting [redeliveryUseExponentialBackOff] to: " + value);
}
info.setRedeliveryUseExponentialBackOff(value);
}
/**
* @return topic prefetch
*/
public Integer getTopicPrefetch() {
return info.getTopicPrefetch();
}
/**
* @param topicPrefetch
*/
public void setTopicPrefetch(Integer topicPrefetch) {
if (log.isDebugEnabled()) {
log.debug("setting [topicPrefetch] to: " + topicPrefetch);
}
info.setTopicPrefetch(topicPrefetch);
}
/**
* @param i
*/
public void setAllPrefetchValues(Integer i) {
info.setAllPrefetchValues(i);
}
/**
* @return use inbound session enabled
*/
public boolean isUseInboundSessionEnabled() {
return info.isUseInboundSessionEnabled();
}
/**
* @return use inbound session
*/
public Boolean getUseInboundSession() {
return info.getUseInboundSession();
}
/**
* @param useInboundSession
*/
public void setUseInboundSession(Boolean useInboundSession) {
if (log.isDebugEnabled()) {
log.debug("setting [useInboundSession] to: " + useInboundSession);
}
info.setUseInboundSession(useInboundSession);
}
public boolean isUseSessionArgs() {
return info.isUseSessionArgs();
}
public Boolean getUseSessionArgs() {
return info.getUseSessionArgs();
}
/**
* if true, calls to managed connection factory.connection.createSession
* will respect the passed in args. When false (default) the args are
* ignored b/c the container will do transaction demarcation via xa or local
* transaction rar contracts. This option is useful when a managed
* connection is used in plain jms mode and a jms transacted session session
* is required.
*
* @param useSessionArgs
*/
public void setUseSessionArgs(Boolean useSessionArgs) {
if (log.isDebugEnabled()) {
log.debug(this + ", setting [useSessionArgs] to: " + useSessionArgs);
}
info.setUseSessionArgs(useSessionArgs);
}
}