KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > tctest > restart > unit > DSOServerRestartTester


1 /*
2  * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright notice. All rights reserved.
3  */
4 package com.tctest.restart.unit;
5
6 import EDU.oswego.cs.dl.util.concurrent.CyclicBarrier;
7 import EDU.oswego.cs.dl.util.concurrent.FutureResult;
8
9 import com.tc.exception.TCRuntimeException;
10 import com.tc.objectserver.control.ServerControl;
11 import com.tc.test.TCTestCase;
12 import com.tc.test.restart.RestartTestEnvironment;
13 import com.tc.util.PortChooser;
14 import com.tc.util.concurrent.ThreadUtil;
15 import com.tctest.restart.AppStateSnapshot;
16
17 import java.io.File JavaDoc;
18 import java.util.Iterator JavaDoc;
19
20 public class DSOServerRestartTester extends TCTestCase {
21
22   private RestartTestEnvironment env;
23   private long startTimeout = 30 * 1000;
24
25   public void setUp() throws Exception JavaDoc {
26     super.setUp();
27     env = new RestartTestEnvironment(this.getTempDirectory(), new PortChooser(), RestartTestEnvironment.PROD_MODE);
28     env.setUp();
29   }
30
31   public void tearDown() throws Exception JavaDoc {
32     assertNoTestThreadExceptions();
33     env.shutdownServer();
34   }
35
36   public void testLockState() throws Exception JavaDoc {
37     RestartUnitTestApp[] apps = new RestartUnitTestApp[10];
38     for (int i = 0; i < apps.length; i++) {
39       apps[i] = new DSOServerRestartTestApp(env.getThreadGroup());
40     }
41
42     basicTestLockState(apps);
43
44     waitForTestThreads();
45   }
46
47   public void testDSOLockState() throws Exception JavaDoc {
48     env.newExtraProcessServer();
49     env.startServer(startTimeout);
50     RestartUnitTestApp[] apps = newTestApps(10);
51
52     basicTestLockState(apps);
53
54     waitForTestThreads();
55   }
56
57   private void basicTestLockState(RestartUnitTestApp[] apps) throws Exception JavaDoc {
58     Object JavaDoc lck = new Object JavaDoc();
59     AppStateSnapshot snapshot = new AppStateSnapshot(apps);
60     CyclicBarrier startBarrier = new CyclicBarrier(apps.length + 1);
61     for (int i = 0; i < apps.length; i++) {
62       final RestartUnitTestApp app = apps[i];
63       app.setID(i);
64       app.reset();
65       app.setSharedLock(lck);
66       app.setStartBarrier(startBarrier);
67       env.startNewClientThread(new Runnable JavaDoc() {
68         public void run() {
69           app.attemptLock();
70         }
71       });
72     }
73
74     // wait until all the threads have started.
75 startBarrier.barrier();
76
77     while (true) {
78       stopServerAndReleaseLock(snapshot);
79       System.out.println(snapshot);
80       if (!snapshot.allEnded() && !env.hasThreadGroupErrors()) env.startServer(startTimeout);
81       else break;
82     }
83   }
84
85   private void stopServerAndReleaseLock(AppStateSnapshot snapshot) throws Exception JavaDoc {
86     RestartUnitTestApp holder = (RestartUnitTestApp) snapshot.getHolder();
87     // there was no holder. We're done.
88 if (holder == null) {
89       if (snapshot.allEnded()) return;
90       else fail("No holder, but not all ended: " + snapshot);
91     }
92
93     // start the shutdown sequence.
94 if (env.getServer().isRunning()) env.getServer().attemptShutdown();
95     // XXX: Yuck.
96 Thread.sleep(2000);
97     // release the lock, so the server can shut down.
98 holder.fallThrough();
99     // wait until the server has stopped...
100 while (env.getServer().isRunning()) {
101       Thread.sleep(100);
102     }
103   }
104
105   public void testDSOWaitNotify() throws Exception JavaDoc {
106     env.newExtraProcessServer();
107     env.startServer(startTimeout);
108     RestartUnitTestApp[] apps = newTestApps(10);
109     basicTestWaitNotify(apps);
110     waitForTestThreads();
111   }
112
113   private void basicTestWaitNotify(RestartUnitTestApp[] apps) throws Exception JavaDoc {
114     Object JavaDoc lck = new Object JavaDoc();
115     AppStateSnapshot snapshot = new AppStateSnapshot(apps);
116     CyclicBarrier startBarrier = new CyclicBarrier(1);
117     apps[0].setDistributedSharedLock(lck);
118     ServerControl server = env.getServer();
119     for (int i = 0; i < apps.length; i++) {
120       final RestartUnitTestApp app = apps[i];
121       app.setID(i);
122       app.reset();
123       app.setStartBarrier(startBarrier);
124       env.startNewClientThread(new Runnable JavaDoc() {
125         public void run() {
126           app.doWait(0);
127         }
128       });
129     }
130     while (!snapshot.allWaiters()) {
131       // wait until all the threads have had a chance to wait on the distributed
132 // object...
133 snapshot.takeSnapshot();
134     }
135
136     for (int i = 0; i < apps.length; i++) {
137       // call notify() to allow a single app to continue.
138 apps[0].doNotify();
139       server.shutdown();
140       snapshot.takeSnapshot();
141       System.out.println(snapshot);
142       assertEquals(apps.length - i - 1, snapshot.getWaiters().length);
143       if (i + 1 < apps.length) {
144         server.start(startTimeout);
145       }
146     }
147     snapshot.takeSnapshot();
148     assertTrue(snapshot.allEnded());
149   }
150
151   public void testDSOWaitNotifyAll() throws Exception JavaDoc {
152     env.newExtraProcessServer().start(startTimeout);
153     RestartUnitTestApp[] apps = newTestApps(10);
154     basicTestWaitNotifyAll(apps);
155     waitForTestThreads();
156   }
157
158   public void testDSOTimedWait() throws Exception JavaDoc {
159     env.newExtraProcessServer().start(startTimeout);
160     RestartUnitTestApp[] apps = newTestApps(10);
161     basicTestTimedWait(apps);
162     waitForTestThreads();
163   }
164
165   private void basicTestTimedWait(RestartUnitTestApp[] apps) throws Exception JavaDoc {
166     ServerControl server = env.getServer();
167     Object JavaDoc lck = new Object JavaDoc();
168     AppStateSnapshot snapshot = new AppStateSnapshot(apps);
169     RestartUnitTestApp shutdownBlocker = newTestApps(1)[0];
170     shutdownBlocker.setStartBarrier(new CyclicBarrier(1));
171     final CyclicBarrier startBarrier = new CyclicBarrier(apps.length + 1);
172     apps[0].setDistributedSharedLock(lck);
173     final int waitTime = 10 * 1000;
174     for (int i = 0; i < apps.length; i++) {
175       final RestartUnitTestApp app = apps[i];
176       app.setID(i);
177       app.reset();
178       app.setStartBarrier(startBarrier);
179       env.startNewClientThread(new Runnable JavaDoc() {
180         public void run() {
181           app.doWait(waitTime);
182         }
183       });
184     }
185
186     startBarrier.barrier();
187     while (!snapshot.takeSnapshot().allWaiters()) {
188       System.out.println("Waiting for all apps to be waiters: " + snapshot);
189       ThreadUtil.reallySleep(100);
190     }
191     System.out.println("obtaining a lock to block shutdown...");
192     FutureResult shutdownBlockerBarrier = new FutureResult();
193     shutdownBlocker.blockShutdown(shutdownBlockerBarrier);
194     System.out.println("starting server shutdown sequence...");
195     server.attemptShutdown();
196     System.out.println("waiting for timers to go off in server before allowing shutdown to complete...");
197     ThreadUtil.reallySleep(waitTime + 1000);
198     System.out.println("letting the server finish shutting down...");
199     shutdownBlockerBarrier.set(new Object JavaDoc());
200     System.out.println("waiting until server is actually shut down...");
201     server.waitUntilShutdown();
202
203     assertTrue(snapshot.takeSnapshot().allWaiters());
204     ThreadUtil.reallySleep(waitTime);
205     assertTrue(snapshot.takeSnapshot().allWaiters());
206     server.start(startTimeout);
207     while (!snapshot.takeSnapshot().allEnded()) {
208       System.out.println(snapshot);
209       ThreadUtil.reallySleep(500);
210     }
211   }
212
213   private void basicTestWaitNotifyAll(RestartUnitTestApp[] apps) throws Exception JavaDoc {
214     ServerControl server = env.getServer();
215     Object JavaDoc lck = new Object JavaDoc();
216     AppStateSnapshot snapshot = new AppStateSnapshot(apps);
217     CyclicBarrier startBarrier = new CyclicBarrier(1);
218     apps[0].setDistributedSharedLock(lck);
219     for (int i = 0; i < apps.length; i++) {
220       final RestartUnitTestApp app = apps[i];
221       app.setID(i);
222       app.reset();
223       app.setStartBarrier(startBarrier);
224       env.startNewClientThread(new Runnable JavaDoc() {
225         public void run() {
226           app.doWait(0);
227         }
228       });
229     }
230     // wait until all the threads have waited on the object.
231 while (!snapshot.allWaiters()) {
232       snapshot.takeSnapshot();
233     }
234
235     server.shutdown();
236     final CyclicBarrier serverStartBarrier = new CyclicBarrier(2);
237     final RestartUnitTestApp app = apps[0];
238     new Thread JavaDoc(new Runnable JavaDoc() {
239       public void run() {
240         try {
241           serverStartBarrier.barrier();
242           app.doNotifyAll();
243         } catch (Exception JavaDoc e) {
244           throw new TCRuntimeException(e);
245         }
246       }
247     }).start();
248
249     serverStartBarrier.barrier();
250     server.start(startTimeout);
251     do {
252       snapshot.takeSnapshot();
253       System.out.println(snapshot);
254       Thread.sleep(500);
255     } while (!snapshot.allEnded());
256   }
257
258   private RestartUnitTestApp newRestartTestApp(ThreadGroup JavaDoc tg) throws Exception JavaDoc {
259     // FIXME 2005-12-01 andrew
260 // IsolationClassLoader cl = new IsolationClassLoader(env.getDSOConfig(), env.getL1DSOConfig());
261 // Class clazz = cl.loadClass(DSOServerRestartTestApp.class.getName());
262 // Constructor ctor = clazz.getConstructor(new Class[] { ThreadGroup.class });
263 // return (RestartUnitTestApp) ctor.newInstance(new Object[] { tg });
264 return null;
265   }
266
267   private RestartUnitTestApp[] newTestApps(int instanceCount) throws Exception JavaDoc {
268     // FIXME 2005-12-01 andrew
269 // DSOServerRestartTestApp.visitL1DSOConfig(null, env.getL1DSOConfig());
270 RestartUnitTestApp[] apps = new RestartUnitTestApp[instanceCount];
271     for (int i = 0; i < apps.length; i++) {
272       apps[i] = newRestartTestApp(env.getThreadGroup());
273     }
274     return apps;
275   }
276
277   public void testServerStartAndStop() throws Exception JavaDoc {
278     env.newExtraProcessServer();
279     assertTrue(isEmptyDirectory(env.getDBHome()));
280     env.startServer(startTimeout);
281     env.shutdownServer();
282     assertFalse(isEmptyDirectory(env.getDBHome()));
283   }
284
285   private boolean isEmptyDirectory(File JavaDoc dir) {
286     if (dir.exists()) {
287       if (!dir.isDirectory()) return false;
288       if (dir.listFiles().length != 0) return false;
289     }
290     return true;
291   }
292
293   private void waitForTestThreads() {
294     while (!env.hasThreadGroupErrors() && env.hasActiveClients()) {
295       ThreadUtil.reallySleep(500);
296     }
297   }
298
299   private void assertNoTestThreadExceptions() {
300     boolean failed = false;
301     for (Iterator JavaDoc i = env.getThreadGroupErrors().iterator(); i.hasNext();) {
302       ((Throwable JavaDoc) i.next()).printStackTrace();
303       failed = true;
304     }
305     assertFalse("There were test thread exceptions", failed);
306   }
307 }
308
Popular Tags