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 2000-2001,2003 (C) Exoffice Technologies Inc. All Rights Reserved.
42 *
43 * $Id: PersistentMessage.java,v 1.9 2003/08/17 01:32:25 tanderson Exp $
44 *
45 * Date Author Changes
46 */
47
48 package org.exolab.jms.persistence;
49
50 import java.io.ByteArrayInputStream;
51 import java.io.ByteArrayOutputStream;
52 import java.io.IOException;
53 import java.io.ObjectInput;
54 import java.io.ObjectInputStream;
55 import java.io.ObjectOutput;
56 import java.io.ObjectOutputStream;
57
58 import javax.jms.JMSException;
59
60 import org.exolab.core.foundation.PersistentObject;
61 import org.exolab.jms.message.DestinationImpl;
62 import org.exolab.jms.message.MessageImpl;
63
64
65 /***
66 * A wrapper to the Message Object to assist in persistency.
67 *
68 *
69 * @version $Revision: 1.9 $ $Date: 2003/08/17 01:32:25 $
70 * @author <a href="mailto:mourikis@exolab.org">Jim Mourikis</a>
71 */
72 public class PersistentMessage extends PersistentObject {
73
74
75 static final long serialVersionUID = 2;
76
77
78 private String destination_;
79
80
81 private String messageId_;
82
83
84 private String messageType_;
85
86
87 private int priority_;
88
89
90 private long timeStamp_;
91
92
93 private long expiryTime_;
94
95
96 private MessageImpl message_;
97
98
99 private boolean processed_;
100
101
102 /***
103 * Default constructor.
104 *
105 * @param MessageImpl the message to persist
106 *
107 */
108 public PersistentMessage() {
109 super();
110 }
111
112
113 /***
114 * Store the message to be persisted. And extract any required column
115 * details.
116 *
117 * @param MessageImpl the message to persist
118 *
119 */
120 public PersistentMessage(MessageImpl message) throws JMSException {
121 super();
122 message_ = message;
123 destination_ =
124 ((DestinationImpl) message.getJMSDestination()).getDestination();
125 messageId_ = message.getMessageId().getId();
126 messageType_ = message.getJMSType();
127 priority_ = message.getJMSPriority();
128 expiryTime_ = message.getJMSExpiration();
129 timeStamp_ = message.getAcceptedTime();
130 processed_ = message.getProcessed();
131 }
132
133 /***
134 * Set the message held by this persistent object
135 *
136 * @param message - the message held
137 */
138 public void setMessage(MessageImpl message) {
139 message_ = message;
140 }
141
142 /***
143 * return the held message from the persistent object.
144 *
145 * @return MessageImpl the held message.
146 *
147 */
148 public MessageImpl getMessage() {
149 return message_;
150 }
151
152
153 /***
154 * Get the message as a serialized blob.
155 *
156 * @return String The serialized message.
157 *
158 */
159 public byte[] getMessageBlob() {
160 try {
161 ByteArrayOutputStream bout = new ByteArrayOutputStream();
162 ObjectOutputStream tmp = new ObjectOutputStream(bout);
163 tmp.writeObject(message_);
164 tmp.close();
165 return bout.toByteArray();
166 } catch (Exception err) {
167 System.err.println
168 ("Error PersistentMessage: Failed to serialize message\n"
169 + err);
170 return null;
171 }
172 }
173
174
175 /***
176 * Set the message from a serialized blob
177 *
178 * @param blob The serialized message.
179 *
180 */
181 public void setMessageBlob(byte[] blob) {
182 try {
183 if (blob != null) {
184 ByteArrayInputStream bin =
185 new ByteArrayInputStream(blob);
186 ObjectInputStream tmpin = new ObjectInputStream(bin);
187 message_ = (MessageImpl) tmpin.readObject();
188 tmpin.close();
189 } else {
190 message_ = null;
191 }
192 } catch (Exception err) {
193 System.err.println
194 ("Error PersistentMessage: Failed to de-serialize message\n"
195 + err);
196 err.printStackTrace();
197 }
198 }
199
200 /***
201 * Get the message destination
202 *
203 * @return String The destination of the message
204 *
205 */
206 public String getDestination() {
207 return destination_;
208 }
209
210 /***
211 * Set the message destination
212 *
213 * @param destination The destination of the message
214 *
215 */
216 public void setDestination(String destination) {
217 destination_ = destination;
218 }
219
220 /***
221 * Get the message id
222 *
223 * @return the message id
224 *
225 */
226 public String getMessageId() {
227 return messageId_;
228 }
229
230 /***
231 * Set the message id
232 *
233 * @param id The message id
234 *
235 */
236 public void setMessageId(String id) {
237 messageId_ = id;
238 }
239
240 /***
241 * Get the message type
242 *
243 * @return String The message type
244 *
245 */
246 public String getMessageType() {
247 return messageType_;
248 }
249
250 /***
251 * Set the message type
252 *
253 * @param messageType The message type
254 *
255 */
256 public void setMessageType(String messageType) {
257 messageType_ = messageType;
258 }
259
260 /***
261 * Get the message priority
262 *
263 * @return int The priority
264 *
265 */
266 public int getPriority() {
267 return priority_;
268 }
269
270 /***
271 * Set the message priority
272 *
273 * @param priority The message priority to set
274 *
275 */
276 public void setPriority(int priority) {
277 priority_ = priority;
278 }
279
280 /***
281 * Get the time the message was received by the MessageMgr
282 *
283 * @return long The message creation time in secs since epoc
284 *
285 */
286 public long getJMSTimeStamp() {
287 return timeStamp_;
288 }
289
290 /***
291 * Set the time the message was received by the MessageMgr
292 *
293 * @param timeStamp The message creation time in secs since epoc
294 *
295 */
296 public void setJMSTimeStamp(long time) {
297 timeStamp_ = time;
298 }
299
300 /***
301 * Retrieve the message expiry time
302 *
303 * @return long - the time that the underlying message expires
304 *
305 */
306 public long getExpiryTime() {
307 return expiryTime_;
308 }
309
310 /***
311 * Set the message expiry time.
312 *
313 * @param time - message expiry time in milliseconds
314 *
315 */
316 public void setExpiryTime(long time) {
317 expiryTime_ = time;
318 }
319
320 /***
321 * Set the state of the processed flag
322 *
323 * @param value - true if message has been processed
324 */
325 public void setProcessed(boolean value) {
326 processed_ = value;
327 }
328
329 /***
330 * Return the state of the processed flag
331 *
332 * @return boolean - true if the message has been processed
333 */
334 public boolean getProcessed() {
335 return processed_;
336 }
337
338
339 public void writeExternal(ObjectOutput stream) throws IOException {
340 stream.writeLong(serialVersionUID);
341 stream.writeObject(destination_);
342 stream.writeUTF(messageId_);
343 stream.writeObject(messageType_);
344 stream.writeInt(priority_);
345 stream.writeLong(timeStamp_);
346 stream.writeLong(expiryTime_);
347 stream.writeBoolean(processed_);
348 stream.writeObject(message_);
349 super.writeExternal(stream);
350 }
351
352
353 public void readExternal(ObjectInput stream)
354 throws IOException, ClassNotFoundException {
355 long version = stream.readLong();
356 if (version == serialVersionUID) {
357 destination_ = (String) stream.readObject();
358 messageId_ = stream.readUTF();
359 messageType_ = (String) stream.readObject();
360 priority_ = stream.readInt();
361 timeStamp_ = stream.readLong();
362 expiryTime_ = stream.readLong();
363 processed_ = stream.readBoolean();
364 message_ = (MessageImpl) stream.readObject();
365 } else {
366 throw new IOException("PersistentMessage with version "
367 + version + " is not supported.");
368 }
369 super.readExternal(stream);
370
371 }
372 }
373