1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.sandesha.storage.dao;
18
19 import org.apache.sandesha.RMMessageContext;
20
21 import java.util.Set;
22
23 /***
24 * @author Chamikara Jayalath
25 */
26
27 public interface ISandeshaDAO {
28
29 /***
30 * This adds a new entry in the storage to to hold messages of a perticular
31 * sequence that come in to the sandesha server/client
32 */
33 boolean addIncomingSequence(String sequenceId);
34
35
36 /***
37 * This adds a entry in the storage for holding the messages of the given outgoing
38 * sequence.
39 */
40 boolean addOutgoingSequence(String sequenceId);
41
42
43 /***
44 * Adds a priority message (e.g. create seq) to the queue. These will be sent
45 * before other messages like application requests.
46 */
47 boolean addPriorityMessage(RMMessageContext message);
48
49
50 /***
51 * This checks the priority messages to see weather there is any one to
52 * be sent (either for the first time or a retransmission)
53 */
54 RMMessageContext getNextPriorityMessageContextToSend();
55
56
57 /***
58 * This adds a incoming message to a area belonging to the given sequence in the
59 * queue.
60 */
61 boolean addMessageToIncomingSequence(String sequenceId, Long msgNo,
62 RMMessageContext rmMessageContext);
63
64
65 /***
66 * This adds the given message to the given sequence.
67 */
68 boolean addMessageToOutgoingSequence(String sequenceId,
69 RMMessageContext rmMessageContext);
70
71
72 /***
73 * This checks weather there is a entry for the given incoming sequence in
74 * the queue.
75 */
76 boolean isIncomingSequenceExists(String sequenceId);
77
78
79 /***
80 * Checks weather a entry for the given outgoing sequence exists in
81 * the queue.
82 */
83 boolean isOutgoingSequenceExists(String sequenceId);
84
85
86 /***
87 * This checks in the given incoming sequence to see weather a message of
88 * the given message no exists
89 */
90 boolean isIncomingMessageExists(String sequenceId, Long msgNo);
91
92
93 /***
94 * This tries to get the next message to be sent from the given outgoing sequence
95 * If these is no message to be sent in the given sequence, null will be returned.
96 */
97 RMMessageContext getNextMsgContextToProcess(Object seq);
98
99
100 /***
101 * Gets the next possible message to be sent from the queue.
102 */
103 RMMessageContext getNextOutgoingMsgContextToSend();
104
105 public Object getRandomSeqToProcess();
106
107
108 /***
109 * This reutns a set of message numbers with all the message numbers of
110 * incoming sequence.
111 */
112 Set getAllReceivedMsgNumsOfIncomingSeq(String sequenceId);
113
114
115 /***
116 * This sets the outgoing sequence. Here seqId is the entry in the queue
117 * that we hope to hold the messages of a perticular sequence. outseqid is the
118 * actual sequence id (i.e. uuid). That will be set within the wsrm:sequence field of
119 * this message. (remember that we may not have received this actual outgoing sequence id
120 * by the time we start to store outgoing messages).
121 */
122 void setOutSequence(String sequenceId, String outSequenceId);
123
124
125 /***
126 * This sets a flag in the queue to indicate that the outSequence of the perticular message set
127 * (stored with the id seqId) has been set correctly. The value in outSequence may be wrong
128 * before the sender gets the create seq. response. After getting this and after setting the
129 * out sequence correctly using the previous method, this flag will be set to true. Only then these
130 * messages thould be send to the sender.
131 */
132 void setOutSequenceApproved(String sequenceID, boolean approved);
133
134
135 /***
136 * this gives the seqId which is used to hold the messages of which the
137 * outsequence entry has been set to the value outsequenceId.
138 */
139 String getSequenceOfOutSequence(String outsequenceId);
140
141
142 /***
143 * This checks the priority queue for a message if given messageid and
144 * moves it to the bin
145 */
146 void removeCreateSequenceMsg(String messageId);
147
148 /***
149 * This gives the next message number, outgoing storage of the given sequence
150 * esxpects. Actually this will be used by storage managers to obtain the message
151 * number that should be put to the next application message.
152 */
153 long getNextOutgoingMessageNumber(String sequenceId);
154
155 /***
156 * When the messageId of therequest message (e.g. from relates to) and the sequence id
157 * is given this will give the response message.
158 */
159 public RMMessageContext checkForResponseMessage(String requestId, String seqId);
160
161 /***
162 * Tries to give the sequence id of the outgoing message with the given message id
163 */
164 public String searchForSequenceId(String messageId);
165
166 /***
167 * This outgoing message will be marked as deleted.
168 * i.e. it will not be re-transmitted
169 */
170 public void markOutgoingMessageToDelete(String sequenceId, Long msgNumber);
171
172
173 /***
174 * Tells to the rtorage that the given message of given sequence was acked.
175 */
176 public void setAckReceived(String seqId, long msgNo);
177
178 /***
179 * Adds a low priority message to the storage (e.g. terminate sequence).
180 * These messages are axpected to be sent after sending all the other messages
181 * of the given sequence (but it is not a must)
182 */
183 public void addLowPriorityMessage(RMMessageContext msg);
184
185 /***
186 * Asks the storage for the next low priority message (if there is any)
187 */
188 public RMMessageContext getNextLowPriorityMessageContextToSend();
189
190 /***
191 * The message will be added to a sent list (the list holds the
192 * messages that were sent at least once)
193 */
194 public void addSendMsgNo(String seqId, long msgNo);
195
196 /***
197 * Asks from the storage weather the given message has been sent at
198 * least once
199 */
200 public boolean isSentMsg(String seqId, long msgNo);
201
202
203 /***
204 * Can be used to ckeck weather the last message has been received in the
205 * incoming sequence.
206 */
207 public boolean hasLastIncomingMsgReceived(String seqId);
208
209 /***
210 * Asks for the last message of the incoming sequence (if it has been received)
211 */
212 public long getLastIncomingMsgNo(String seqId);
213
214 /***
215 * When a server or client sends a create sequence, it will be marked from this method.
216 * But the actual resources will be allocated only when the first message arrives.
217 */
218 public void addRequestedSequence(String seqId);
219
220 /***
221 * Check weather the given sequence id is one of the requested once (see 'addRequestedSequence')
222 */
223 public boolean isRequestedSeqPresent(String seqId);
224
225 /***
226 * The client side will not be able to have sequenceId as a key for storing request messages.
227 * Since it may be not known when the user adds first message.
228 * This asks for that key, giving sequence id of incoming messages.
229 */
230 public String getKeyFromIncomingSequenceId(String incomingSeqID);
231
232 /***
233 * This asks for the above key (the key used to hold messages) given the outgoing sequece id.
234 */
235 public String getKeyFromOutgoingSequenceId(String outgoingSeqID);
236
237 /***
238 * Sets this after sending the terminate sequence message.
239 */
240 public void setTerminateSend(String seqId);
241
242 /***
243 * Sets a incoming sequence of messages as terminate received.
244 */
245 public void setTerminateReceived(String seqId);
246
247 /***
248 * Checks weather the terminate message of all out going sequences have been sent.
249 */
250 public boolean isAllOutgoingTerminateSent();
251
252 /***
253 * Use this to check weather the terminate message of all sequences (incoming) has
254 * been received.
255 */
256 public boolean isAllIncommingTerminateReceived();
257
258 /***
259 * Set the acks to of the given sequence.
260 */
261 public void setAcksTo(String seqId, String acksTo);
262
263 /***
264 * gets the acksTo value
265 */
266 public String getAcksTo(String seqId);
267
268 /***
269 * Sets the offered incoming sequence, of a outgoing sequence.
270 */
271 void addOffer(String msgID, String offerID);
272
273 /***
274 * Gets the offered incoming sequence, of outgoing sequence.
275 */
276 public String getOffer(String msgID);
277
278 /***
279 * clears the storage.
280 */
281 void clear();
282
283 public boolean isOutgoingTerminateSent(String seqId);
284
285 public boolean isIncommingTerminateReceived(String seqId);
286
287 public void updateFinalMessageArrivedTime(String sequenceID);
288
289 public void sendAck(String sequenceId);
290
291 public void removeAllAcks(String sequenceID);
292 }