001/*
002 * Copyright 2009 Red Hat, Inc.
003 *  Red Hat licenses this file to you under the Apache License, version
004 *  2.0 (the "License"); you may not use this file except in compliance
005 *  with the License.  You may obtain a copy of the License at
006 *     http://www.apache.org/licenses/LICENSE-2.0
007 *  Unless required by applicable law or agreed to in writing, software
008 *  distributed under the License is distributed on an "AS IS" BASIS,
009 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
010 *  implied.  See the License for the specific language governing
011 *  permissions and limitations under the License.
012 */
013package org.hornetq.api.jms;
014
015import javax.jms.Queue;
016import javax.jms.Topic;
017
018import org.hornetq.api.core.DiscoveryGroupConfiguration;
019import org.hornetq.api.core.TransportConfiguration;
020import org.hornetq.core.logging.Logger;
021import org.hornetq.jms.client.HornetQConnectionFactory;
022import org.hornetq.jms.client.HornetQDestination;
023import org.hornetq.jms.client.HornetQJMSConnectionFactory;
024import org.hornetq.jms.client.HornetQQueueConnectionFactory;
025import org.hornetq.jms.client.HornetQTopicConnectionFactory;
026import org.hornetq.jms.client.HornetQXAConnectionFactory;
027import org.hornetq.jms.client.HornetQXAQueueConnectionFactory;
028import org.hornetq.jms.client.HornetQXATopicConnectionFactory;
029
030/**
031 * A utility class for creating HornetQ client-side JMS managed resources.
032 *
033 * @author <a href="mailto:andy.taylor@jboss.org">Andy Taylor</a>
034 */
035public class HornetQJMSClient
036{
037   private static final Logger log = Logger.getLogger(HornetQJMSClient.class);
038
039   /**
040    * Create a HornetQConnectionFactory which will receive cluster topology updates from the cluster as servers leave or join and new backups are appointed or removed.
041    * The discoveryAddress and discoveryPort parameters in this method are used to listen for UDP broadcasts which contain connection information for members of the cluster.
042    * The broadcasted connection information is simply used to make an initial connection to the cluster, once that connection is made, up to date
043    * cluster topology information is downloaded and automatically updated whenever the cluster topology changes. If the topology includes backup servers
044    * that information is also propagated to the client so that it can know which server to failover onto in case of live server failure.
045    * @param discoveryAddress The UDP group address to listen for updates
046    * @param discoveryPort the UDP port to listen for updates
047    * @return the HornetQConnectionFactory
048    */
049   public static HornetQConnectionFactory createConnectionFactoryWithHA(final DiscoveryGroupConfiguration groupConfiguration, JMSFactoryType jmsFactoryType)
050   {
051      HornetQConnectionFactory factory = null;
052      if (jmsFactoryType.equals(JMSFactoryType.CF))
053      {
054         factory = new HornetQJMSConnectionFactory(true, groupConfiguration);
055      }
056      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_CF))
057      {
058         factory = new HornetQQueueConnectionFactory(true, groupConfiguration);
059      }
060      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_CF))
061      {
062         factory = new HornetQTopicConnectionFactory(true, groupConfiguration);
063      }
064      else if (jmsFactoryType.equals(JMSFactoryType.XA_CF))
065      {
066         factory = new HornetQXAConnectionFactory(true, groupConfiguration);
067      }
068      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_XA_CF))
069      {
070         factory = new HornetQXAQueueConnectionFactory(true, groupConfiguration);
071      }
072      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_XA_CF))
073      {
074         factory = new HornetQXATopicConnectionFactory(true, groupConfiguration);
075      }
076      
077      return factory;
078   }
079
080   /**
081    * Create a HornetQConnectionFactory which creates session factories from a set of live servers, no HA backup information is propagated to the client
082    * 
083    * The UDP address and port are used to listen for live servers in the cluster
084    * 
085    * @param discoveryAddress The UDP group address to listen for updates
086    * @param discoveryPort the UDP port to listen for updates
087    * @return the HornetQConnectionFactory
088    */
089   public static HornetQConnectionFactory createConnectionFactoryWithoutHA(final DiscoveryGroupConfiguration groupConfiguration, JMSFactoryType jmsFactoryType)
090   {
091      HornetQConnectionFactory factory = null;
092      if (jmsFactoryType.equals(JMSFactoryType.CF))
093      {
094         factory = new HornetQJMSConnectionFactory(false, groupConfiguration);
095      }
096      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_CF))
097      {
098         factory = new HornetQQueueConnectionFactory(false, groupConfiguration);
099      }
100      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_CF))
101      {
102         factory = new HornetQTopicConnectionFactory(false, groupConfiguration);
103      }
104      else if (jmsFactoryType.equals(JMSFactoryType.XA_CF))
105      {
106         factory = new HornetQXAConnectionFactory(false, groupConfiguration);
107      }
108      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_XA_CF))
109      {
110         factory = new HornetQXAQueueConnectionFactory(false, groupConfiguration);
111      }
112      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_XA_CF))
113      {
114         factory = new HornetQXATopicConnectionFactory(false, groupConfiguration);
115      }
116      
117      return factory;
118   }
119   
120   /**
121    * Create a HornetQConnectionFactory which will receive cluster topology updates from the cluster as servers leave or join and new backups are appointed or removed.
122    * The initial list of servers supplied in this method is simply to make an initial connection to the cluster, once that connection is made, up to date
123    * cluster topology information is downloaded and automatically updated whenever the cluster topology changes. If the topology includes backup servers
124    * that information is also propagated to the client so that it can know which server to failover onto in case of live server failure.
125    * @param initialServers The initial set of servers used to make a connection to the cluster. Each one is tried in turn until a successful connection is made. Once
126    * a connection is made, the cluster topology is downloaded and the rest of the list is ignored.
127    * @return the HornetQConnectionFactory
128    */
129   public static HornetQConnectionFactory createConnectionFactoryWithHA(JMSFactoryType jmsFactoryType, final TransportConfiguration... initialServers)
130   {
131      HornetQConnectionFactory factory = null;
132      if (jmsFactoryType.equals(JMSFactoryType.CF))
133      {
134         factory = new HornetQJMSConnectionFactory(true, initialServers);
135      }
136      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_CF))
137      {
138         factory = new HornetQQueueConnectionFactory(true, initialServers);
139      }
140      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_CF))
141      {
142         factory = new HornetQTopicConnectionFactory(true, initialServers);
143      }
144      else if (jmsFactoryType.equals(JMSFactoryType.XA_CF))
145      {
146         factory = new HornetQXAConnectionFactory(true, initialServers);
147      }
148      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_XA_CF))
149      {
150         factory = new HornetQXAQueueConnectionFactory(true, initialServers);
151      }
152      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_XA_CF))
153      {
154         factory = new HornetQXATopicConnectionFactory(true, initialServers);
155      }
156      
157      return factory;
158   }
159
160   /**
161    * Create a HornetQConnectionFactory which creates session factories using a static list of transportConfigurations, the HornetQConnectionFactory is not updated automatically
162    * as the cluster topology changes, and no HA backup information is propagated to the client
163    * 
164    * @param transportConfigurations
165    * @return the HornetQConnectionFactory
166    */
167   public static HornetQConnectionFactory createConnectionFactoryWithoutHA(JMSFactoryType jmsFactoryType, final TransportConfiguration... transportConfigurations)
168   {
169      HornetQConnectionFactory factory = null;
170      if (jmsFactoryType.equals(JMSFactoryType.CF))
171      {
172         factory = new HornetQJMSConnectionFactory(false, transportConfigurations);
173      }
174      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_CF))
175      {
176         factory = new HornetQQueueConnectionFactory(false, transportConfigurations);
177      }
178      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_CF))
179      {
180         factory = new HornetQTopicConnectionFactory(false, transportConfigurations);
181      }
182      else if (jmsFactoryType.equals(JMSFactoryType.XA_CF))
183      {
184         factory = new HornetQXAConnectionFactory(false, transportConfigurations);
185      }
186      else if (jmsFactoryType.equals(JMSFactoryType.QUEUE_XA_CF))
187      {
188         factory = new HornetQXAQueueConnectionFactory(false, transportConfigurations);
189      }
190      else if (jmsFactoryType.equals(JMSFactoryType.TOPIC_XA_CF))
191      {
192         factory = new HornetQXATopicConnectionFactory(false, transportConfigurations);
193      }
194      
195      return factory;
196   }
197   
198   /**
199    * Creates a client-side representation of a JMS Topic.
200    *
201    * @param name the name of the topic
202    * @return The Topic
203    */
204   public static Topic createTopic(final String name)
205   {
206      return HornetQDestination.createTopic(name);
207   }
208
209   /**
210    * Creates a client-side representation of a JMS Queue.
211    *
212    * @param name the name of the queue
213    * @return The Queue
214    */
215   public static Queue createQueue(final String name)
216   {
217      return HornetQDestination.createQueue(name);
218   }
219
220   private HornetQJMSClient()
221   {
222   }
223}