Author: manik.surtani(a)jboss.com Date: 2007-09-14 11:51:46 -0400 (Fri, 14 Sep 2007) New Revision: 4462 Added: core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/ core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/ConcurrentPutRemoveTest.java core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockNotReleasedTest.java core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockUpgradeTest.java core/trunk/src/test/java/org/jboss/cache/transaction/AsyncRollbackTxLockTest.java Removed: core/trunk/src/test/java/org/jboss/cache/ConcurrentPutRemoveTest.java Log: Added tests for a series of bugs, including JBCACHE-923, JBCACHE-1164, JBCACHE-1165, JBCACHE-1166, JBCACHE-1168, JBCACHE-1183. Deleted: core/trunk/src/test/java/org/jboss/cache/ConcurrentPutRemoveTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/ConcurrentPutRemoveTest.java 2007-09-14 15:50:44 UTC (rev 4461) +++ core/trunk/src/test/java/org/jboss/cache/ConcurrentPutRemoveTest.java 2007-09-14 15:51:46 UTC (rev 4462) @@ -1,87 +0,0 @@ -package org.jboss.cache; - -import java.util.ArrayList; -import java.util.List; - -import javax.transaction.TransactionManager; - -import junit.framework.TestCase; - -import org.jboss.cache.lock.IsolationLevel; -import org.jboss.cache.config.Configuration; -import org.jboss.cache.transaction.DummyTransactionManagerLookup; - -public class ConcurrentPutRemoveTest extends TestCase { - - private TransactionManager tm; - - private Cache cache; - - protected void setUp() throws Exception { - cache = DefaultCacheFactory.getInstance().createCache(false); - cache.getConfiguration().setCacheMode(Configuration.CacheMode.LOCAL); - cache.getConfiguration().setIsolationLevel(IsolationLevel.READ_COMMITTED); - cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); - cache.getConfiguration().setLockAcquisitionTimeout(10000); - cache.start(); - tm = cache.getConfiguration().getRuntimeConfig().getTransactionManager(); - } - - protected void tearDown() throws Exception { - super.tearDown(); - cache.stop(); - cache.destroy(); - } - - public void testLock() throws Exception { - List<SeparateThread> threads = new ArrayList<SeparateThread>(); - for (int x = 0; x < 2; x++) { - SeparateThread t = new SeparateThread(x); - threads.add(t); - t.start(); - } - for (SeparateThread separateThread : threads) { - separateThread.join(); - if (separateThread.getException() != null) { - throw separateThread.getException(); - } - } - - } - - private class SeparateThread extends Thread { - Exception e = null; - - private int num = 0; - - public SeparateThread(int num) { - this.num = num; - } - - public Exception getException() { - return e; - } - - public void run() { - - Thread.currentThread().setName("Thread:" + num); - try { - for (int x = 0; x < 1000; x++) { - tm.begin(); - System.out.println("R" + Thread.currentThread().getName()); - //inside transaction - cache.removeNode(Fqn.fromString("/a")); - System.out.println("AR" + Thread.currentThread().getName()); - tm.commit(); - //outside transaction - System.out.println("P" + Thread.currentThread().getName()); - cache.put(Fqn.fromString("/a/b/c/d"), "text"+x,"b"); - System.out.println("AP" + Thread.currentThread().getName()); - } - } catch (Exception e) { - this.e = e; - } - } - } - -} Added: core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/ConcurrentPutRemoveTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/ConcurrentPutRemoveTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/ConcurrentPutRemoveTest.java 2007-09-14 15:51:46 UTC (rev 4462) @@ -0,0 +1,92 @@ +package org.jboss.cache.lock.pessimistic; + +import org.testng.annotations.Test; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.AfterMethod; +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.Fqn; +import org.jboss.cache.lock.IsolationLevel; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.transaction.DummyTransactionManagerLookup; + +import java.util.ArrayList; +import java.util.List; + +import javax.transaction.TransactionManager; + +@Test(groups = {"functional"}) +public class ConcurrentPutRemoveTest +{ + private TransactionManager tm; + + private Cache cache; + + @BeforeMethod(alwaysRun = true) + public void setUp() throws Exception { + cache = DefaultCacheFactory.getInstance().createCache(false); + cache.getConfiguration().setCacheMode(Configuration.CacheMode.LOCAL); + cache.getConfiguration().setIsolationLevel(IsolationLevel.READ_COMMITTED); + cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + cache.getConfiguration().setLockAcquisitionTimeout(10000); + cache.start(); + tm = cache.getConfiguration().getRuntimeConfig().getTransactionManager(); + } + + @AfterMethod(alwaysRun = true) + public void tearDown() throws Exception + { + cache.destroy(); + } + + public void testLock() throws Exception { + List<SeparateThread> threads = new ArrayList<SeparateThread>(); + for (int x = 0; x < 2; x++) { + SeparateThread t = new SeparateThread(x); + threads.add(t); + t.start(); + } + for (SeparateThread separateThread : threads) { + separateThread.join(); + if (separateThread.getException() != null) { + throw separateThread.getException(); + } + } + + } + + private class SeparateThread extends Thread { + Exception e = null; + + private int num = 0; + + public SeparateThread(int num) { + this.num = num; + } + + public Exception getException() { + return e; + } + + public void run() { + Thread.currentThread().setName("Thread:" + num); + try { + for (int x = 0; x < 1000; x++) { + tm.begin(); + System.out.println("R" + Thread.currentThread().getName()); + //inside transaction + cache.removeNode(Fqn.fromString("/a")); + System.out.println("AR" + Thread.currentThread().getName()); + tm.commit(); + //outside transaction + System.out.println("P" + Thread.currentThread().getName()); + cache.put(Fqn.fromString("/a/b/c/d"), "text"+x,"b"); + System.out.println("AP" + Thread.currentThread().getName()); + } + } catch (Exception e) { + this.e = e; + } + } + } + +} Added: core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockNotReleasedTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockNotReleasedTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockNotReleasedTest.java 2007-09-14 15:51:46 UTC (rev 4462) @@ -0,0 +1,161 @@ +package org.jboss.cache.lock.pessimistic; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Random; + +import javax.transaction.TransactionManager; + + +import org.jboss.cache.CacheException; +import org.jboss.cache.Node; +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.Fqn; +import org.jboss.cache.UnversionedNode; +import org.jboss.cache.CacheImpl; +import org.jboss.cache.config.ConfigurationComponent; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.transaction.DummyTransactionManagerLookup; +import org.jboss.cache.lock.IsolationLevel; +import org.testng.annotations.Test; +import org.testng.annotations.AfterMethod; + +@Test(groups = {"functional"}) +public class LockNotReleasedTest +{ + Random rand = new Random(System.currentTimeMillis()); + + private TransactionManager tm; + + private Cache cache; + + private void startTest() throws Exception { + cache = DefaultCacheFactory.getInstance().createCache(false); + cache.getConfiguration().setCacheMode(Configuration.CacheMode.LOCAL); + cache.getConfiguration().setIsolationLevel(IsolationLevel.READ_COMMITTED); + cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + cache.getConfiguration().setLockAcquisitionTimeout(1000); + cache.create(); + cache.start(); + tm = cache.getConfiguration().getRuntimeConfig().getTransactionManager(); + } + + @AfterMethod(alwaysRun = true) + public void tearDown() throws Exception { + cache.stop(); + cache.destroy(); + } + + + public int getNumberOfLocksHeld() + { + return numLocks(cache.getRoot()); + } + + private int numLocks(Node node) + { + UnversionedNode n = (UnversionedNode) node; + int num = 0; + Map children; + + if (n.getLock().isLocked()){ + num++; + System.out.println("Node ["+n.getFqn()+"] is locked"); + } + if ((children = n.getChildrenMapDirect()) != null) + { + for (Object o : children.values()) + { + num += numLocks((Node) o); + } + } + return num; + } + + public void testTransactionStorm() throws Exception { + startTest(); + List<WorkThread> threads = new ArrayList<WorkThread>(); +// System.out.println(cache.getNumberOfLocksHeld()); + assert 0 == getNumberOfLocksHeld(); + while (true) { + for (int x = 0; x < 2; x++) { + WorkThread t = new WorkThread(x == 1); + threads.add(t); + t.start(); + } + for (WorkThread separateThread : threads) { + separateThread.join(); + if (separateThread.getException() != null) { + //separateThread.getException().getMessage(); + } + } + int locksNum = getNumberOfLocksHeld(); +// System.out.println("Locks="+locksNum); + // checkpoint + if (((CacheImpl) cache).getNumberOfLocksHeld()>0){ + System.out.println("ERROR, locks="+locksNum); + doDomethingOnCache(1); + } + assert 0 == locksNum; + } + + } + + private class WorkThread extends Thread { + Exception e = null; + + private boolean remove; + + public WorkThread(boolean remove) { + this.remove = remove; + } + + public Exception getException() { + return e; + } + + public void run() { + try { + for (int x = 0; x < 100; x++) { + tm.begin(); + try { + doDomethingOnCache(x); + } finally { + if (x % 3 == 0) { + tm.commit(); + } else { + tm.rollback(); + } + } + } + } catch (Exception e) { +// System.out.println(e.getMessage()); + this.e = e; + } + } + + } + + private void doDomethingOnCache(int x) throws CacheException, InterruptedException { + cache.put(Fqn.fromString("/a/b/c/a"), "text1" + x, ""); + cache.removeNode(Fqn.fromString("/q/b/c/d")); + cache.put(Fqn.fromString("/a/b/c/b"), "text2" + x, ""); + cache.removeNode(Fqn.fromString("/q/b/c/c")); + cache.put(Fqn.fromString("/a/b/c/c"), "text3" + x, ""); + cache.removeNode(Fqn.fromString("/q/b/c/b")); + cache.put(Fqn.fromString("/a/b/c/d"), "text4" + x, ""); + cache.removeNode(Fqn.fromString("/q/b/c/a")); + cache.put(Fqn.fromString("/q/b/c/a"), "text5" + x, ""); + cache.removeNode(Fqn.fromString("/a/b/c/d")); + cache.put(Fqn.fromString("/q/b/c/b"), "text6" + x, ""); + cache.removeNode(Fqn.fromString("/a/b/c/c")); + cache.put(Fqn.fromString("/q/b/c/c"), "text7" + x, ""); + cache.removeNode(Fqn.fromString("/a/b/c/b")); + cache.put(Fqn.fromString("/q/b/c/d"), "text8" + x, ""); + cache.removeNode(Fqn.fromString("/a/b/c/a")); + } + +} Added: core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockUpgradeTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockUpgradeTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/lock/pessimistic/LockUpgradeTest.java 2007-09-14 15:51:46 UTC (rev 4462) @@ -0,0 +1,93 @@ +package org.jboss.cache.lock.pessimistic; + +import java.util.ArrayList; +import java.util.List; + +import javax.transaction.TransactionManager; + +import junit.framework.TestCase; + +import org.jboss.cache.CacheImpl; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.config.Configuration.CacheMode; +import org.jboss.cache.factories.UnitTestCacheConfigurationFactory; +import org.jboss.cache.transaction.DummyTransactionManager; +import org.jboss.cache.transaction.DummyTransactionManagerLookup; +import org.testng.annotations.Test; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.AfterMethod; + +/** + * Test behaviour of concurent put/remove + * + * @author jhalat + */ +@Test(groups = {"functional"}) +public class LockUpgradeTest{ + + private TransactionManager tm; + + private CacheImpl cache; + + @BeforeMethod(alwaysRun = true) + protected void setUp() throws Exception { + Configuration c = new Configuration(); + c.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + cache = (CacheImpl) DefaultCacheFactory.getInstance().createCache(c); + tm = DummyTransactionManager.getInstance(); + } + + @AfterMethod(alwaysRun = true) + protected void tearDown() throws Exception { + cache.stop(); + cache.destroy(); + } + + public void testLock() throws Exception { + List<WorkThread> threads = new ArrayList<WorkThread>(); + for (int x = 0; x < 2; x++) { + WorkThread t = new WorkThread(x == 1); + threads.add(t); + t.start(); + } + for (WorkThread separateThread : threads) { + separateThread.join(); + if (separateThread.getException() != null) { + throw separateThread.getException(); + } + } + } + + private class WorkThread extends Thread { + Exception e = null; + + private boolean remove; + + public WorkThread(boolean remove) { + this.remove = remove; + } + + public Exception getException() { + return e; + } + + public void run() { + try { + for (int x = 0; x < 1000; x++) { + tm.begin(); + if (remove) { + cache.remove("/a/b/c/d"); + cache.remove("/a"); + } else { + cache.put("/a/b/c/d", "key","text" + x); + } + tm.commit(); + Thread.sleep(1); + } + } catch (Exception e) { + this.e = e; + } + } + } +} Added: core/trunk/src/test/java/org/jboss/cache/transaction/AsyncRollbackTxLockTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/transaction/AsyncRollbackTxLockTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/transaction/AsyncRollbackTxLockTest.java 2007-09-14 15:51:46 UTC (rev 4462) @@ -0,0 +1,98 @@ +package org.jboss.cache.transaction; + +import junit.framework.TestCase; + + +import javax.transaction.Synchronization; +import javax.transaction.SystemException; +import javax.transaction.Transaction; +import javax.transaction.TransactionManager; + +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.CacheImpl; +import org.jboss.cache.Fqn; +import org.testng.annotations.Test; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; + +/** + * Test behaviour of async rollback timeouted transaction + * + * @author <a href="mailto:jhalat@infovide.pl">Jacek Halat</a> + */ +@Test(groups = {"functional"}) +public class AsyncRollbackTxLockTest +{ + private Cache cache; + private TransactionManager tm; + + + @BeforeMethod(alwaysRun = true) + public void setUp() throws Exception + { + cache = DefaultCacheFactory.getInstance().createCache(false); + + cache.getConfiguration().setTransactionManagerLookupClass(AsyncRollbackTransactionManagerLookup.class.getName()); + cache.start(); + tm = cache.getConfiguration().getRuntimeConfig().getTransactionManager(); + tm.setTransactionTimeout(2); + } + + @AfterMethod(alwaysRun = true) + public void tearDown() + { + try + { + if (tm != null && tm.getTransaction() != null) + { + try + { + tm.rollback(); + } + catch (SystemException e) + { + // do nothing + } + } + } + catch (SystemException e) + { + // do nothing + } + if (cache != null) cache.stop(); + cache = null; + tm = null; + } + + + public void testTxTimeoutAndRemovePutAfter() throws Exception + { + Thread.currentThread().setName("Thread-0"); + System.out.println("Main Thread:"+Thread.currentThread()); + assert 0 == ((CacheImpl) cache).getNumberOfLocksHeld(); + tm.setTransactionTimeout(1);//short transaction timeout + cache.put(Fqn.fromString("/a/b/c/d"), "k", "v"); + tm.begin(); + Transaction transaction = tm.getTransaction(); + transaction.registerSynchronization(new Synchronization(){ + + public void afterCompletion(int arg0) { + System.out.println("Synchronization Thread:"+Thread.currentThread()); + } + + public void beforeCompletion() { + } + + }); + assert tm.getTransaction() != null; + Thread.sleep(500);//transaction should be rolledback in another thread + cache.put(Fqn.fromString("/a"), "k", "v"); + tm.rollback(); + assert tm.getTransaction() == null; + assert 0 == ((CacheImpl) cache).getNumberOfLocksHeld(); + cache.put(Fqn.fromString("/a"), "k", "v"); + } + +} +