/**
*
* Copyright 2004 Hiram Chirino
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**/
package org.activemq.ra;
import java.util.HashMap;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.XAConnection;
import javax.jms.XASession;
import javax.resource.NotSupportedException;
import javax.resource.ResourceException;
import javax.resource.spi.ActivationSpec;
import javax.resource.spi.BootstrapContext;
import javax.resource.spi.ResourceAdapter;
import javax.resource.spi.ResourceAdapterInternalException;
import javax.resource.spi.endpoint.MessageEndpointFactory;
import javax.transaction.xa.XAResource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.activemq.ActiveMQConnection;
import org.activemq.ActiveMQConnectionFactory;
import org.activemq.XmlConfigHelper;
import org.activemq.broker.BrokerContainer;
import org.activemq.broker.BrokerContainerFactory;
import org.activemq.broker.BrokerContext;
import org.activemq.util.IdGenerator;
/**
* Knows how to connect to one ActiveMQ server. It can then activate endpoints
* and deliver messages to those enpoints using the connection configure in the
* resource adapter. <p/>Must override equals and hashCode (JCA spec 16.4)
*
* @version $Revision: 1.2 $
*/
public class ActiveMQResourceAdapter implements ResourceAdapter {
private static final Log log = LogFactory.getLog(ActiveMQResourceAdapter.class);
private static final String ASF_ENDPOINT_WORKER_TYPE = "asf";
private static final String POLLING_ENDPOINT_WORKER_TYPE = "polling";
private BootstrapContext bootstrapContext;
private HashMap endpointWorkers = new HashMap();
final private ActiveMQConnectionRequestInfo info = new ActiveMQConnectionRequestInfo();
private String endpointWorkerType = ASF_ENDPOINT_WORKER_TYPE;
private ActiveMQConnectionFactory connectionFactory;
private BrokerContainer container;
private Boolean useEmbeddedBroker;
public ActiveMQResourceAdapter() {
}
/**
* @see javax.resource.spi.ResourceAdapter#start(javax.resource.spi.BootstrapContext)
*/
public void start(BootstrapContext bootstrapContext) throws ResourceAdapterInternalException {
this.bootstrapContext = bootstrapContext;
if (isUseEmbeddedBroker() != null && isUseEmbeddedBroker().booleanValue()) {
createBroker();
}
}
private void createBroker() throws ResourceAdapterInternalException {
try {
BrokerContainerFactory brokerContainerFactory = XmlConfigHelper.createBrokerContainerFactory(getBrokerXmlConfig());
IdGenerator idgen = new IdGenerator();
container = brokerContainerFactory.createBrokerContainer(idgen.generateId(), BrokerContext.getInstance());
container.start();
connectionFactory = new ActiveMQConnectionFactory(container, getServerUrl());
} catch (JMSException e) {
log.error(e.toString(), e);
throw new ResourceAdapterInternalException("Failed to startup an embedded broker", e);
}
}
/**
*/
public ActiveMQConnection makeConnection() throws JMSException {
ActiveMQConnectionFactory connectionFactory = getConnectionFactory();
String userName = info.getUserName();
String password = info.getPassword();
ActiveMQConnection physicalConnection = (ActiveMQConnection) connectionFactory.createConnection(userName, password);
String clientId = info.getClientid();
if (clientId != null) {
physicalConnection.setClientID(clientId);
}
return physicalConnection;
}
/**
* @param activationSpec
*/
public ActiveMQConnection makeConnection(ActiveMQActivationSpec activationSpec) throws JMSException {
ActiveMQConnectionFactory connectionFactory = getConnectionFactory();
String userName = defaultValue(activationSpec.getUserName(), info.getUserName());
String password = defaultValue(activationSpec.getPassword(), info.getPassword());
ActiveMQConnection physicalConnection = (ActiveMQConnection) connectionFactory.createConnection(userName, password);
if (activationSpec.isDurableSubscription()) {
physicalConnection.setClientID(activationSpec.getClientId());
}
return physicalConnection;
}
/**
* @return
*/
private ActiveMQConnectionFactory getConnectionFactory() {
if (connectionFactory == null) {
connectionFactory = new ActiveMQConnectionFactory(info.getServerUrl());
connectionFactory.setCachingEnabled(false);
connectionFactory.setCopyMessageOnSend(true);
connectionFactory.setDoMessageCompression(false);
connectionFactory.setDoMessageFragmentation(false);
connectionFactory.setUseAsyncSend(false);
}
return connectionFactory;
}
private String defaultValue(String value, String defaultValue) {
if (value != null)
return value;
return defaultValue;
}
/**
* @see javax.resource.spi.ResourceAdapter#stop()
*/
public void stop() {
stopBroker();
this.bootstrapContext = null;
}
private void stopBroker() {
if (container != null) {
try {
container.stop();
} catch (JMSException e) {
log.warn("Exception while stopping the broker container", e);
}
}
}
/**
* @return
*/
public BootstrapContext getBootstrapContext() {
return bootstrapContext;
}
/**
* @see javax.resource.spi.ResourceAdapter#endpointActivation(javax.resource.spi.endpoint.MessageEndpointFactory,
* javax.resource.spi.ActivationSpec)
*/
public void endpointActivation(MessageEndpointFactory endpointFactory, ActivationSpec activationSpec)
throws ResourceException {
// spec section 5.3.3
if (activationSpec.getResourceAdapter() != this) {
throw new ResourceException("Activation spec not initialized with this ResourceAdapter instance");
}
if (activationSpec.getClass().equals(ActiveMQActivationSpec.class)) {
ActiveMQEndpointActivationKey key = new ActiveMQEndpointActivationKey(endpointFactory,
(ActiveMQActivationSpec) activationSpec);
// This is weird.. the same endpoint activated twice.. must be a
// container error.
if (endpointWorkers.containsKey(key)) {
throw new IllegalStateException("Endpoint previously activated");
}
ActiveMQBaseEndpointWorker worker;
if (POLLING_ENDPOINT_WORKER_TYPE.equals(getEndpointWorkerType())) {
worker = new ActiveMQPollingEndpointWorker(this, key);
} else if (ASF_ENDPOINT_WORKER_TYPE.equals(getEndpointWorkerType())) {
worker = new ActiveMQAsfEndpointWorker(this, key);
} else {
throw new NotSupportedException("That type of EndpointWorkerType is not supported: "
+ getEndpointWorkerType());
}
endpointWorkers.put(key, worker);
worker.start();
} else {
throw new NotSupportedException("That type of ActicationSpec not supported: " + activationSpec.getClass());
}
}
/**
* @see javax.resource.spi.ResourceAdapter#endpointDeactivation(javax.resource.spi.endpoint.MessageEndpointFactory,
* javax.resource.spi.ActivationSpec)
*/
public void endpointDeactivation(MessageEndpointFactory endpointFactory, ActivationSpec activationSpec) {
if (activationSpec.getClass().equals(ActiveMQActivationSpec.class)) {
ActiveMQEndpointActivationKey key = new ActiveMQEndpointActivationKey(endpointFactory,
(ActiveMQActivationSpec) activationSpec);
ActiveMQBaseEndpointWorker worker = (ActiveMQBaseEndpointWorker) endpointWorkers.get(key);
if (worker == null) {
// This is weird.. that endpoint was not activated.. oh well..
// this method
// does not throw exceptions so just return.
return;
}
try {
worker.stop();
} catch (InterruptedException e) {
// We interrupted.. we won't throw an exception but will stop
// waiting for the worker
// to stop.. we tried our best. Keep trying to interrupt the
// thread.
Thread.currentThread().interrupt();
}
}
}
/**
* We only connect to one resource manager per ResourceAdapter instance, so
* any ActivationSpec will return the same XAResource.
*
* @see javax.resource.spi.ResourceAdapter#getXAResources(javax.resource.spi.ActivationSpec[])
*/
public XAResource[] getXAResources(ActivationSpec[] activationSpecs) throws ResourceException {
Connection connection = null;
try {
connection = makeConnection();
if (connection instanceof XAConnection) {
XASession session = ((XAConnection) connection).createXASession();
XAResource xaResource = session.getXAResource();
return new XAResource[] { xaResource };
} else {
return new XAResource[] {};
}
} catch (JMSException e) {
throw new ResourceException(e);
} finally {
try {
connection.close();
} catch (Throwable ignore) {
}
}
}
// ///////////////////////////////////////////////////////////////////////
//
// Java Bean getters and setters for this ResourceAdapter class.
//
// ///////////////////////////////////////////////////////////////////////
/**
* @return
*/
public String getClientid() {
return emptyToNull(info.getClientid());
}
/**
* @return
*/
public String getPassword() {
return emptyToNull(info.getPassword());
}
/**
* @return
*/
public String getServerUrl() {
return info.getServerUrl();
}
/**
* @return
*/
public String getUserName() {
return emptyToNull(info.getUserName());
}
/**
* @param clientid
*/
public void setClientid(String clientid) {
info.setClientid(clientid);
}
/**
* @param password
*/
public void setPassword(String password) {
info.setPassword(password);
}
/**
* @param url
*/
public void setServerUrl(String url) {
info.setServerUrl(url);
}
/**
* @param userid
*/
public void setUserName(String userid) {
info.setUserName(userid);
}
/**
* @return Returns the endpointWorkerType.
*/
public String getEndpointWorkerType() {
return endpointWorkerType;
}
/**
* @param endpointWorkerType
* The endpointWorkerType to set.
*/
public void setEndpointWorkerType(String endpointWorkerType) {
this.endpointWorkerType = endpointWorkerType.toLowerCase();
}
public String getBrokerXmlConfig() {
return info.getBrokerXmlConfig();
}
/**
* Sets the <a href="http://activemq.org/Xml+Configuration">XML
* configuration file </a> used to configure the ActiveMQ broker via Spring
* if using embedded mode.
*
* @param brokerXmlConfig
* is the filename which is assumed to be on the classpath unless
* a URL is specified. So a value of <code>foo/bar.xml</code>
* would be assumed to be on the classpath whereas
* <code>file:dir/file.xml</code> would use the file system.
* Any valid URL string is supported.
* @see #setUseEmbeddedBroker(Boolean)
*/
public void setBrokerXmlConfig(String brokerXmlConfig) {
info.setBrokerXmlConfig(brokerXmlConfig);
}
public Boolean isUseEmbeddedBroker() {
return useEmbeddedBroker;
}
public void setUseEmbeddedBroker(Boolean useEmbeddedBroker) {
this.useEmbeddedBroker = useEmbeddedBroker;
}
/**
* @return Returns the info.
*/
public ActiveMQConnectionRequestInfo getInfo() {
return info;
}
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof ActiveMQResourceAdapter)) {
return false;
}
final ActiveMQResourceAdapter activeMQResourceAdapter = (ActiveMQResourceAdapter) o;
if (!endpointWorkerType.equals(activeMQResourceAdapter.endpointWorkerType)) {
return false;
}
if (!info.equals(activeMQResourceAdapter.info)) {
return false;
}
if (useEmbeddedBroker != activeMQResourceAdapter.useEmbeddedBroker && useEmbeddedBroker != null) {
return useEmbeddedBroker.equals(activeMQResourceAdapter.useEmbeddedBroker);
}
return true;
}
public int hashCode() {
int result;
result = info.hashCode();
result = 29 * result + endpointWorkerType.hashCode();
if (useEmbeddedBroker != null && useEmbeddedBroker.booleanValue()) {
result = result * 29 + 1;
}
return result;
}
private String emptyToNull(String value) {
if (value == null || value.length() == 0) {
return null;
}
return value;
}
}