[jbosscache-commits] JBoss Cache SVN: r5479 - core/trunk/src/test/java/org/jboss/cache/marshall.

[jbosscache-commits at lists.jboss.org]

Author: manik.surtani at jboss.com
Date: 2008-03-31 13:53:52 -0400 (Mon, 31 Mar 2008)
New Revision: 5479

Added:
   core/trunk/src/test/java/org/jboss/cache/marshall/InvalidRegionForStateTransferTest.java
Log:
JBCACHE-1170 - added test

Added: core/trunk/src/test/java/org/jboss/cache/marshall/InvalidRegionForStateTransferTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/marshall/InvalidRegionForStateTransferTest.java	                        (rev 0)
+++ core/trunk/src/test/java/org/jboss/cache/marshall/InvalidRegionForStateTransferTest.java	2008-03-31 17:53:52 UTC (rev 5479)
@@ -0,0 +1,90 @@
+package org.jboss.cache.marshall;
+
+import org.jboss.cache.Cache;
+import org.jboss.cache.DefaultCacheFactory;
+import org.jboss.cache.Fqn;
+import org.jboss.cache.Region;
+import org.jboss.cache.config.Configuration;
+import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
+import org.jboss.cache.misc.TestingUtil;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+/**
+ * This test ensures the CacheMarshaller doesn't use stale regions when attempting to unmarshall state transfers.  Seen intermittently
+ * when async replication is used, since JGroups doesn't attempt to marshall a return value, thereby leaving a stale region in thread local
+ * in the cache marshaller, which then gets reused when the thread is reused to provide state.
+ * <p/>
+ * Need to ensure that the same thread is used to process incoming requests as well as state transfers, hence limiting the JGroups
+ * thread pool size to 1.
+ * <p/>
+ *
+ * @author Manik Surtani (<a href="mailto:manik at jboss.org">manik at jboss.org</a>)
+ * @since 2.1.0
+ */
+ at Test(groups = "functional")
+public class InvalidRegionForStateTransferTest
+{
+   Cache<Object, Object> c1, c2;
+
+   @BeforeMethod
+   public void setUp() throws CloneNotSupportedException
+   {
+      c1 = new DefaultCacheFactory<Object, Object>().createCache(UnitTestCacheConfigurationFactory.createConfiguration(Configuration.CacheMode.REPL_ASYNC), false);
+
+      String jgroupsCfg = c1.getConfiguration().getClusterConfig();
+
+      // make sure we use STATE_TRANSFER and not STREAMING_STATE_TRANSFER, so the same thread pool is used for incoming calls and ST
+      jgroupsCfg = jgroupsCfg.replace("STREAMING_STATE_TRANSFER", "STATE_TRANSFER");
+      // also make sure we use a thread pool size of 1
+      jgroupsCfg = jgroupsCfg.replaceFirst("thread_pool.max_threads=[0-9]*;", "thread_pool.max_threads=1;");
+
+      System.out.println(">>>> " + jgroupsCfg);
+      c1.getConfiguration().setClusterConfig(jgroupsCfg);
+
+      c1.getConfiguration().setUseRegionBasedMarshalling(true);
+      c1.start();
+
+      c2 = new DefaultCacheFactory<Object, Object>().createCache(c1.getConfiguration().clone());
+
+      TestingUtil.blockUntilViewsReceived(60000, c1, c2);
+   }
+
+   @AfterMethod
+   public void tearDown()
+   {
+      TestingUtil.killCaches(c1, c2);
+   }
+
+   public void testUseOfInvalidRegion()
+   {
+      Fqn fqn = Fqn.fromString("/a/b/c/d");
+      c1.getRegion(fqn.getParent(), true).registerContextClassLoader(getClass().getClassLoader());
+      c2.getRegion(fqn.getParent(), true).registerContextClassLoader(getClass().getClassLoader());
+
+      // write something; will cause a stale region to be stored in C2's cache marshaller
+      c1.put(fqn, "k", "v");
+      assert c1.get(fqn, "k").equals("v");
+
+      TestingUtil.sleepThread(250); // async repl
+
+      // assert that this made it to c2
+      assert c2.get(fqn, "k").equals("v");
+
+      // c2's cache marshaller's thread local would be polluted now.
+
+      // restart c1 so that it forces a state transfer from c2
+      c1.destroy();
+      c1.create();
+      Region r = c1.getRegion(fqn.getParent(), true);
+      r.registerContextClassLoader(getClass().getClassLoader());
+      r.deactivate();
+      c1.start();
+
+      TestingUtil.blockUntilViewsReceived(60000, c1, c2);
+
+      // assert that the state has been transferred to C1
+      assert c1.get(fqn, "k").equals("v");
+   }
+}