KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > tc > objectserver > tx > ServerTransactionManagerImplTest


1 /*
2  * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright
3  * notice. All rights reserved.
4  */

5 package com.tc.objectserver.tx;
6
7 import EDU.oswego.cs.dl.util.concurrent.LinkedQueue;
8
9 import com.tc.exception.ImplementMe;
10 import com.tc.exception.TCRuntimeException;
11 import com.tc.net.protocol.tcm.ChannelID;
12 import com.tc.net.protocol.tcm.MessageChannel;
13 import com.tc.object.ObjectID;
14 import com.tc.object.dmi.DmiDescriptor;
15 import com.tc.object.dna.impl.ObjectStringSerializer;
16 import com.tc.object.gtx.GlobalTransactionID;
17 import com.tc.object.lockmanager.api.LockID;
18 import com.tc.object.net.ChannelStats;
19 import com.tc.object.tx.ServerTransactionID;
20 import com.tc.object.tx.TransactionID;
21 import com.tc.object.tx.TxnBatchID;
22 import com.tc.object.tx.TxnType;
23 import com.tc.objectserver.api.ObjectInstanceMonitor;
24 import com.tc.objectserver.gtx.TestGlobalTransactionManager;
25 import com.tc.objectserver.impl.ObjectInstanceMonitorImpl;
26 import com.tc.objectserver.impl.TestObjectManager;
27 import com.tc.objectserver.l1.api.TestClientStateManager;
28 import com.tc.objectserver.l1.impl.TransactionAcknowledgeAction;
29 import com.tc.objectserver.lockmanager.api.TestLockManager;
30 import com.tc.objectserver.managedobject.BackReferences;
31 import com.tc.objectserver.persistence.impl.TestTransactionStore;
32 import com.tc.stats.counter.Counter;
33 import com.tc.stats.counter.CounterImpl;
34 import com.tc.util.SequenceID;
35
36 import java.util.ArrayList JavaDoc;
37 import java.util.Collections JavaDoc;
38 import java.util.HashMap JavaDoc;
39 import java.util.HashSet JavaDoc;
40 import java.util.Iterator JavaDoc;
41 import java.util.LinkedList JavaDoc;
42 import java.util.List JavaDoc;
43 import java.util.Map JavaDoc;
44 import java.util.Set JavaDoc;
45
46 import junit.framework.TestCase;
47
48 public class ServerTransactionManagerImplTest extends TestCase {
49
50   private ServerTransactionManagerImpl transactionManager;
51   private TestTransactionAcknowledgeAction action;
52   private TestClientStateManager clientStateManager;
53   private TestLockManager lockManager;
54   private TestObjectManager objectManager;
55   private TestTransactionStore transactionStore;
56   private Counter transactionRateCounter;
57   private TestChannelStats channelStats;
58   private TestGlobalTransactionManager gtxm;
59   private int idsequence;
60   private ObjectInstanceMonitor imo;
61
62   protected void setUp() throws Exception JavaDoc {
63     super.setUp();
64     this.action = new TestTransactionAcknowledgeAction();
65     this.clientStateManager = new TestClientStateManager();
66     this.lockManager = new TestLockManager();
67     this.objectManager = new TestObjectManager();
68     this.transactionStore = new TestTransactionStore();
69     this.transactionRateCounter = new CounterImpl();
70     this.channelStats = new TestChannelStats();
71     this.gtxm = new TestGlobalTransactionManager();
72     this.imo = new ObjectInstanceMonitorImpl();
73     newTransactionManager();
74   }
75
76   protected void tearDown() throws Exception JavaDoc {
77     super.tearDown();
78   }
79
80   private void newTransactionManager() {
81     this.transactionManager = new ServerTransactionManagerImpl(this.gtxm, this.transactionStore, this.lockManager,
82                                                                this.clientStateManager, this.objectManager,
83                                                                this.action, this.transactionRateCounter,
84                                                                this.channelStats);
85   }
86
87   public void testRootCreatedEvent() {
88     Map JavaDoc roots = new HashMap JavaDoc();
89     roots.put("root", new ObjectID(1));
90
91     // first test w/o any listeners attached
92
this.transactionManager.release(null, Collections.EMPTY_SET, roots);
93
94     // add a listener
95
Listener listener = new Listener();
96     this.transactionManager.addRootListener(listener);
97     roots.clear();
98     roots.put("root2", new ObjectID(2));
99
100     this.transactionManager.release(null, Collections.EMPTY_SET, roots);
101     assertEquals(1, listener.rootsCreated.size());
102     Root root = (Root) listener.rootsCreated.remove(0);
103     assertEquals("root2", root.name);
104     assertEquals(new ObjectID(2), root.id);
105
106     // add another listener
107
Listener listener2 = new Listener();
108     this.transactionManager.addRootListener(listener2);
109     roots.clear();
110     roots.put("root3", new ObjectID(3));
111
112     this.transactionManager.release(null, Collections.EMPTY_SET, roots);
113     assertEquals(1, listener.rootsCreated.size());
114     root = (Root) listener.rootsCreated.remove(0);
115     assertEquals("root3", root.name);
116     assertEquals(new ObjectID(3), root.id);
117     root = (Root) listener2.rootsCreated.remove(0);
118     assertEquals("root3", root.name);
119     assertEquals(new ObjectID(3), root.id);
120
121     // add a listener that throws an exception
122
this.transactionManager.addRootListener(new ServerTransactionManagerEventListener() {
123       public void rootCreated(String JavaDoc name, ObjectID id) {
124         throw new RuntimeException JavaDoc("This exception is supposed to be here");
125       }
126     });
127     this.transactionManager.release(null, Collections.EMPTY_SET, roots);
128   }
129
130   public void tests() throws Exception JavaDoc {
131
132     ChannelID cid1 = new ChannelID(1);
133     TransactionID tid1 = new TransactionID(1);
134     TransactionID tid2 = new TransactionID(2);
135     ChannelID cid2 = new ChannelID(2);
136     ChannelID cid3 = new ChannelID(3);
137
138     LockID[] lockIDs = new LockID[0];
139     List JavaDoc dnas = Collections.unmodifiableList(new LinkedList JavaDoc());
140     ObjectStringSerializer serializer = null;
141     Map JavaDoc newRoots = Collections.unmodifiableMap(new HashMap JavaDoc());
142     TxnType txnType = TxnType.NORMAL;
143     SequenceID sequenceID = new SequenceID(1);
144     ServerTransaction tx1 = new ServerTransactionImpl(new TxnBatchID(1), tid1, sequenceID, lockIDs, cid1, dnas,
145                                                       serializer, newRoots, txnType, new LinkedList JavaDoc(),
146                                                       DmiDescriptor.EMPTY_ARRAY);
147
148     // Test with one waiter
149
transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid2);
150     assertTrue(transactionManager.isWaiting(cid1, tid1));
151     assertTrue(action.clientID == null && action.txID == null);
152     transactionManager.acknowledgement(cid1, tid1, cid2);
153     assertTrue(action.clientID == null && action.txID == null);
154     Set JavaDoc txns = new HashSet JavaDoc();
155     txns.add(tx1);
156     doStages(cid1, txns);
157     assertTrue(action.clientID == cid1 && action.txID == tid1);
158     assertFalse(transactionManager.isWaiting(cid1, tid1));
159
160     // Test with 2 waiters
161
action.clear();
162     gtxm.clear();
163     transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid2);
164     transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid3);
165     assertTrue(action.clientID == null && action.txID == null);
166     assertTrue(transactionManager.isWaiting(cid1, tid1));
167     transactionManager.acknowledgement(cid1, tid1, cid2);
168     assertTrue(action.clientID == null && action.txID == null);
169     assertTrue(transactionManager.isWaiting(cid1, tid1));
170     transactionManager.acknowledgement(cid1, tid1, cid3);
171     assertTrue(action.clientID == null && action.txID == null);
172     doStages(cid1, txns);
173     assertTrue(action.clientID == cid1 && action.txID == tid1);
174     assertFalse(transactionManager.isWaiting(cid1, tid1));
175
176     // Test shutdown client with 2 waiters
177
action.clear();
178     gtxm.clear();
179     transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid2);
180     transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid3);
181     assertTrue(action.clientID == null && action.txID == null);
182     assertTrue(transactionManager.isWaiting(cid1, tid1));
183     transactionManager.shutdownClient(cid3);
184     assertTrue(this.clientStateManager.shutdownClientCalled);
185     assertTrue(transactionManager.isWaiting(cid1, tid1));
186     transactionManager.acknowledgement(cid1, tid1, cid2);
187     doStages(cid1, txns);
188     assertTrue(action.clientID == cid1 && action.txID == tid1);
189     assertFalse(transactionManager.isWaiting(cid1, tid1));
190
191     // Test shutdown client that no one is waiting for
192
action.clear();
193     gtxm.clear();
194     transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid2);
195     transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid3);
196     transactionManager.shutdownClient(cid1);
197     assertTrue(action.clientID == null && action.txID == null);
198     assertFalse(transactionManager.isWaiting(cid1, tid1));
199
200     // Test with 2 waiters on different tx's
201
action.clear();
202     gtxm.clear();
203     transactionManager.addWaitingForAcknowledgement(cid1, tid1, cid2);
204     transactionManager.addWaitingForAcknowledgement(cid1, tid2, cid2);
205
206     assertTrue(action.clientID == null && action.txID == null);
207     assertTrue(transactionManager.isWaiting(cid1, tid1));
208     assertTrue(transactionManager.isWaiting(cid1, tid2));
209
210     transactionManager.acknowledgement(cid1, tid1, cid2);
211     assertFalse(transactionManager.isWaiting(cid1, tid1));
212     assertTrue(transactionManager.isWaiting(cid1, tid2));
213     doStages(cid1, txns);
214     assertTrue(action.clientID == cid1 && action.txID == tid1);
215
216     action.clear();
217     gtxm.clear();
218     transactionManager.acknowledgement(cid1, tid2, cid2);
219     ServerTransaction tx2 = new ServerTransactionImpl(new TxnBatchID(2), tid2, sequenceID, lockIDs, cid1, dnas,
220                                                       serializer, newRoots, txnType, new LinkedList JavaDoc(),
221                                                       DmiDescriptor.EMPTY_ARRAY);
222     txns.clear();
223     txns.add(tx2);
224     doStages(cid1, txns);
225     assertTrue(action.clientID == cid1 && action.txID == tid2);
226     assertFalse(transactionManager.isWaiting(cid1, tid1));
227     assertFalse(transactionManager.isWaiting(cid1, tid2));
228   }
229
230   private void doStages(ChannelID cid, Set JavaDoc txns) {
231
232     // process stage
233
transactionManager.incomingTransactions(cid, getServerTransactionIDs(txns), false);
234
235     for (Iterator JavaDoc iter = txns.iterator(); iter.hasNext();) {
236       ServerTransaction tx = (ServerTransaction) iter.next();
237
238       // apply stage
239
transactionManager.apply(new GlobalTransactionID(idsequence++), tx, Collections.EMPTY_MAP, new BackReferences(),
240                                imo);
241       assertTrue(action.clientID == null && action.txID == null);
242       // release
243
transactionManager.release(null, Collections.EMPTY_SET, Collections.EMPTY_MAP);
244       assertTrue(action.clientID == null && action.txID == null);
245       // commit stage
246
gtxm.commitAll(null, getServerTransactionIDs(txns));
247       ArrayList JavaDoc committedIDs = new ArrayList JavaDoc();
248       committedIDs.add(tx.getServerTransactionID());
249       transactionManager.committed(committedIDs);
250       assertTrue(action.clientID == null && action.txID == null);
251
252       // broadcast stage
253
transactionManager.broadcasted(tx.getChannelID(), tx.getTransactionID());
254     }
255   }
256
257   private Set JavaDoc getServerTransactionIDs(Set JavaDoc txns) {
258     Set JavaDoc s = new HashSet JavaDoc();
259     for (Iterator JavaDoc iter = txns.iterator(); iter.hasNext();) {
260       s.add(((ServerTransaction) iter.next()).getServerTransactionID());
261     }
262     return s;
263   }
264
265   private static final class TestChannelStats implements ChannelStats {
266
267     public LinkedQueue notifyTransactionContexts = new LinkedQueue();
268
269     public Counter getCounter(MessageChannel channel, String JavaDoc name) {
270       throw new ImplementMe();
271     }
272
273     public void notifyTransaction(ChannelID channelID) {
274       try {
275         notifyTransactionContexts.put(channelID);
276       } catch (InterruptedException JavaDoc e) {
277         throw new TCRuntimeException(e);
278       }
279     }
280
281   }
282
283   private static class Root {
284     final String JavaDoc name;
285     final ObjectID id;
286
287     Root(String JavaDoc name, ObjectID id) {
288       this.name = name;
289       this.id = id;
290     }
291   }
292
293   private static class Listener implements ServerTransactionManagerEventListener {
294     final List JavaDoc rootsCreated = new ArrayList JavaDoc();
295
296     public void rootCreated(String JavaDoc name, ObjectID id) {
297       rootsCreated.add(new Root(name, id));
298     }
299   }
300
301   public class TestTransactionAcknowledgeAction implements TransactionAcknowledgeAction {
302     public ChannelID clientID;
303     public TransactionID txID;
304
305     public void acknowledgeTransaction(ServerTransactionID stxID) {
306       this.txID = stxID.getClientTransactionID();
307       this.clientID = stxID.getChannelID();
308     }
309
310     public void clear() {
311       txID = null;
312       clientID = null;
313     }
314
315   }
316 }
317
Popular Tags