Author: manik.surtani(a)jboss.com Date: 2007-10-19 14:51:12 -0400 (Fri, 19 Oct 2007) New Revision: 4652 Added: core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java Modified: core/trunk/src/main/java/org/jboss/cache/statetransfer/DefaultStateTransferIntegrator.java Log: Updated test for JBCACHE-1202 to also cover cache loaders Modified: core/trunk/src/main/java/org/jboss/cache/statetransfer/DefaultStateTransferIntegrator.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/statetransfer/DefaultStateTransferIntegrator.java 2007-10-19 17:55:03 UTC (rev 4651) +++ core/trunk/src/main/java/org/jboss/cache/statetransfer/DefaultStateTransferIntegrator.java 2007-10-19 18:51:12 UTC (rev 4652) @@ -249,9 +249,12 @@ if (nd != null && !nd.isMarker()) { Map attributes = nd.getAttributes(); - DataVersion version = (DataVersion) attributes.remove(StateTransferManager.DATA_VERSION_KEY); - target.putAllDirect(attributes); - if (version != null) target.setVersion(version); + if (attributes != null) + { + DataVersion version = (DataVersion) attributes.remove(StateTransferManager.DATA_VERSION_KEY); + target.putAllDirect(attributes); + if (version != null) target.setVersion(version); + } // Check whether this is an integration into the buddy backup // subtree Added: core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java 2007-10-19 18:51:12 UTC (rev 4652) @@ -0,0 +1,208 @@ +package org.jboss.cache.optimistic; + +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.Fqn; +import org.jboss.cache.NodeSPI; +import org.jboss.cache.config.CacheLoaderConfig; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.loader.DummySharedInMemoryCacheLoader; +import org.jboss.cache.transaction.DummyTransactionManagerLookup; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +/** + * Tests whether data versions are transferred along with state + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class DataVersionPersistenceTest +{ + private Cache cache; + + @BeforeMethod + public void setUp() + { + + cache = DefaultCacheFactory.getInstance().createCache(false); + cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + cache.getConfiguration().setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC); + + CacheLoaderConfig clc = new CacheLoaderConfig(); + CacheLoaderConfig.IndividualCacheLoaderConfig iclc = new CacheLoaderConfig.IndividualCacheLoaderConfig(); + iclc.setClassName(DummySharedInMemoryCacheLoader.class.getName()); + clc.addIndividualCacheLoaderConfig(iclc); + + cache.getConfiguration().setCacheLoaderConfig(clc); + + cache.start(); + } + + @AfterMethod + public void tearDown() + { + try + { + cache.getConfiguration().getRuntimeConfig().getTransactionManager().rollback(); + } + catch (Exception e) + { + // do nothing? + } + cache.stop(); + } + + public void testStateTransferDefaultVersions() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + cache.put(f, "k", "v"); + cache.put(f, "k1", "v1"); + cache.remove(f, "k1"); + + NodeSPI n = (NodeSPI) cache.getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Should have accurate data version"; + + // now restart cache instance + cache.stop(); + cache.start(); + + assert cache.get(f, "k").equals("v") : "Value should have peristed"; + + n = (NodeSPI) cache.getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Version should have peristed"; + // make sure leakage doesn't occur into data map + assert n.getData().size() == 1; + } + + public void testStateTransferCustomVersion() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + cache.getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('A')); + cache.put(f, "k", "v"); + cache.getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('B')); + cache.put(f, "k1", "v1"); + cache.getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('C')); + cache.remove(f, "k1"); + + NodeSPI n = (NodeSPI) cache.getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Should have accurate data version"; + + // now restart cache instance + cache.stop(); + cache.start(); + + assert cache.get(f, "k").equals("v") : "Value should have peristed"; + + n = (NodeSPI) cache.getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Version should have peristed"; + + // make sure leakage doesn't occur into data map + assert n.getData().size() == 1; + } + + public void testStateTransferDefaultVersionAfterRemoval() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + cache.put(f, "k", "v"); + cache.put(f, "k1", "v1"); + cache.removeNode(f); + + NodeSPI n = (NodeSPI) cache.getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Should have accurate data version"; + + // now restart cache instance + cache.stop(); + cache.start(); + + assert cache.get(f, "k")== null : "Should be removed"; + + n = (NodeSPI) cache.getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Version should have persisted"; + } + + public void testStateTransferCustomVersionAfterRemoval() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + cache.getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('A')); + cache.put(f, "k", "v"); + cache.getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('B')); + cache.put(f, "k1", "v1"); + cache.getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('C')); + cache.removeNode(f); + + NodeSPI n = (NodeSPI) cache.getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Should have accurate data version"; + + // now restart cache instance + cache.stop(); + cache.start(); + + assert cache.get(f, "k")== null : "Should be removed"; + + n = (NodeSPI) cache.getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Version should have persisted"; + } + + public static class CharVersion implements DataVersion + { + private char version = 'A'; + + public CharVersion(char version) + { + this.version = version; + } + + public boolean newerThan(DataVersion other) + { + if (other instanceof CharVersion) + { + CharVersion otherVersion = (CharVersion) other; + return version > otherVersion.version; + } + else + { + return true; + } + } + } + +} Copied: core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java (from rev 4651, core/trunk/src/test/java/org/jboss/cache/statetransfer/DataVersionTransferTest.java) =================================================================== --- core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java 2007-10-19 18:51:12 UTC (rev 4652) @@ -0,0 +1,282 @@ +package org.jboss.cache.optimistic; + +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.Fqn; +import org.jboss.cache.NodeSPI; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.misc.TestingUtil; +import org.jboss.cache.transaction.DummyTransactionManagerLookup; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.ArrayList; +import java.util.List; + +/** + * Tests whether data versions are transferred along with state + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class DataVersionTransferTest +{ + private List<Cache<Object, Object>> caches = new ArrayList<Cache<Object, Object>>(2); + + @BeforeMethod + public void setUp() + { + + caches.add(DefaultCacheFactory.getInstance().createCache(false)); + caches.get(0).getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + caches.get(0).getConfiguration().setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC); + caches.get(0).getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC); + caches.get(0).start(); + + caches.add(DefaultCacheFactory.getInstance().createCache(false)); + caches.get(1).getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + caches.get(1).getConfiguration().setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC); + caches.get(1).getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC); + } + + @AfterMethod + public void tearDown() + { + if (caches != null) + { + for (Cache cache: caches) + { + try + { + cache.getConfiguration().getRuntimeConfig().getTransactionManager().rollback(); + } + catch (Exception e) + { + // do nothing? + } + cache.stop(); + } + } + } + + public void testStateTransferDefaultVersions() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + caches.get(0).put(f, "k", "v"); + caches.get(0).put(f, "k1", "v1"); + caches.get(0).remove(f, "k1"); + + NodeSPI n = (NodeSPI) caches.get(0).getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Should have accurate data version"; + + // now start next cache instance + caches.get(1).start(); + + TestingUtil.blockUntilViewsReceived(10000, caches.get(0), caches.get(1)); + + assert caches.get(1).get(f, "k").equals("v") : "Value should have transferred"; + + n = (NodeSPI) caches.get(1).getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Version should have transferred"; + // make sure leakage doesn't occur into data map + assert n.getData().size() == 1; + } + + public void testStateTransferCustomVersion() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + caches.get(0).getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('A')); + caches.get(0).put(f, "k", "v"); + caches.get(0).getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('B')); + caches.get(0).put(f, "k1", "v1"); + caches.get(0).getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('C')); + caches.get(0).remove(f, "k1"); + + NodeSPI n = (NodeSPI) caches.get(0).getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Should have accurate data version"; + + // now start next cache instance + caches.get(1).start(); + + TestingUtil.blockUntilViewsReceived(10000, caches.get(0), caches.get(1)); + + assert caches.get(1).get(f, "k").equals("v") : "Value should have transferred"; + + n = (NodeSPI) caches.get(1).getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Version should have transferred"; + // make sure leakage doesn't occur into data map + assert n.getData().size() == 1; + } + + public void testStateTransferIntermediateNodeDefaultVersions() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + Fqn intermediate = f.getParent(); + + caches.get(0).put(f, "k", "v"); + caches.get(0).put(intermediate, "k", "v"); + + NodeSPI n = (NodeSPI) caches.get(0).getRoot().getChild(intermediate); + DataVersion dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 1 : "Should have accurate data version"; + + // now start next cache instance + caches.get(1).start(); + + TestingUtil.blockUntilViewsReceived(10000, caches.get(0), caches.get(1)); + + assert caches.get(1).get(intermediate, "k").equals("v") : "Value should have transferred"; + + n = (NodeSPI) caches.get(0).getRoot().getChild(intermediate); + dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 1 : "Should have accurate data version"; + // make sure leakage doesn't occur into data map + assert n.getData().size() == 1; + } + + public void testStateTransferIntermediateNodeCustomVersion() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + Fqn intermediate = f.getParent(); + + caches.get(0).put(f, "k", "v"); + caches.get(0).getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('X')); + caches.get(0).put(intermediate, "k", "v"); + + NodeSPI n = (NodeSPI) caches.get(0).getRoot().getChild(intermediate); + DataVersion dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'X' : "Should have accurate data version"; + + // now start next cache instance + caches.get(1).start(); + + TestingUtil.blockUntilViewsReceived(10000, caches.get(0), caches.get(1)); + + assert caches.get(1).get(intermediate, "k").equals("v") : "Value should have transferred"; + + n = (NodeSPI) caches.get(0).getRoot().getChild(intermediate); + dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'X' : "Should have accurate data version"; + // make sure leakage doesn't occur into data map + assert n.getData().size() == 1; + } + + public void testStateTransferDefaultVersionAfterRemoval() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + caches.get(0).put(f, "k", "v"); + caches.get(0).put(f, "k1", "v1"); + caches.get(0).removeNode(f); + + NodeSPI n = (NodeSPI) caches.get(0).getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Should have accurate data version"; + + // now start next cache instance + caches.get(1).start(); + + TestingUtil.blockUntilViewsReceived(10000, caches.get(0), caches.get(1)); + + assert caches.get(1).get(f, "k")== null : "Should be removed"; + + n = (NodeSPI) caches.get(1).getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof DefaultDataVersion : "Should be an instance of DefaultDataVersion"; + + assert ((DefaultDataVersion) dv).getRawVersion() == 3 : "Version should have transferred"; + } + + public void testStateTransferCustomVersionAfterRemoval() throws Exception + { + Fqn f = Fqn.fromString("/one/two/three"); + caches.get(0).getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('A')); + caches.get(0).put(f, "k", "v"); + caches.get(0).getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('B')); + caches.get(0).put(f, "k1", "v1"); + caches.get(0).getInvocationContext().getOptionOverrides().setDataVersion(new CharVersion('C')); + caches.get(0).removeNode(f); + + NodeSPI n = (NodeSPI) caches.get(0).getRoot().getChild(f); + DataVersion dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Should have accurate data version"; + + // now start next cache instance + caches.get(1).start(); + + TestingUtil.blockUntilViewsReceived(10000, caches.get(0), caches.get(1)); + + assert caches.get(1).get(f, "k")== null : "Should be removed"; + + n = (NodeSPI) caches.get(1).getRoot().getChild(f); + + dv = n.getVersion(); + + assert dv instanceof CharVersion : "Should be an instance of CharVersion"; + + assert ((CharVersion) dv).version == 'C' : "Version should have transferred"; + } + + public static class CharVersion implements DataVersion + { + private char version = 'A'; + + public CharVersion(char version) + { + this.version = version; + } + + public boolean newerThan(DataVersion other) + { + if (other instanceof CharVersion) + { + CharVersion otherVersion = (CharVersion) other; + return version > otherVersion.version; + } + else + { + return true; + } + } + } + +}