7:53 p.m.
Author: manik.surtani(a)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@jboss.org">manik@jboss.org</a>)
+ * @since 2.1.0
+ */
+@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");
+ }
+}