1 /***
2 * Redistribution and use of this software and associated documentation
3 * ("Software"), with or without modification, are permitted provided
4 * that the following conditions are met:
5 *
6 * 1. Redistributions of source code must retain copyright
7 * statements and notices. Redistributions must also contain a
8 * copy of this document.
9 *
10 * 2. Redistributions in binary form must reproduce the
11 * above copyright notice, this list of conditions and the
12 * following disclaimer in the documentation and/or other
13 * materials provided with the distribution.
14 *
15 * 3. The name "Exolab" must not be used to endorse or promote
16 * products derived from this Software without prior written
17 * permission of Exoffice Technologies. For written permission,
18 * please contact info@exolab.org.
19 *
20 * 4. Products derived from this Software may not be called "Exolab"
21 * nor may "Exolab" appear in their names without prior written
22 * permission of Exoffice Technologies. Exolab is a registered
23 * trademark of Exoffice Technologies.
24 *
25 * 5. Due credit should be given to the Exolab Project
26 * (http://www.exolab.org/).
27 *
28 * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS
29 * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
30 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
31 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
32 * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
33 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
34 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
35 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
37 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
39 * OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 * Copyright 2001-2003 (C) Exoffice Technologies Inc. All Rights Reserved.
42 *
43 * $Id: MessageHandleFactory.java,v 1.12 2003/08/17 01:32:24 tanderson Exp $
44 *
45 * Date Author Changes
46 * 3/1/2001 jima Created
47 */
48 package org.exolab.jms.messagemgr;
49
50 import java.sql.Connection;
51
52 import javax.jms.DeliveryMode;
53 import javax.jms.JMSException;
54 import javax.jms.Message;
55 import javax.transaction.TransactionManager;
56
57 import org.exolab.jms.client.JmsDestination;
58 import org.exolab.jms.client.JmsQueue;
59 import org.exolab.jms.message.MessageHandle;
60 import org.exolab.jms.message.MessageImpl;
61 import org.exolab.jms.persistence.DatabaseService;
62 import org.exolab.jms.persistence.PersistenceException;
63
64
65 /***
66 * This class defines a number of static methods that are responsible
67 * for creatimg message handles
68 *
69 * @version $Revision: 1.12 $ $Date: 2003/08/17 01:32:24 $
70 * @author <a href="mailto:jima@exoffice.com">Jim Alateras</a>
71 */
72 public class MessageHandleFactory {
73
74 /***
75 * Retrieve a {@link TransientMessageHandle} given the specified message,
76 * irrespective of whether it is a persistent or non-persistent message.
77 *
78 * @param message the message
79 * @return the message handle
80 * @throws JMSException if the handle can't be created
81 */
82 public static MessageHandle getHandle(MessageImpl message)
83 throws JMSException {
84
85 MessageHandle handle = null;
86
87 if (message.isPersistent()) {
88 handle = new PersistentMessageHandle(message);
89 } else {
90 handle = new TransientMessageHandle(message);
91 }
92
93 return handle;
94 }
95
96 /***
97 * Retrieve a {@link org.exolab.jms.message.MessageHandle} from the
98 * specified QueueConsumerEndpoint and message. It will create a
99 * PersistentMessageHandle if the message is persistent or a
100 * TransientMessageHandle otherwise.
101 *
102 * @param queue the queue destination cache
103 * @param message the message
104 * @return the message handle
105 * @throws JMSException if the handle can't be created
106 */
107 public static MessageHandle getHandle(QueueDestinationCache queue,
108 MessageImpl message)
109 throws JMSException {
110
111 MessageHandle handle = null;
112 if (message.getJMSDeliveryMode() == DeliveryMode.PERSISTENT) {
113 PersistentMessageHandle phandle =
114 new PersistentMessageHandle(message);
115
116 phandle.setConsumerName(queue.getDestination().getName());
117 phandle.setDestination(queue.getDestination());
118
119 handle = phandle;
120 } else {
121 handle = new TransientMessageHandle(message);
122 }
123
124 return handle;
125 }
126
127 /***
128 * Use the message, destination and optionally, the consumer name to
129 * retrieve a message handle.
130 *
131 * @param destination the message destination
132 * @param name the consumer name, can be null for JmsQueue type
133 * @param message the message
134 * @return the message handle
135 * @throws JMSException if the handle can't be created
136 */
137 public static MessageHandle getHandle(JmsDestination dest, String name,
138 MessageImpl message)
139 throws JMSException {
140
141 MessageHandle handle = null;
142 if (message.getJMSDeliveryMode() == DeliveryMode.PERSISTENT) {
143 PersistentMessageHandle phandle =
144 new PersistentMessageHandle(message);
145
146 phandle.setDestination(dest);
147 if (dest instanceof JmsQueue) {
148 phandle.setConsumerName(dest.getName());
149 } else {
150 phandle.setConsumerName(name);
151 }
152 handle = phandle;
153 } else {
154 handle = new TransientMessageHandle(message);
155 }
156 return handle;
157 }
158
159 /***
160 * Retrieve a message handle for the specified {@link ConsumerEndpoint}
161 * and message.
162 *
163 * @param consumer the consumer endpoint
164 * @param message the message
165 * @return the message handle
166 * @throws JMSException if the handle can't be created
167 */
168 public static MessageHandle getHandle(ConsumerEndpoint consumer,
169 MessageImpl message)
170 throws JMSException {
171
172 MessageHandle handle = null;
173 if (message.getJMSDeliveryMode() == DeliveryMode.PERSISTENT) {
174 if (consumer instanceof DurableConsumerEndpoint) {
175 PersistentMessageHandle phandle =
176 new PersistentMessageHandle(message);
177 DurableConsumerEndpoint durable =
178 (DurableConsumerEndpoint) consumer;
179
180
181 phandle.setConsumerName(durable.getName());
182 phandle.setDestination(
183 (JmsDestination) message.getJMSDestination());
184
185 handle = phandle;
186 } else {
187 handle = new TransientMessageHandle(message);
188 }
189 } else {
190 handle = new TransientMessageHandle(message);
191 }
192 return handle;
193 }
194
195
196 /***
197 * Create a transient handle for a message belonging to a queue.
198 *
199 * @param queue the queue destination cache
200 * @param message the message
201 * @return the message handle
202 * @throws JMSException if the handle can't be created
203 */
204 public static MessageHandle createHandle(QueueDestinationCache queue,
205 MessageImpl message)
206 throws JMSException {
207
208 return new TransientMessageHandle(message);
209 }
210
211 /***
212 * Create a transient message handle for a durable consumer
213 *
214 * @param durable the durable consumer endpoint
215 * @param message the message
216 * @return the message handle
217 * @throws JMSException if the handle can't be created
218 */
219 public static MessageHandle createHandle(DurableConsumerEndpoint durable,
220 MessageImpl message)
221 throws JMSException {
222
223 return new TransientMessageHandle(message);
224 }
225
226 /***
227 * Create a transient message handle.
228 *
229 * @param destination the message destination
230 * @param name the consumer name, can be null for JmsQueue type
231 * @param message the message
232 * @return the message handle
233 * @throws JMSException if the handle can't be created
234 */
235 public static MessageHandle createHandle(JmsDestination dest, String name,
236 MessageImpl message)
237 throws JMSException {
238
239 return new TransientMessageHandle(message);
240 }
241
242 /***
243 * Create a {@link PersistentMessageHandle} from the specified
244 * {@link TransientMessageHandle}. It does not fill in all the fields of a
245 * persistent message handle.
246 *
247 * @param handle the transient message handle
248 * @return the persistent message handle
249 * @throws JMSException if the handle can't be created
250 */
251 public static MessageHandle createPersistentHandle(
252 TransientMessageHandle handle) throws JMSException {
253
254 PersistentMessageHandle phandle = new PersistentMessageHandle();
255 phandle.setMessageId(handle.getMessageId());
256 phandle.setPriority(handle.getPriority());
257 phandle.setDelivered(handle.getDelivered());
258 phandle.setDestination(handle.getDestination());
259 phandle.setAcceptedTime(handle.getAcceptedTime());
260 phandle.setExpiryTime(handle.getExpiryTime());
261 phandle.setSequenceNumber(handle.getSequenceNumber());
262 phandle.setClientId(handle.getClientId());
263
264 return phandle;
265 }
266
267 /***
268 * Create a persistent message handle belonging to a queue.
269 *
270 * @param connection connection to the database
271 * @param queue queue destination cache
272 * @param message the message
273 * @return the message handle
274 * @throws JMSException if the handle can't be created
275 * @throws PersistenceException if the handle cannot be made persistent
276 */
277 public static MessageHandle createPersistentHandle(
278 Connection connection, QueueDestinationCache queue,
279 MessageImpl message) throws JMSException, PersistenceException {
280
281 PersistentMessageHandle handle = new PersistentMessageHandle(message);
282
283
284 handle.setConsumerName(queue.getDestination().getName());
285 handle.setDestination(queue.getDestination());
286
287
288 DatabaseService.getAdapter().addMessageHandle(connection, handle);
289
290 return handle;
291 }
292
293 /***
294 * Create a persistent handle for a message belonging to a particular
295 * durable consumer
296 *
297 * @param connection the connection to use.
298 * @param durable durable consumer endpoint
299 * @param message the message
300 * @return the message handle
301 * @throws JMSException if the handle can't be created
302 * @throws PersistenceException if the handle cannot be made persistent
303 */
304 public static MessageHandle createPersistentHandle(
305 Connection connection, DurableConsumerEndpoint durable,
306 MessageImpl message) throws JMSException, PersistenceException {
307
308 PersistentMessageHandle handle = new PersistentMessageHandle(message);
309
310
311 handle.setConsumerName(durable.getName());
312 handle.setDestination(durable.getDestination());
313
314 DatabaseService.getAdapter().addMessageHandle(connection, handle);
315
316 return handle;
317 }
318
319 /***
320 * Create a persistent message handle from the destination and consumer
321 * name
322 *
323 * @param connection the connection to use
324 * @param destination the message destination
325 * @param name the consumer name, can be null for JmsQueue type
326 * @param message the message
327 * @return the message handle
328 * @throws JMSException if the handle can't be created
329 * @throws PersistenceException if the handle cannot be made persistent
330 */
331 public static MessageHandle createPersistentHandle(Connection connection,
332 JmsDestination dest,
333 String name,
334 MessageImpl message)
335 throws JMSException, PersistenceException {
336
337 PersistentMessageHandle handle = new PersistentMessageHandle(message);
338
339
340 handle.setDestination(dest);
341 if (dest instanceof JmsQueue) {
342 handle.setConsumerName(dest.getName());
343 } else {
344 handle.setConsumerName(name);
345 }
346
347 DatabaseService.getAdapter().addMessageHandle(connection, handle);
348 return handle;
349 }
350
351 /***
352 * Destroy the specified persistent handle.
353 *
354 * @param connection the connection to use
355 * @param handle the persistent handle to destroy
356 * @throws PersistenceExcetpion if there is a persistence-related error
357 */
358 public static void destroyPersistentHandle(Connection connection,
359 PersistentMessageHandle handle)
360 throws PersistenceException {
361 DatabaseService.getAdapter().removeMessageHandle(connection, handle);
362
363
364 MessageMgr.instance().handleDestroyed(handle);
365 }
366
367 /***
368 * Destroy a persistent handle associated with a destination, consumer
369 * name and message
370 *
371 * @param connection the connection to use
372 * @param destination the destination assoicated with the message
373 * @param name the name of the consumer
374 * @param message the message
375 * @throws JMSException if the handle can't be created
376 * @throws PersistentException if there is a persistence related error
377 */
378 public static void destroyPersistentHandle(Connection connection,
379 JmsDestination destination,
380 String name,
381 MessageImpl message)
382 throws JMSException, PersistenceException {
383
384 if (message.isPersistent()) {
385 PersistentMessageHandle handle =
386 (PersistentMessageHandle) getHandle(destination, name,
387 message);
388 destroyPersistentHandle(connection, handle);
389 }
390 }
391
392 /***
393 * Update the state of the persistent handle
394 *
395 * @param connection the connection to use
396 * @param handle the handle to update
397 * @throws PersistentException if there is a persistence related error
398 */
399 public static void updatePersistentHandle(Connection connection,
400 PersistentMessageHandle handle)
401 throws PersistenceException {
402 DatabaseService.getAdapter().updateMessageHandle(connection, handle);
403 }
404
405 }
406