001: /*
002: * JBoss, Home of Professional Open Source.
003: * Copyright 2006, Red Hat Middleware LLC, and individual contributors
004: * as indicated by the @author tags. See the copyright.txt file in the
005: * distribution for a full listing of individual contributors.
006: *
007: * This is free software; you can redistribute it and/or modify it
008: * under the terms of the GNU Lesser General Public License as
009: * published by the Free Software Foundation; either version 2.1 of
010: * the License, or (at your option) any later version.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015: * Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public
018: * License along with this software; if not, write to the Free
019: * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
021: */
022: package org.jboss.test.deadlock.test;
023:
024: import javax.naming.Context;
025: import javax.naming.InitialContext;
026: import javax.ejb.DuplicateKeyException;
027: import javax.ejb.ObjectNotFoundException;
028:
029: import java.util.ArrayList;
030: import java.util.Arrays;
031: import java.util.Collections;
032: import java.util.Date;
033: import java.util.Random;
034:
035: import junit.framework.Test;
036:
037: import org.jboss.test.deadlock.interfaces.BeanOrder;
038: import org.jboss.test.deadlock.interfaces.EnterpriseEntityHome;
039: import org.jboss.test.deadlock.interfaces.EnterpriseEntity;
040: import org.jboss.test.deadlock.interfaces.StatelessSessionHome;
041: import org.jboss.test.deadlock.interfaces.StatelessSession;
042: import org.jboss.test.JBossTestCase;
043: import org.jboss.ejb.plugins.TxInterceptorCMT;
044:
045: /**
046: * Sample client for the jboss container.
047: *
048: * @author <a href="mailto:bill@burkecentral.com">Bill Burke</a>
049: * @version $Id: BeanStressTestCase.java 57211 2006-09-26 12:39:46Z dimitris@jboss.org $
050: */
051: public class BeanStressTestCase extends JBossTestCase {
052: org.apache.log4j.Category log = getLog();
053:
054: static boolean deployed = false;
055: static int test = 0;
056: static Date startDate = new Date();
057:
058: protected final String namingFactory = System
059: .getProperty(Context.INITIAL_CONTEXT_FACTORY);
060:
061: protected final String providerURL = System
062: .getProperty(Context.PROVIDER_URL);
063:
064: public BeanStressTestCase(String name) {
065: super (name);
066: }
067:
068: boolean failed = false;
069:
070: private StatelessSession getSession() throws Exception {
071:
072: StatelessSessionHome home = (StatelessSessionHome) new InitialContext()
073: .lookup("nextgen.StatelessSession");
074: return home.create();
075: }
076:
077: public class RunTest implements Runnable {
078: public String test;
079:
080: public RunTest(String test) {
081: this .test = test;
082: }
083:
084: public void run() {
085: if (test.equals("AB"))
086: runAB();
087: else
088: runBA();
089: }
090:
091: private void runAB() {
092: log.debug("running AB");
093: try {
094: getSession().callAB();
095: } catch (Exception ex) {
096: failed = true;
097: }
098: }
099:
100: private void runBA() {
101: log.debug("running BA");
102: try {
103: getSession().callBA();
104: } catch (Exception ex) {
105: failed = true;
106: }
107: }
108: }
109:
110: public void testDeadLock() throws Exception {
111: EnterpriseEntityHome home = (EnterpriseEntityHome) new InitialContext()
112: .lookup("nextgenEnterpriseEntity");
113: try {
114: EnterpriseEntity A = home.findByPrimaryKey("A");
115: } catch (ObjectNotFoundException ex) {
116: home.create("A");
117: }
118: try {
119: EnterpriseEntity B = home.findByPrimaryKey("B");
120: } catch (ObjectNotFoundException ex) {
121: home.create("B");
122: }
123: Thread one = new Thread(new RunTest("AB"));
124: Thread two = new Thread(new RunTest("BA"));
125: one.start();
126: two.start();
127: one.join();
128: two.join();
129: if (failed) {
130: fail("testing of deadlock AB BA scenario failed");
131: }
132: }
133:
134: Random random = new Random();
135:
136: int target;
137: int iterations;
138:
139: Object lock = new Object();
140: int completed = 0;
141:
142: Exception unexpected;
143:
144: public class OrderTest implements Runnable {
145: BeanOrder beanOrder;
146: EnterpriseEntityHome home;
147:
148: String toStringCached;
149:
150: public OrderTest(EnterpriseEntityHome home, int beanCount,
151: int depth) {
152: // Create the list of beans
153: ArrayList list = new ArrayList();
154: for (int i = 0; i < depth; i++)
155: list.add(new Integer(i % beanCount).toString());
156:
157: // Shuffle them
158: Collections.shuffle(list, random);
159:
160: beanOrder = new BeanOrder((String[]) list
161: .toArray(new String[beanCount]));
162: this .home = home;
163: }
164:
165: public void run() {
166: try {
167: EnterpriseEntity bean = home
168: .findByPrimaryKey(beanOrder.order[0]);
169: home = null;
170: for (int i = 0; i < iterations; i++) {
171: log.debug("Before: iter=" + i + " " + this );
172: bean.callAnotherBean(beanOrder);
173: log.debug("After : iter=" + i + " " + this );
174: }
175: } catch (Exception e) {
176: if (TxInterceptorCMT.isADE(e) == null) {
177: log.debug("Saw exception for " + this , e);
178: unexpected = e;
179: }
180: }
181: }
182:
183: public String toString() {
184: if (toStringCached != null)
185: return toStringCached;
186:
187: StringBuffer buffer = new StringBuffer();
188: buffer.append(" hash=").append(hashCode());
189: buffer.append(" order=").append(
190: Arrays.asList(beanOrder.order));
191:
192: toStringCached = buffer.toString();
193: return toStringCached;
194: }
195: }
196:
197: public class TestThread extends Thread {
198: OrderTest test;
199:
200: public TestThread(OrderTest test) {
201: super (test);
202: this .test = test;
203: }
204:
205: public void run() {
206: super .run();
207: synchronized (lock) {
208: completed++;
209: log.debug("Completed " + completed + " of " + target);
210: lock.notifyAll();
211: }
212: }
213: }
214:
215: public void waitForCompletion() throws Exception {
216: log.debug("Waiting for completion");
217: synchronized (lock) {
218: while (completed < target) {
219: lock.wait();
220: }
221: }
222: if (unexpected != null) {
223: log.error("Unexpected exception", unexpected);
224: fail("Unexpected exception");
225: }
226: }
227:
228: /**
229: * Creates a number of threads to invoke on the
230: * session beans at random to produce deadlocks.
231: * The test will timeout if a deadlock detection is missed.
232: */
233: public void testAllCompleteOrFail() throws Exception {
234: doAllCompleteOrFail("nextgenEnterpriseEntity", 2);
235: }
236:
237: /**
238: * Creates a number of threads to invoke on the
239: * session beans at random to produce deadlocks.
240: * The test will timeout if a deadlock detection is missed.
241: */
242: public void testAllCompleteOrFailReentrant() throws Exception {
243: doAllCompleteOrFail("nextgenEnterpriseEntityReentrant", 4);
244: }
245:
246: /**
247: * Creates a number of threads to invoke on the
248: * session beans at random to produce deadlocks.
249: * The test will timeout if a deadlock detection is missed.
250: */
251: public void testAllCompleteOrFailNotSupported() throws Exception {
252: doAllCompleteOrFail("nextgenEnterpriseEntityNotSupported", 2);
253: }
254:
255: /**
256: * Creates a number of threads to invoke on the
257: * session beans at random to produce deadlocks.
258: * The test will timeout if a deadlock detection is missed.
259: */
260: public void testAllCompleteOrFailNotSupportedReentrant()
261: throws Exception {
262: doAllCompleteOrFail(
263: "nextgenEnterpriseEntityNotSupportedReentrant", 4);
264: }
265:
266: /**
267: * Creates a number of threads to invoke on the
268: * session beans at random to produce deadlocks.
269: * The test will timeout if a deadlock detection is missed.
270: */
271: public void doAllCompleteOrFail(String jndiName, int depth)
272: throws Exception {
273: log.debug("========= Starting " + getName());
274:
275: // Non-standard: We want a lot of threads and a small number of beans
276: // for maximum contention
277: // target = getThreadCount();
278: // int beanCount = getBeanCount();
279: target = 40;
280: int beanCount = 2;
281: completed = 0;
282: unexpected = null;
283:
284: // Create some beans
285: EnterpriseEntityHome home = (EnterpriseEntityHome) new InitialContext()
286: .lookup(jndiName);
287: for (int i = 0; i < beanCount; i++) {
288: try {
289: home.create(new Integer(i).toString());
290: } catch (DuplicateKeyException weDontCare) {
291: }
292: }
293:
294: // Create some threads
295: TestThread[] threads = new TestThread[target];
296: for (int i = 0; i < target; i++)
297: threads[i] = new TestThread(new OrderTest(home, beanCount,
298: depth));
299:
300: // Start the threads
301: for (int i = 0; i < target; i++) {
302: log.debug("Starting " + threads[i].test);
303: threads[i].start();
304: }
305:
306: waitForCompletion();
307:
308: log.debug("========= Completed " + getName());
309: }
310:
311: public class CMRTest implements Runnable {
312: StatelessSession session;
313: String jndiName;
314: String start;
315:
316: public CMRTest(StatelessSession session, String jndiName,
317: String start) {
318: this .session = session;
319: this .jndiName = jndiName;
320: this .start = start;
321: }
322:
323: public void run() {
324: try {
325: session.cmrTest(jndiName, start);
326: } catch (Exception e) {
327: if (TxInterceptorCMT.isADE(e) == null) {
328: log.debug("Saw exception for " + this , e);
329: unexpected = e;
330: }
331: }
332: }
333:
334: public String toString() {
335: return hashCode() + " " + start;
336: }
337: }
338:
339: public class CMRTestThread extends Thread {
340: CMRTest test;
341:
342: public CMRTestThread(CMRTest test) {
343: super (test);
344: this .test = test;
345: }
346:
347: public void run() {
348: super .run();
349: synchronized (lock) {
350: completed++;
351: log.debug("Completed " + completed + " of " + target);
352: lock.notifyAll();
353: }
354: }
355: }
356:
357: /**
358: * Creates a number of threads to CMR relationships.
359: * The test will timeout if a deadlock detection is missed.
360: */
361: public void testAllCompleteOrFailCMR() throws Exception {
362: doAllCompleteOrFailCMR("local/nextgenEnterpriseEntity");
363: }
364:
365: /**
366: * Creates a number of threads to CMR relationships.
367: * The test will timeout if a deadlock detection is missed.
368: */
369: public void doAllCompleteOrFailCMR(String jndiName)
370: throws Exception {
371: log.debug("========= Starting " + getName());
372:
373: // Non-standard: We want a lot of threads and a small number of beans
374: // for maximum contention
375: // target = getThreadCount();
376: // int beanCount = getBeanCount();
377: target = 40;
378: completed = 0;
379: unexpected = null;
380:
381: // Create some beans
382: StatelessSessionHome home = (StatelessSessionHome) new InitialContext()
383: .lookup("nextgen.StatelessSession");
384: StatelessSession session = home.create();
385: session.createCMRTestData(jndiName);
386:
387: // Create some threads
388: CMRTestThread[] threads = new CMRTestThread[target];
389: for (int i = 0; i < target; i++)
390: threads[i] = new CMRTestThread(new CMRTest(session,
391: jndiName, i % 2 == 0 ? "First" : "Second"));
392:
393: // Start the threads
394: for (int i = 0; i < target; i++) {
395: log.debug("Starting " + threads[i].test);
396: threads[i].start();
397: }
398:
399: waitForCompletion();
400:
401: log.debug("========= Completed " + getName());
402: }
403:
404: /*
405: public void testRequiresNewDeadlock()
406: throws Exception
407: {
408:
409: EnterpriseEntityHome home = (EnterpriseEntityHome)new InitialContext().lookup("nextgenEnterpriseEntity");
410: try
411: {
412: EnterpriseEntity C = home.findByPrimaryKey("C");
413: }
414: catch (ObjectNotFoundException ex)
415: {
416: home.create("C");
417: }
418:
419: boolean deadlockExceptionThrown = false;
420: try
421: {
422: getSession().requiresNewTest(true);
423: }
424: catch (RemoteException ex)
425: {
426: if (ex.detail instanceof ApplicationDeadlockException)
427: {
428: deadlockExceptionThrown = true;
429: }
430: }
431: assertTrue("ApplicationDeadlockException was not thrown", deadlockExceptionThrown);
432: }
433: */
434:
435: public void testCleanup() throws Exception {
436: // Restart the db pool
437: super .restartDBPool();
438: }
439:
440: public static Test suite() throws Exception {
441: return getDeploySetup(BeanStressTestCase.class, "deadlock.jar");
442: }
443: }
|