[jbosscache-commits] JBoss Cache SVN: r4663 - in core/trunk/src: main/java/org/jboss/cache/eviction and 6 other directories.

Author: manik.surtani(a)jboss.com Date: 2007-10-22 19:08:18 -0400 (Mon, 22 Oct 2007) New Revision: 4663 Added: core/trunk/src/main/java/org/jboss/cache/NodeNotValidException.java core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedOptNodeValidityTest.java core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedPessNodeValidityTest.java core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalOptNodeValidityTest.java core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalPessNodeValidityTest.java core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/NodeValidityTestBase.java core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedOptNodeValidityTest.java core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedPessNodeValidityTest.java core/trunk/src/test/java/org/jboss/cache/invalidation/TombstoneEvictionTest.java Modified: core/trunk/src/main/java/org/jboss/cache/CacheImpl.java core/trunk/src/main/java/org/jboss/cache/CacheSPI.java core/trunk/src/main/java/org/jboss/cache/Node.java core/trunk/src/main/java/org/jboss/cache/NodeSPI.java core/trunk/src/main/java/org/jboss/cache/Region.java core/trunk/src/main/java/org/jboss/cache/RegionImpl.java core/trunk/src/main/java/org/jboss/cache/UnversionedNode.java core/trunk/src/main/java/org/jboss/cache/eviction/BaseEvictionAlgorithm.java core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java core/trunk/src/main/java/org/jboss/cache/interceptors/InvalidationInterceptor.java core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticCreateIfNotExistsInterceptor.java core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticNodeInterceptor.java core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticValidatorInterceptor.java core/trunk/src/test/java/org/jboss/cache/misc/TestingUtil.java core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java Log: JBCACHE-1188 - implemented Node.isValid() and tombstones for invalidations using optimistic locking Modified: core/trunk/src/main/java/org/jboss/cache/CacheImpl.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/CacheImpl.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/CacheImpl.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -1389,13 +1389,13 @@ return n != null; } - /** - * Gets node without attempt to load it from CacheLoader if not present - * - * @param fqn - */ public NodeSPI<K, V> peek(Fqn<?> fqn, boolean includeDeletedNodes) { + return peek(fqn, includeDeletedNodes, false); + } + + public NodeSPI<K, V> peek(Fqn<?> fqn, boolean includeDeletedNodes, boolean includeInvalidNodes) + { if (fqn == null || fqn.size() == 0) return root; NodeSPI<K, V> n = root; int fqnSize = fqn.size(); @@ -1411,6 +1411,10 @@ { return null; } + else if (!includeInvalidNodes && !n.isValid()) + { + return null; + } } return n; } @@ -2401,7 +2405,7 @@ } // Find the node. This will add the temporarily created parent nodes to the TX's node list if tx != null) - n = findNode(fqn, version); + n = findNode(fqn, version, true); if (n == null) { if (log.isTraceEnabled()) @@ -2430,11 +2434,11 @@ if (eviction || configuration.isNodeLockingOptimistic()) { // if there is no parent node and the fqn is root, found == true otherwise found == false. - found = parent_node == null ? fqn.isRoot() : parent_node.removeChildDirect(n.getFqn().getLastElement()); + found = n.isValid() && parent_node == null ? fqn.isRoot() : parent_node.removeChildDirect(n.getFqn().getLastElement()); } else { - found = !n.isDeleted(); + found = n.isValid() && !n.isDeleted(); n.markAsDeleted(true); } @@ -2448,7 +2452,7 @@ // create a compensating method call (reverting the effect of // this modification) and put it into the TX's undo list. - if (tx != null && create_undo_ops && !eviction) + if (tx != null && create_undo_ops && !eviction && found) { undo_op = MethodCallFactory.create(MethodDeclarations.addChildMethodLocal, tx, parent_node.getFqn(), n.getFqn().getLastElement(), n, false); @@ -2661,8 +2665,9 @@ */ public boolean _evict(Fqn fqn) throws CacheException { - if (!exists(fqn)) - return true;// node does not exist. Maybe it has been recursively removed. + if (peek(fqn, false, true) == null) return true; + // node does not exist. Maybe it has been recursively removed. + // use remove method now if there is a child node. Otherwise, it is removed boolean create_undo_ops = false; boolean sendNodeEvent = false; @@ -2724,20 +2729,25 @@ * <p/> * Finally, the data version of the in-memory node is updated to the version being evicted to prevent versions * going out of sync. - * - * @param fqn - * @param versionToInvalidate */ public void invalidate(Fqn fqn, DataVersion versionToInvalidate) { - Node node = get(fqn); // force interceptor chain, load if necessary from cache loader. + Node<K, V> node = get(fqn); // force interceptor chain, load if necessary from cache loader. if (node != null) { - _removeData(null, fqn, false, false, true, versionToInvalidate); + // mark the node to be removed (and all children) as invalid so anyone holding a direct reference to it will + // be aware that it is no longer valid. + ((NodeSPI) node).setValid(false, true); + + if (configuration.isNodeLockingOptimistic()) + _removeData(null, fqn, false, false, true, versionToInvalidate); + else + _evict(fqn); + if (versionToInvalidate != null) { - NodeSPI n = peek(fqn, false); + NodeSPI n = peek(fqn, false, true); n.setVersion(versionToInvalidate); } } @@ -2745,15 +2755,24 @@ { // if pessimistic locking, just return. if (!configuration.isNodeLockingOptimistic()) return; - // create the node we need. - Map<K, V> m = Collections.emptyMap(); - InvocationContext ic = getInvocationContext(); - boolean origCacheModeLocal = ic.getOptionOverrides().isCacheModeLocal(); - ic.getOptionOverrides().setCacheModeLocal(true); - put(fqn, m); - ic.getOptionOverrides().setCacheModeLocal(origCacheModeLocal); - NodeSPI nodeSPI = (NodeSPI) root.getChild(fqn); + + // check if a tombstone already exists + NodeSPI nodeSPI = peek(fqn, false, true); + if (nodeSPI == null) + { + // create the node we need. + Map<K, V> m = Collections.emptyMap(); + InvocationContext ic = getInvocationContext(); + boolean origCacheModeLocal = ic.getOptionOverrides().isCacheModeLocal(); + ic.getOptionOverrides().setCacheModeLocal(true); + put(fqn, m); + ic.getOptionOverrides().setCacheModeLocal(origCacheModeLocal); + nodeSPI = (NodeSPI) root.getChild(fqn); + } nodeSPI.setVersion(versionToInvalidate); + // mark the node to be removed (and all children) as invalid so anyone holding a direct reference to it will + // be aware that it is no longer valid. + nodeSPI.setValid(false, true); } } @@ -2803,6 +2822,11 @@ childNode.markAsDeleted(false, true); + // tricky stuff here - this does look kludgy since we're recursively re-validating nodes + // potentially mistakenly revalidating tombstones, but this method would only be called + // when using pess locking and tombstones don't exist with PL, so this is OK. + childNode.setValid(true, true); + if (gtx != null && undoOps) { // 1. put undo-op in TX' undo-operations list (needed to rollback TX) @@ -4056,6 +4080,10 @@ return false; } + // mark the node to be removed (and all children) as invalid so anyone holding a direct reference to it will + // be aware that it is no longer valid. + n.setValid(false, true); + if (log.isTraceEnabled()) log.trace("Performing a real remove for node " + f + ", marked for removal."); if (skipMarkerCheck || n.isDeleted()) { @@ -4080,15 +4108,20 @@ } /** - * Finds a node given a fully qualified name and DataVersion. + * Finds a node given a fully qualified name and DataVersion. Does not include invalid nodes. */ - private NodeSPI<K, V> findNode(Fqn fqn, DataVersion version) throws CacheException + private NodeSPI<K, V> findNode(Fqn fqn, DataVersion version) { + return findNode(fqn, version, false); + } + + private NodeSPI<K, V> findNode(Fqn fqn, DataVersion version, boolean includeInvalidNodes) + { if (fqn == null) return null; - NodeSPI<K, V> toReturn = peek(fqn, false); + NodeSPI<K, V> toReturn = peek(fqn, false, includeInvalidNodes); - if (version != null && configuration.isNodeLockingOptimistic()) + if (toReturn != null && version != null && configuration.isNodeLockingOptimistic()) { // we need to check the version of the data node... DataVersion nodeVersion = toReturn.getVersion(); Modified: core/trunk/src/main/java/org/jboss/cache/CacheSPI.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/CacheSPI.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/CacheSPI.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -152,7 +152,7 @@ Notifier getNotifier(); /** - * Returns a node without accessing the interceptor chain. + * Returns a node without accessing the interceptor chain. Does not return any nodes marked as invalid. * * @param fqn the Fqn to look up. * @param includeDeletedNodes if you intend to see nodes marked as deleted within the current tx, set this to true @@ -161,6 +161,16 @@ NodeSPI<K, V> peek(Fqn<?> fqn, boolean includeDeletedNodes); /** + * Returns a node without accessing the interceptor chain, optionally returning nodes that are marked as invalid ({@link org.jboss.cache.Node#isValid()} == false). + * + * @param fqn the Fqn to look up. + * @param includeDeletedNodes if you intend to see nodes marked as deleted within the current tx, set this to true + * @param includeInvalidNodes if true, nodes marked as being invalid are also returned. + * @return a node if one exists or null + */ + NodeSPI<K, V> peek(Fqn<?> fqn, boolean includeDeletedNodes, boolean includeInvalidNodes); + + /** * Used with buddy replication's data gravitation interceptor. If marshalling is necessary, ensure that the cache is * configured to use {@link org.jboss.cache.config.Configuration#useRegionBasedMarshalling} and the {@link org.jboss.cache.Region} * pertaining to the Fqn passed in is activated, and has an appropriate ClassLoader. Modified: core/trunk/src/main/java/org/jboss/cache/Node.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/Node.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/Node.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -270,8 +270,9 @@ boolean hasChild(Object o); /** - * Tests if a node reference is still valid. A node reference may become invalid if it has been evicted, for example, - * in which case it should be looked up again from the cache. + * Tests if a node reference is still valid. A node reference may become invalid if it has been removed, invalidated + * or moved, either locally or remotely. If a node is invalid, it should be fetched again from the cache or a valid + * parent node. Operations on invalid nodes will throw a {@link org.jboss.cache.NodeNotValidException}. * * @return true if the node is valid. */ Added: core/trunk/src/main/java/org/jboss/cache/NodeNotValidException.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/NodeNotValidException.java (rev 0) +++ core/trunk/src/main/java/org/jboss/cache/NodeNotValidException.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,30 @@ +package org.jboss.cache; + +/** + * Thrown whenever operations are attempted on a node that is no longer valid. See {@link org.jboss.cache.Node#isValid()} + * for details. + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +public class NodeNotValidException extends CacheException +{ + public NodeNotValidException() + { + } + + public NodeNotValidException(Throwable cause) + { + super(cause); + } + + public NodeNotValidException(String msg) + { + super(msg); + } + + public NodeNotValidException(String msg, Throwable cause) + { + super(msg, cause); + } +} Modified: core/trunk/src/main/java/org/jboss/cache/NodeSPI.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/NodeSPI.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/NodeSPI.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -459,4 +459,13 @@ * @since 2.1.0 */ void setInternalState(Map state); + + /** + * Sets the validity of a node. By default, all nodes are valid unless they are deleted, invalidated or moved, either + * locally or remotely. To be used in conjunction with {@link #isValid()}. + * @param valid if true, the node is marked as valid; if false, the node is invalid. + * @param recursive if true, the validity flag passed in is applied to all children as well. + * @since 2.1.0 + */ + void setValid(boolean valid, boolean recursive); } Modified: core/trunk/src/main/java/org/jboss/cache/Region.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/Region.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/Region.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -6,6 +6,7 @@ */ package org.jboss.cache; +import org.jboss.cache.config.Configuration; import org.jboss.cache.config.EvictionPolicyConfig; import org.jboss.cache.config.EvictionRegionConfig; import org.jboss.cache.eviction.EvictedEventNode; @@ -50,6 +51,12 @@ void registerContextClassLoader(ClassLoader classLoader); /** + * @return the cache-wide configuration + * @since 2.1.0 + */ + Configuration getCacheConfiguration(); + + /** * Unregisters a registered {@link ClassLoader}s for this region. */ void unregisterContextClassLoader(); Modified: core/trunk/src/main/java/org/jboss/cache/RegionImpl.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/RegionImpl.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/RegionImpl.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -8,6 +8,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.jboss.cache.config.Configuration; import org.jboss.cache.config.EvictionPolicyConfig; import org.jboss.cache.config.EvictionRegionConfig; import org.jboss.cache.eviction.EvictedEventNode; @@ -58,6 +59,11 @@ createQueue(); } + public Configuration getCacheConfiguration() + { + return regionManager.getCache().getConfiguration(); + } + public void registerContextClassLoader(ClassLoader classLoader) { this.classLoader = classLoader; Modified: core/trunk/src/main/java/org/jboss/cache/UnversionedNode.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/UnversionedNode.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/UnversionedNode.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -69,6 +69,7 @@ private final Map<K, V> data = new HashMap<K, V>(); private boolean lockForChildInsertRemove; + private boolean valid = true; /** * Constructs a new node with an FQN of Root. @@ -163,6 +164,7 @@ public V get(K key) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.get(getFqn(), key); } @@ -190,6 +192,7 @@ public Map<K, V> getData() { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); if (cache == null) return Collections.emptyMap(); return cache.getData(getFqn()); @@ -211,6 +214,7 @@ public V put(K key, V value) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.put(getFqn(), key, value); } @@ -283,6 +287,7 @@ public V remove(K key) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.remove(getFqn(), key); } @@ -305,6 +310,8 @@ { StringBuffer sb = new StringBuffer(); sb.append(getClass().getSimpleName()); + if (!valid) sb.append(" (INVALID!) "); + if (deleted) { sb.append(" (deleted) [ ").append(fqn); @@ -341,6 +348,7 @@ public Node<K, V> addChild(Fqn f) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); Fqn nf = new Fqn(getFqn(), f); cache.put(nf, null); return getChild(f); @@ -375,6 +383,7 @@ public void clearData() { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); cache.removeData(getFqn()); } @@ -385,6 +394,7 @@ public Node<K, V> getChild(Fqn fqn) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.get(new Fqn(getFqn(), fqn)); } @@ -409,6 +419,7 @@ public Set<Object> getChildrenNames() { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.getChildrenNames(getFqn()); } @@ -419,6 +430,7 @@ public Set<K> getKeys() { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); Set<K> keys = cache.getKeys(getFqn()); return keys == null ? Collections.<K>emptySet() : Collections.<K>unmodifiableSet(keys); } @@ -434,16 +446,19 @@ public boolean hasChild(Fqn f) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return getChild(f) != null; } public boolean hasChild(Object o) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return getChild(o) != null; } public V putIfAbsent(K k, V v) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); // make sure this is atomic. Not hugely performant at the moment (should use the locking interceptors) but for now ... synchronized (this) { @@ -456,6 +471,7 @@ public V replace(K key, V value) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); // make sure this is atomic. Not hugely performant at the moment (should use the locking interceptors) but for now ... synchronized (this) { @@ -470,6 +486,7 @@ public boolean replace(K key, V oldValue, V newValue) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); // make sure this is atomic. Not hugely performant at the moment (should use the locking interceptors) but for now ... synchronized (this) { @@ -485,16 +502,19 @@ public boolean removeChild(Fqn fqn) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.removeNode(new Fqn(getFqn(), fqn)); } public int dataSize() { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.getKeys(getFqn()).size(); } public boolean removeChild(Object childName) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); return cache.removeNode(new Fqn(getFqn(), childName)); } @@ -529,11 +549,13 @@ public void putAll(Map<K, V> data) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); cache.put(fqn, data); } public void replaceAll(Map<K, V> data) { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); cache.put(fqn, data, true); } @@ -648,6 +670,7 @@ public Set<Node<K, V>> getChildren() { + if (!valid) throw new NodeNotValidException("Node " + getFqn() + " is not valid. Perhaps it has been moved or removed."); if (cache == null) return Collections.emptySet(); Set<Node<K, V>> children = new HashSet<Node<K, V>>(); for (Object c : cache.getChildrenNames(getFqn())) @@ -738,10 +761,22 @@ public boolean isValid() { - // TODO; implement this property, to detect if it has been evicted, removed by another thread, etc. Method added for now as a dummy so it exists in the API - return true; + return valid; } + public void setValid(boolean valid, boolean recursive) + { + this.valid = valid; + if (log.isTraceEnabled()) log.trace("Marking node " + getFqn() + " as " + (valid ? "" : "in") + "valid"); + if (recursive) + { + for (Node child: children().values()) + { + ((UnversionedNode) child).setValid(valid, recursive); + } + } + } + public boolean isLockForChildInsertRemove() { return lockForChildInsertRemove; Modified: core/trunk/src/main/java/org/jboss/cache/eviction/BaseEvictionAlgorithm.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/eviction/BaseEvictionAlgorithm.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/eviction/BaseEvictionAlgorithm.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -10,6 +10,7 @@ import org.apache.commons.logging.LogFactory; import org.jboss.cache.Fqn; import org.jboss.cache.Region; +import org.jboss.cache.config.Configuration; import org.jboss.cache.lock.TimeoutException; import java.util.concurrent.BlockingQueue; @@ -44,6 +45,8 @@ */ protected EvictionQueue evictionQueue; + protected boolean allowTombstones = false; + /** * This method will create an EvictionQueue implementation and prepare it for use. * @@ -74,6 +77,10 @@ this.region = region; evictionQueue = setupEvictionQueue(region); log.debug("initialized: " + this); + // hacky temp solution till we have an ioc fwk to inject configuration elements as needed + Configuration.CacheMode cm = region.getCacheConfiguration().getCacheMode(); + allowTombstones = region.getCacheConfiguration().isNodeLockingOptimistic() && + (cm == Configuration.CacheMode.INVALIDATION_ASYNC || cm == Configuration.CacheMode.INVALIDATION_SYNC); } /** @@ -340,7 +347,17 @@ NodeEntry ne = evictionQueue.getNodeEntry(fqn); if (ne != null) { - evictionQueue.removeNodeEntry(ne); + if (allowTombstones) + { + // don't remove from the queue - deleting a node results in a tombstone which means the nodes + // still need to be considered for eviction! + return; + } + else + { + // a removeNode operation will simply remove the node. Nothing to worry about. + evictionQueue.removeNodeEntry(ne); + } } else { Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -5,6 +5,7 @@ import org.jboss.cache.Fqn; import org.jboss.cache.InvocationContext; import org.jboss.cache.NodeSPI; +import static org.jboss.cache.config.Configuration.CacheMode; import org.jboss.cache.loader.CacheLoader; import org.jboss.cache.lock.NodeLock; import org.jboss.cache.marshall.MethodCall; @@ -34,6 +35,7 @@ private TransactionTable txTable = null; protected boolean isActivation = false; protected CacheLoader loader; + protected boolean usingOptimisticInvalidation = false; /** * True if CacheStoreInterceptor is in place. @@ -47,6 +49,9 @@ super.setCache(cache); txTable = cache.getTransactionTable(); this.loader = cache.getCacheLoaderManager().getCacheLoader(); + CacheMode mode = cache.getConfiguration().getCacheMode(); + usingOptimisticInvalidation = cache.getConfiguration().isNodeLockingOptimistic() && + ((mode == CacheMode.INVALIDATION_ASYNC) || (mode == CacheMode.INVALIDATION_SYNC)); } /** @@ -117,6 +122,10 @@ acquireLock = true; break; case MethodDeclarations.getNodeMethodLocal_id: + bypassLoadingData = !usingOptimisticInvalidation; + fqn = (Fqn) args[0]; + acquireLock = true; + break; case MethodDeclarations.getChildrenNamesMethodLocal_id: bypassLoadingData = true; case MethodDeclarations.releaseAllLocksMethodLocal_id: @@ -134,6 +143,12 @@ // clean up nodesCreated map cleanupNodesCreated(entry); break; + case MethodDeclarations.removeNodeMethodLocal_id: + if (cache.getConfiguration().isNodeLockingOptimistic()) + { + fqn = (Fqn) args[1]; + } + break; default: if (!useCacheStore) { @@ -168,7 +183,7 @@ private void loadIfNeeded(InvocationContext ctx, Fqn fqn, Object key, boolean allKeys, boolean initNode, boolean acquireLock, MethodCall m, TransactionEntry entry, boolean recursive, boolean isMove, boolean bypassLoadingData) throws Throwable { - NodeSPI n = cache.peek(fqn, true); + NodeSPI n = cache.peek(fqn, true, true); boolean mustLoad = mustLoad(n, key, allKeys); if (log.isTraceEnabled()) @@ -299,6 +314,15 @@ log.trace("must load, node null"); return true; } + + // check this first!!! + if (!n.isValid() && cache.getConfiguration().isNodeLockingOptimistic()) + { + // attempt to load again; this only happens if we have tombstones lying around, or we are using invalidation. + log.trace("loading again from cache loader since in-memory node is marked as invalid"); + return true; + } + // JBCACHE-1172 Skip single-key optimization if request needs all keys if (!allKeys) { @@ -429,6 +453,9 @@ // n.clearDataDirect(); n.setInternalState(nodeData); + // set this node as valid? + if (usingOptimisticInvalidation) n.setValid(true, false); + cache.getNotifier().notifyNodeLoaded(fqn, false, nodeData, ctx); if (isActivation) { Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -242,9 +242,13 @@ { for (Fqn f : affectedFqns) { - NodeSPI n = cache.peek(f, false); - Map internalState = n.getInternalState(true); - loader.put(f, internalState); + // NOT going to store tombstones!! + NodeSPI n = cache.peek(f, false, false); + if (n != null) + { + Map internalState = n.getInternalState(true); + loader.put(f, internalState); + } } } } Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/InvalidationInterceptor.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/interceptors/InvalidationInterceptor.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/interceptors/InvalidationInterceptor.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -14,9 +14,9 @@ import org.jboss.cache.marshall.MethodCallFactory; import org.jboss.cache.marshall.MethodDeclarations; import org.jboss.cache.optimistic.DataVersion; +import org.jboss.cache.optimistic.DefaultDataVersion; import org.jboss.cache.optimistic.TransactionWorkspace; import org.jboss.cache.optimistic.WorkspaceNode; -import org.jboss.cache.optimistic.DefaultDataVersion; import org.jboss.cache.transaction.GlobalTransaction; import org.jboss.cache.transaction.OptimisticTransactionEntry; import org.jboss.cache.transaction.TransactionEntry; @@ -112,22 +112,24 @@ { case MethodDeclarations.prepareMethod_id: - log.debug("Entering InvalidationInterceptor's prepare phase"); - // fetch the modifications before the transaction is committed (and thus removed from the txTable) - gtx = ctx.getGlobalTransaction(); - entry = txTable.get(gtx); - if (entry == null) throw new IllegalStateException("cannot find transaction entry for " + gtx); - modifications = new LinkedList<MethodCall>(entry.getModifications()); + if (!optimistic) + { + log.debug("Entering InvalidationInterceptor's prepare phase"); + // fetch the modifications before the transaction is committed (and thus removed from the txTable) + gtx = ctx.getGlobalTransaction(); + entry = txTable.get(gtx); + if (entry == null) throw new IllegalStateException("cannot find transaction entry for " + gtx); + modifications = new LinkedList<MethodCall>(entry.getModifications()); - if (modifications.size() > 0) - { - broadcastInvalidate(modifications, gtx, tx, ctx); + if (modifications.size() > 0) + { + broadcastInvalidate(modifications, gtx, tx, ctx); + } + else + { + log.debug("Nothing to invalidate - no modifications in the transaction."); + } } - else - { - log.debug("Nothing to invalidate - no modifications in the transaction."); - } - break; case MethodDeclarations.optimisticPrepareMethod_id: // here we just record the modifications but actually do the invalidate in commit. Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticCreateIfNotExistsInterceptor.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticCreateIfNotExistsInterceptor.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticCreateIfNotExistsInterceptor.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -10,7 +10,6 @@ import org.jboss.cache.CacheSPI; import org.jboss.cache.Fqn; import org.jboss.cache.InvocationContext; -import org.jboss.cache.Node; import org.jboss.cache.NodeFactory; import org.jboss.cache.NodeSPI; import org.jboss.cache.marshall.MethodCall; @@ -77,7 +76,7 @@ fqns.add(newParent); // peek into Node and get a hold of all child fqns as these need to be in the workspace. - NodeSPI node = cache.peek(nodeFqn, true); + NodeSPI node = cache.peek(nodeFqn, true, true); greedyGetFqns(fqns, node, newParent); @@ -222,6 +221,10 @@ log.trace("Child node " + currentNode.getFqn() + " doesn't exist in workspace or has been deleted. Adding to workspace in gtx " + gtx); workspaceNode = nodeFactory.createWorkspaceNode(currentNode, workspace); + + // if the underlying node is a tombstone then mark the workspace node as newly created + if (!currentNode.isValid()) workspaceNode.markAsCreated(); + if (isTargetFqn && !workspace.isVersioningImplicit()) { workspaceNode.setVersion(version); Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticNodeInterceptor.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticNodeInterceptor.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticNodeInterceptor.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -63,12 +63,12 @@ GlobalTransaction gtx = getGlobalTransaction(ctx); TransactionWorkspace workspace = getTransactionWorkspace(gtx); Fqn fqn = getFqn(args, m.getMethodId()); - WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, true); + WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, true, true); // in the case of a data gravitation cleanup, if the primary Fqn does not exist the backup one may. if (workspaceNode == null && m.getMethodId() == MethodDeclarations.dataGravitationCleanupMethod_id) { - workspaceNode = fetchWorkspaceNode(getBackupFqn(args), workspace, true); + workspaceNode = fetchWorkspaceNode(getBackupFqn(args), workspace, true, true); } if (workspaceNode != null) @@ -232,7 +232,7 @@ return; } - WorkspaceNode oldParent = fetchWorkspaceNode(nodeFqn.getParent(), ws, false); + WorkspaceNode oldParent = fetchWorkspaceNode(nodeFqn.getParent(), ws, false, true); if (oldParent == null) throw new NodeNotExistsException("Node " + nodeFqn.getParent() + " does not exist!"); if (parentFqn.equals(oldParent.getFqn())) @@ -241,7 +241,7 @@ return; } // retrieve parent - WorkspaceNode parent = fetchWorkspaceNode(parentFqn, ws, false); + WorkspaceNode parent = fetchWorkspaceNode(parentFqn, ws, false, true); if (parent == null) throw new NodeNotExistsException("Node " + parentFqn + " does not exist!"); Object nodeName = nodeFqn.getLastElement(); @@ -275,13 +275,13 @@ private void recursiveMoveNode(WorkspaceNode node, Fqn newBase, TransactionWorkspace ws) { Fqn newFqn = new Fqn(newBase, node.getFqn().getLastElement()); - WorkspaceNode movedNode = fetchWorkspaceNode(newFqn, ws, true); + WorkspaceNode movedNode = fetchWorkspaceNode(newFqn, ws, true, true); movedNode.putAll(node.getData()); // process children for (Object n : node.getChildrenNames()) { - WorkspaceNode child = fetchWorkspaceNode(new Fqn(node.getFqn(), n), ws, false); + WorkspaceNode child = fetchWorkspaceNode(new Fqn(node.getFqn(), n), ws, false, true); if (child != null) recursiveMoveNode(child, newFqn, ws); } } @@ -323,7 +323,7 @@ if (workspaceNode == null) return false; Fqn parentFqn = workspaceNode.getFqn().getParent(); - WorkspaceNode parentNode = fetchWorkspaceNode(parentFqn, workspace, true); + WorkspaceNode parentNode = fetchWorkspaceNode(parentFqn, workspace, true, true); if (parentNode == null) throw new NodeNotExistsException("Unable to find parent node with fqn " + parentFqn); // pre-notify @@ -390,7 +390,7 @@ { Fqn fqn = (Fqn) args[0]; Object key = args[1]; - WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false); + WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false, false); if (workspaceNode == null) { @@ -412,7 +412,7 @@ { Fqn fqn = (Fqn) args[0]; - WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false); + WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false, false); if (workspaceNode == null) { @@ -437,7 +437,7 @@ { Fqn fqn = (Fqn) args[0]; - WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false); + WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false, false); if (workspaceNode == null) { @@ -458,7 +458,7 @@ { Fqn fqn = (Fqn) args[0]; - WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false); + WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false, false); if (workspaceNode == null) { @@ -479,7 +479,7 @@ { Fqn fqn = (Fqn) args[0]; - WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false); + WorkspaceNode workspaceNode = fetchWorkspaceNode(fqn, workspace, false, false); if (workspaceNode == null) { @@ -513,15 +513,16 @@ * @param fqn Fqn of the node to retrieve * @param workspace transaction workspace to look in * @param undeleteIfNecessary if the node is in the workspace but marked as deleted, this meth + * @param includeInvalidNodes * @return a node, if found, or null if not. */ - private WorkspaceNode fetchWorkspaceNode(Fqn fqn, TransactionWorkspace workspace, boolean undeleteIfNecessary) + private WorkspaceNode fetchWorkspaceNode(Fqn fqn, TransactionWorkspace workspace, boolean undeleteIfNecessary, boolean includeInvalidNodes) { WorkspaceNode workspaceNode = workspace.getNode(fqn); // if we do not have the node then we need to add it to the workspace if (workspaceNode == null) { - NodeSPI node = cache.peek(fqn, true); + NodeSPI node = cache.peek(fqn, true, includeInvalidNodes); if (node == null) return null; // create new workspace node based on the node from the underlying data structure @@ -539,7 +540,7 @@ { workspaceNode.markAsDeleted(false); // re-add to parent - WorkspaceNode parent = fetchWorkspaceNode(fqn.getParent(), workspace, true); + WorkspaceNode parent = fetchWorkspaceNode(fqn.getParent(), workspace, true, includeInvalidNodes); parent.addChild(workspaceNode); } else Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticValidatorInterceptor.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticValidatorInterceptor.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticValidatorInterceptor.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -7,9 +7,11 @@ package org.jboss.cache.interceptors; import org.jboss.cache.CacheException; +import org.jboss.cache.CacheSPI; import org.jboss.cache.Fqn; import org.jboss.cache.InvocationContext; import org.jboss.cache.NodeSPI; +import static org.jboss.cache.config.Configuration.CacheMode; import org.jboss.cache.marshall.MethodCall; import org.jboss.cache.marshall.MethodDeclarations; import org.jboss.cache.optimistic.DataVersioningException; @@ -44,6 +46,15 @@ */ public class OptimisticValidatorInterceptor extends OptimisticInterceptor { + private boolean useTombstones; + + public void setCache(CacheSPI cache) + { + super.setCache(cache); + CacheMode mode = cache.getConfiguration().getCacheMode(); + useTombstones = (mode == CacheMode.INVALIDATION_ASYNC) || (mode == CacheMode.INVALIDATION_SYNC); + } + public Object invoke(InvocationContext ctx) throws Throwable { MethodCall m = ctx.getMethodCall(); @@ -93,7 +104,7 @@ if (trace) log.trace("Validating version for node [" + fqn + "]"); NodeSPI underlyingNode; - underlyingNode = cache.peek(fqn, true); + underlyingNode = cache.peek(fqn, true, true); // if this is a newly created node then we expect the underlying node to be null. // also, if the node has been deleted in the WS and the underlying node is null, this *may* be ok ... will test again later when comparing versions @@ -104,11 +115,22 @@ } // needs to have been created AND modified - we allow concurrent creation if no data is put into the node - if (underlyingNode != null && workspaceNode.isCreated() && workspaceNode.isModified()) + if (underlyingNode != null && underlyingNode.isValid() && workspaceNode.isCreated() && workspaceNode.isModified()) { throw new DataVersioningException("Transaction attempted to create " + fqn + " anew. It has already been created since this transaction started, by another (possibly remote) transaction. We have a concurrent creation event."); } + if (underlyingNode != null && !underlyingNode.isValid()) + { + // we havea tombstone + if (!workspaceNode.isCreated()) throw new DataVersioningException("Underlying node doesn't exist but a tombstone does; workspace node should be marked as created!"); + if (underlyingNode.getVersion().newerThan(workspaceNode.getVersion())) + { + // we have an out of date node here + throw new DataVersioningException("Version mismatch for node " + fqn + ": underlying node with version " + workspaceNode.getNode().getVersion() + " is newer than workspace node, with version " + workspaceNode.getVersion()); + } + } + if (!workspaceNode.isCreated() && (workspaceNode.isDeleted() || workspaceNode.isModified())) { // if the real node is null, throw a DVE @@ -170,13 +192,22 @@ } else { - NodeSPI parent = underlyingNode.getParent(); - if (parent == null) + // mark it as invalid so any direct references are marked as such + underlyingNode.setValid(false, true); + // we need to update versions here, too + performVersionUpdate(underlyingNode, workspaceNode); + + if (!useTombstones) { - throw new CacheException("Underlying node " + underlyingNode + " has no parent"); + // don't retain the tombstone + NodeSPI parent = underlyingNode.getParent(); + if (parent == null) + { + throw new CacheException("Underlying node " + underlyingNode + " has no parent"); + } + + parent.removeChildDirect(underlyingNode.getFqn().getLastElement()); } - - parent.removeChildDirect(underlyingNode.getFqn().getLastElement()); } } else @@ -197,7 +228,14 @@ for (Fqn child : deltas.get(1)) { - underlyingNode.removeChildDirect(child.getLastElement()); + // mark it as invalid so any direct references are marked as such + underlyingNode.getChildDirect(child.getLastElement()).setValid(false, true); + + if (!useTombstones) + { + // don't retain the tombstone + underlyingNode.removeChildDirect(child.getLastElement()); + } } updateVersion = underlyingNode.isLockForChildInsertRemove(); @@ -211,35 +249,36 @@ Map mergedData = workspaceNode.getMergedData(); underlyingNode.clearDataDirect(); underlyingNode.putAllDirect(mergedData); + underlyingNode.setValid(true, false); updateVersion = true; } if (updateVersion) { - if (workspaceNode.isVersioningImplicit()) - { - if (trace) log.trace("Versioning is implicit; incrementing."); - underlyingNode.setVersion(((DefaultDataVersion) workspaceNode.getVersion()).increment()); - } - else - { - if (trace) log.trace("Versioning is explicit; not attempting an increment."); - underlyingNode.setVersion(workspaceNode.getVersion()); - } - - if (trace) - log.trace("Setting version of node " + underlyingNode.getFqn() + " from " + workspaceNode.getVersion() + " to " + underlyingNode.getVersion()); + performVersionUpdate(underlyingNode, workspaceNode); } - else - { - if (trace) - log.trace("Version update on " + workspaceNode.getFqn() + " not necessary since the node is not dirty or LockParentForChildInsertRemove is set to false"); - } } } } + private void performVersionUpdate(NodeSPI underlyingNode, WorkspaceNode workspaceNode) + { + if (workspaceNode.isVersioningImplicit()) + { + if (trace) log.trace("Versioning is implicit; incrementing."); + underlyingNode.setVersion(((DefaultDataVersion) workspaceNode.getVersion()).increment()); + } + else + { + if (trace) log.trace("Versioning is explicit; not attempting an increment."); + underlyingNode.setVersion(workspaceNode.getVersion()); + } + + if (trace) + log.trace("Setting version of node " + underlyingNode.getFqn() + " from " + workspaceNode.getVersion() + " to " + underlyingNode.getVersion()); + } + private void rollBack(GlobalTransaction gtx) { TransactionWorkspace workspace; Added: core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedOptNodeValidityTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedOptNodeValidityTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedOptNodeValidityTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,99 @@ +package org.jboss.cache.api.nodevalidity; + +import org.jboss.cache.CacheImpl; +import org.jboss.cache.NodeSPI; +import org.jboss.cache.optimistic.DefaultDataVersion; +import org.testng.annotations.Test; + +/** + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class InvalidatedOptNodeValidityTest extends InvalidatedPessNodeValidityTest +{ + public InvalidatedOptNodeValidityTest() + { + optimistic = true; + } + + public void testTombstoneRevival() + { + modifier.put(parent, K, V); + modifier.removeNode(parent); + + NodeSPI observerNode = (NodeSPI) observer.getRoot().getChild(parent); + assert observerNode == null : "Should be removed"; + + // now try a put on a with a newer data version; should work + modifier.getInvocationContext().getOptionOverrides().setDataVersion(new DefaultDataVersion(10)); + modifier.put(parent, K, V); + + NodeSPI modifierNode = (NodeSPI) modifier.getRoot().getChild(parent); + assert modifierNode != null : "Should not be null"; + assert modifierNode.isValid() : "No longer a tombstone"; + assert ((DefaultDataVersion) modifierNode.getVersion()).getRawVersion() == 10 : "Version should be updated"; + + observerNode = (NodeSPI) observer.getRoot().getChild(parent); + assert observerNode != null : "Should not be null"; + assert observerNode.isValid() : "No longer a tombstone"; + assert ((DefaultDataVersion) observerNode.getVersion()).getRawVersion() == 10 : "Version should be updated"; + } + + public void testTombstoneVersioningFailure() throws Exception + { + CacheImpl modifierImpl = (CacheImpl) modifier; + CacheImpl observerImpl = (CacheImpl) observer; + + modifier.put(parent, K, V); + + // test that this exists in the (shared) loader + assert loader.get(parent) != null; + assert loader.get(parent).size() > 0; + + modifier.removeNode(parent); + + // assert that tombstones exist on both instances + assert modifierImpl.peek(parent, true, true) != null; + assert observerImpl.peek(parent, true, true) != null; + assert modifierImpl.peek(parent, false, false) == null; + assert observerImpl.peek(parent, false, false) == null; + + // make sure this does not exist in the loader; since it HAS been removed + assert loader.get(parent) == null; + + NodeSPI observerNode = (NodeSPI) observer.getRoot().getChild(parent); + assert observerNode == null : "Should be removed"; + + // now try a put on a with a newer data version; should work + modifier.getInvocationContext().getOptionOverrides().setDataVersion(new DefaultDataVersion(1)); + try + { + modifier.put(parent, K, V); + assert false : "Should have barfed!"; + } + catch (RuntimeException expected) + { + + } + + NodeSPI modifierNode = (NodeSPI) modifier.getRoot().getChild(parent); + assert modifierNode == null : "Should be null"; + + observerNode = (NodeSPI) observer.getRoot().getChild(parent); + assert observerNode == null : "Should be null"; + + NodeSPI modifierTombstone = modifierImpl.peek(parent, true, true); + NodeSPI observerTombstone = observerImpl.peek(parent, true, true); + + assert modifierTombstone != null : "Tombstone should still exist"; + assert observerTombstone != null : "Tombstone should still exist"; + + assert !modifierTombstone.isValid() : "Should not be valid"; + assert !observerTombstone.isValid() : "Should not be valid"; + + assert ((DefaultDataVersion) modifierTombstone.getVersion()).getRawVersion() == 2 : "Should retain versioning"; + assert ((DefaultDataVersion) observerTombstone.getVersion()).getRawVersion() == 2 : "Should retain versioning"; + } +} \ No newline at end of file Added: core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedPessNodeValidityTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedPessNodeValidityTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/InvalidatedPessNodeValidityTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,65 @@ +package org.jboss.cache.api.nodevalidity; + +import org.jboss.cache.Cache; +import org.jboss.cache.CacheFactory; +import org.jboss.cache.CacheImpl; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.config.CacheLoaderConfig; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.loader.DummyInMemoryCacheLoader; +import org.jboss.cache.loader.DummySharedInMemoryCacheLoader; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.Test; + +/** + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class InvalidatedPessNodeValidityTest extends NodeValidityTestBase +{ + protected DummyInMemoryCacheLoader loader; + + public InvalidatedPessNodeValidityTest() + { + invalidation = true; + } + + protected Cache<String, String> createObserver() + { + return newCache(); + } + + protected Cache<String, String> createModifier() + { + return newCache(); + } + + @AfterMethod + public void emptyCacheLoader() + { + if (loader != null) loader.wipe(); + } + + protected Cache<String, String> newCache() + { + CacheFactory<String, String> f = DefaultCacheFactory.getInstance(); + Cache<String, String> cache = f.createCache(false); + cache.getConfiguration().setCacheMode(Configuration.CacheMode.INVALIDATION_SYNC); + optimisticConfiguration(cache.getConfiguration()); + + // need a cache loader as a shared data source between the 2 instances + CacheLoaderConfig.IndividualCacheLoaderConfig iclc = new CacheLoaderConfig.IndividualCacheLoaderConfig(); + iclc.setClassName(DummySharedInMemoryCacheLoader.class.getName()); + CacheLoaderConfig clc = new CacheLoaderConfig(); + clc.addIndividualCacheLoaderConfig(iclc); + cache.getConfiguration().setCacheLoaderConfig(clc); + + cache.start(); + + loader = (DummyInMemoryCacheLoader) ((CacheImpl) cache).getCacheLoader(); + + return cache; + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalOptNodeValidityTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalOptNodeValidityTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalOptNodeValidityTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,17 @@ +package org.jboss.cache.api.nodevalidity; + +import org.testng.annotations.Test; + +/** + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class LocalOptNodeValidityTest extends LocalPessNodeValidityTest +{ + public LocalOptNodeValidityTest() + { + optimistic = true; + } +} \ No newline at end of file Added: core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalPessNodeValidityTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalPessNodeValidityTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/LocalPessNodeValidityTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,50 @@ +package org.jboss.cache.api.nodevalidity; + +import org.jboss.cache.Cache; +import org.jboss.cache.CacheFactory; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.misc.TestingUtil; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.Test; + +/** + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class LocalPessNodeValidityTest extends NodeValidityTestBase +{ + private Cache<String, String> cache; + + public LocalPessNodeValidityTest() + { + clustered = false; + } + + @AfterMethod + public void tearDown() + { + super.tearDown(); + TestingUtil.killCaches(cache); + cache = null; + } + + protected Cache<String, String> createObserver() + { + return createModifier(); + } + + protected Cache<String, String> createModifier() + { + if (cache == null) + { + CacheFactory<String, String> f = DefaultCacheFactory.getInstance(); + cache = f.createCache(false); + optimisticConfiguration(cache.getConfiguration()); + cache.start(); + return cache; + } + return cache; + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/NodeValidityTestBase.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/NodeValidityTestBase.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/NodeValidityTestBase.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,366 @@ +package org.jboss.cache.api.nodevalidity; + +import org.jboss.cache.Cache; +import org.jboss.cache.CacheImpl; +import org.jboss.cache.Fqn; +import org.jboss.cache.Node; +import org.jboss.cache.NodeNotValidException; +import org.jboss.cache.NodeSPI; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.misc.TestingUtil; +import org.jboss.cache.optimistic.DefaultDataVersion; +import org.jboss.cache.transaction.DummyTransactionManagerLookup; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Collections; + +/** + * exercises the isValid() api call on node. + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public abstract class NodeValidityTestBase +{ + protected boolean optimistic; + + // needed to attach a blockUntilViewsReceived in setup + protected boolean clustered = true; + + // needed to test tombstones + protected boolean invalidation = false; + + protected Cache<String, String> observer; + protected Cache<String, String> modifier; + protected Fqn parent = Fqn.fromString("/parent"); + protected Fqn child = Fqn.fromString("/parent/child"); + protected String K="k", V="v"; + + protected abstract Cache<String, String> createObserver(); + protected abstract Cache<String, String> createModifier(); + + protected void optimisticConfiguration(Configuration c) + { + if (optimistic) + { + c.setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC); + c.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + c.setSyncCommitPhase(true); + c.setSyncRollbackPhase(true); + } + } + + @BeforeMethod + public void setUp() + { + observer = createObserver(); + modifier = createModifier(); + if (clustered) TestingUtil.blockUntilViewsReceived(60000, observer, modifier); + } + + @AfterMethod + public void tearDown() + { + TestingUtil.killCaches(observer, modifier); + observer = null; + modifier = null; + } + + public void testRemoval() + { +// observer.getInvocationContext().getOptionOverrides().setCacheModeLocal(true); + observer.put(parent, K, V); + + Node<String, String> obsNode = observer.getRoot().getChild(parent); + + assert obsNode.get(K).equals(V) : "Data should be in the node."; + assert obsNode.isValid() : "Node should be valid"; + + modifier.removeNode(parent); + + assert !obsNode.isValid() : "Should no longer be valid"; + } + + public void testRemovalWithChildren() + { +// observer.getInvocationContext().getOptionOverrides().setCacheModeLocal(true); + observer.put(child, K, V); + + Node<String, String> obsParentNode = observer.getRoot().getChild(parent); + Node<String, String> obsChildNode = observer.getRoot().getChild(child); + + assert obsChildNode.get(K).equals(V) : "Data should be in the node."; + assert obsChildNode.isValid() : "Node should be valid"; + assert obsParentNode.isValid() : "Node should be valid"; + + modifier.removeNode(parent); + + assert !obsParentNode.isValid() : "Should no longer be valid"; + assert !obsChildNode.isValid() : "Should no longer be valid"; + } + + public void testMove() + { + Fqn newParent = Fqn.fromString("/newParent/parent"); + + //observer.getInvocationContext().getOptionOverrides().setCacheModeLocal(true); + observer.put(parent, K, V); + + Node<String, String> obsNode = observer.getRoot().getChild(parent); + + assert obsNode.get(K).equals(V) : "Data should be in the node."; + assert obsNode.isValid() : "Node should be valid"; + + // new parent needs to exist first. + modifier.getRoot().addChild(newParent); + modifier.move(parent, newParent.getParent()); + + // the old node is only marked as invalid if we use opt locking + // with pess locking we directly move the node reference so the old ref is still valid, EVEN if the move happens + // remotely. + if (optimistic) assert !obsNode.isValid() : "Should no longer be valid"; + + assert observer.getRoot().getChild(newParent).isValid() : "Should be valid"; + } + + public void testMoveWithChildren() + { + Fqn newParent = Fqn.fromString("/newParent/parent"); + Fqn newChild = Fqn.fromString("/newParent/parent/child"); + +// observer.getInvocationContext().getOptionOverrides().setCacheModeLocal(true); + observer.put(child, K, V); + + Node<String, String> obsParentNode = observer.getRoot().getChild(parent); + Node<String, String> obsChildNode = observer.getRoot().getChild(child); + + assert obsChildNode.get(K).equals(V) : "Data should be in the node."; + assert obsChildNode.isValid() : "Node should be valid"; + assert obsParentNode.isValid() : "Node should be valid"; + + // new parent needs to exist first. + modifier.getRoot().addChild(newParent); + modifier.move(parent, newParent.getParent()); + + // the old node is only marked as invalid if we use opt locking + // with pess locking we directly move the node reference so the old ref is still valid. + if (optimistic) + { + assert !obsParentNode.isValid() : "Should no longer be valid"; + assert !obsChildNode.isValid() : "Should no longer be valid"; + } + + assert observer.getRoot().getChild(newParent).isValid() : "Should be valid"; + assert observer.getRoot().getChild(newChild).isValid() : "Should be valid"; + } + + public void testEvict() + { + // eviction should NOT affect validity + observer.put(parent, K, V); + Node<String, String> obsNode = observer.getRoot().getChild(parent); + + assert obsNode.get(K).equals(V) : "Data should be in the node."; + assert obsNode.isValid() : "Node should be valid"; + + // eviction needs to happen on the same cache being watched + observer.evict(parent, false); + + assert obsNode.isValid() : "Node should be valid"; + } + + public void testOperationsOnInvalidNode() + { + observer.put(parent, K, V); + Node<String, String> obsNode = observer.getRoot().getChild(parent); + + assert obsNode.get(K).equals(V) : "Data should be in the node."; + assert obsNode.isValid() : "Node should be valid"; + + modifier.removeNode(parent); + + assert !obsNode.isValid() : "Node should not be valid"; + + // all operations on the cached node should throw a NodeNotValidException + + try + { + obsNode.get(K); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.put(K, "v2"); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.remove(K); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.clearData(); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.putAll(Collections.singletonMap(K, "v2")); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.getKeys(); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.hasChild("Something"); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.removeChild("Something"); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.addChild(child); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + + try + { + obsNode.getChildrenNames(); + assert false : "Should fail"; + } + catch (NodeNotValidException good) + { + // do nothing + } + } + + public void testExistenceOfTombstones() + { + CacheImpl modifierImpl = (CacheImpl) modifier; + CacheImpl observerImpl = (CacheImpl) observer; + + modifier.put(parent, K, V); + modifier.removeNode(parent); + + if (optimistic && invalidation) + { + // if we are using optimistic invalidation then we should see tombstones. NOT otherwise. + NodeSPI modifierTombstone = modifierImpl.peek(parent, true, true); + NodeSPI observerTombstone = observerImpl.peek(parent, true, true); + + assert modifierTombstone != null : "Modifier tombstone should not be null"; + assert observerTombstone != null : "Observer tombstone should not be null"; + + assert !modifierTombstone.isValid() : "Should not be valid"; + assert !observerTombstone.isValid() : "Should not be valid"; + + assert ((DefaultDataVersion) modifierTombstone.getVersion()).getRawVersion() == 2 : "Tombstone should be versioned"; + assert ((DefaultDataVersion) observerTombstone.getVersion()).getRawVersion() == 2 : "Tombstone should be versioned"; + + } + else + { + // if we are using pess locking there should be NO tombstones, regardless of replication/invalidation! + assert modifierImpl.peek(parent, true, true) == null : "Tombstone should not exist"; + assert observerImpl.peek(parent, true, true) == null : "Tombstone should not exist"; + } + } + + public void testExistenceOfTombstonesWithChildren() + { + CacheImpl modifierImpl = (CacheImpl) modifier; + CacheImpl observerImpl = (CacheImpl) observer; + + modifier.put(child, K, V); + modifier.removeNode(parent); + + if (optimistic && invalidation) + { + // if we are using optimistic invalidation then we should see tombstones. NOT otherwise. + NodeSPI modifierParentTombstone = modifierImpl.peek(parent, true, true); + NodeSPI observerParentTombstone = observerImpl.peek(parent, true, true); + NodeSPI modifierChildTombstone = modifierImpl.peek(child, true, true); + NodeSPI observerChildTombstone = observerImpl.peek(child, true, true); + + assert modifierParentTombstone != null : "Modifier parent tombstone should not be null"; + assert observerParentTombstone != null : "Observer parent tombstone should not be null"; + assert modifierChildTombstone != null : "Modifier child tombstone should not be null"; + assert observerChildTombstone != null : "Observer child tombstone should not be null"; + + assert !modifierParentTombstone.isValid() : "Should not be valid"; + assert !observerParentTombstone.isValid() : "Should not be valid"; + assert !modifierChildTombstone.isValid() : "Should not be valid"; + assert !observerChildTombstone.isValid() : "Should not be valid"; + + assert ((DefaultDataVersion) modifierParentTombstone.getVersion()).getRawVersion() == 1 : "Tombstone should be versioned"; + assert ((DefaultDataVersion) observerParentTombstone.getVersion()).getRawVersion() == 1 : "Tombstone should be versioned"; + + // note that versions on children cannot be incremented/updated since the remove operation was + // performed on the parent. + assert ((DefaultDataVersion) modifierChildTombstone.getVersion()).getRawVersion() == 1 : "Tombstone should be versioned"; + assert ((DefaultDataVersion) observerChildTombstone.getVersion()).getRawVersion() == 1 : "Tombstone should be versioned"; + + } + else + { + // if we are using pess locking there should be NO tombstones, regardless of replication/invalidation! + assert modifierImpl.peek(parent, true, true) == null : "Tombstone should not exist"; + assert observerImpl.peek(parent, true, true) == null : "Tombstone should not exist"; + assert modifierImpl.peek(child, true, true) == null : "Tombstone should not exist"; + assert observerImpl.peek(child, true, true) == null : "Tombstone should not exist"; + } + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedOptNodeValidityTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedOptNodeValidityTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedOptNodeValidityTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,17 @@ +package org.jboss.cache.api.nodevalidity; + +import org.testng.annotations.Test; + +/** + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class ReplicatedOptNodeValidityTest extends ReplicatedPessNodeValidityTest +{ + public ReplicatedOptNodeValidityTest() + { + optimistic = true; + } +} \ No newline at end of file Added: core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedPessNodeValidityTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedPessNodeValidityTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/nodevalidity/ReplicatedPessNodeValidityTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,36 @@ +package org.jboss.cache.api.nodevalidity; + +import org.jboss.cache.Cache; +import org.jboss.cache.CacheFactory; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.config.Configuration; +import org.testng.annotations.Test; + +/** + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test(groups = {"functional"}) +public class ReplicatedPessNodeValidityTest extends NodeValidityTestBase +{ + protected Cache<String, String> createObserver() + { + return newCache(); + } + + protected Cache<String, String> createModifier() + { + return newCache(); + } + + protected Cache<String, String> newCache() + { + CacheFactory<String, String> f = DefaultCacheFactory.getInstance(); + Cache<String, String> cache = f.createCache(false); + cache.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC); + optimisticConfiguration(cache.getConfiguration()); + cache.start(); + return cache; + } +} Added: core/trunk/src/test/java/org/jboss/cache/invalidation/TombstoneEvictionTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/invalidation/TombstoneEvictionTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/invalidation/TombstoneEvictionTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -0,0 +1,131 @@ +package org.jboss.cache.invalidation; + +import org.jboss.cache.CacheImpl; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.Fqn; +import org.jboss.cache.config.Configuration; +import org.jboss.cache.config.EvictionConfig; +import org.jboss.cache.config.EvictionRegionConfig; +import org.jboss.cache.eviction.FIFOConfiguration; +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.Collections; +import java.util.List; + +/** + * Make sure tombstones are evicted + * + * @author <a href="mailto:manik@jboss.org">Manik Surtani</a> + * @since 2.1.0 + */ +@Test (groups = {"functional"}) +public class TombstoneEvictionTest +{ + private CacheImpl c1, c2; + private Fqn fqn = Fqn.fromString("/data/test"); + private Fqn dummy = Fqn.fromString("/data/dummy"); + private long evictionWaitTime = 2100; + + @BeforeMethod + public void setUp() throws Exception + { + c1 = (CacheImpl) DefaultCacheFactory.getInstance().createCache(false); + c2 = (CacheImpl) DefaultCacheFactory.getInstance().createCache(false); + + // the FIFO policy cfg + FIFOConfiguration cfg = new FIFOConfiguration(); + cfg.setMaxNodes(1); + cfg.setMinTimeToLiveSeconds(0); + + // the region configuration + EvictionRegionConfig regionCfg = new EvictionRegionConfig(); + regionCfg.setRegionFqn(dummy.getParent()); + regionCfg.setRegionName(dummy.getParent().toString()); + regionCfg.setEvictionPolicyConfig(cfg); + + // set regions in a list + List<EvictionRegionConfig> evictionRegionConfigs = Collections.singletonList(regionCfg); + + + EvictionConfig ec = new EvictionConfig(); + ec.setWakeupIntervalSeconds(1); + ec.setEvictionRegionConfigs(evictionRegionConfigs); + + c1.getConfiguration().setCacheMode(Configuration.CacheMode.INVALIDATION_SYNC); + c1.getConfiguration().setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC); + c1.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + c1.getConfiguration().setEvictionConfig(ec); + + c2.setConfiguration(c1.getConfiguration().clone()); + + c1.start(); + c2.start(); + + TestingUtil.blockUntilViewsReceived(60000, c1, c2); + } + + @AfterMethod + public void tearDown() + { + TestingUtil.killCaches(c1, c2); + } + + public void testControl() + { + c1.put(fqn, "k", "v"); + c1.put(dummy, "k", "v"); + + assert c1.peek(fqn, false, true) != null : "Node should exist"; + assert c1.peek(dummy, false, true) != null : "Node should exist"; + + TestingUtil.sleepThread(evictionWaitTime); + + assert c1.peek(fqn, false, true) == null : "Should have evicted"; + assert c1.peek(dummy, false, true) != null : "Node should exist"; + } + + public void testWithInvalidationMarkers() + { + c1.put(fqn, "k", "v"); + c1.put(dummy, "k", "v"); + + assert c1.peek(fqn, false, true) != null : "Node should exist"; + assert c1.peek(dummy, false, true) != null : "Node should exist"; + + assert c2.peek(fqn, false, true) != null : "Node should exist"; + assert c2.peek(dummy, false, true) != null : "Node should exist"; + + TestingUtil.sleepThread(evictionWaitTime); + + assert c1.peek(fqn, false, true) == null : "Should have evicted"; + assert c1.peek(dummy, false, true) != null : "Node should exist"; + + assert c2.peek(fqn, false, true) == null : "Should have evicted"; + assert c2.peek(dummy, false, true) != null : "Node should exist"; + } + + public void testWithTombstones() + { + c1.put(fqn, "k", "v"); + c1.removeNode(fqn); + c1.put(dummy, "k", "v"); + + assert c1.peek(fqn, false, true) != null : "Node should exist"; + assert c1.peek(dummy, false, true) != null : "Node should exist"; + + assert c2.peek(fqn, false, true) != null : "Node should exist"; + assert c2.peek(dummy, false, true) != null : "Node should exist"; + + TestingUtil.sleepThread(evictionWaitTime); + + assert c1.peek(fqn, false, true) == null : "Should have evicted"; + assert c1.peek(dummy, false, true) != null : "Node should exist"; + + assert c2.peek(fqn, false, true) == null : "Should have evicted"; + assert c2.peek(dummy, false, true) != null : "Node should exist"; + } +} Modified: core/trunk/src/test/java/org/jboss/cache/misc/TestingUtil.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/misc/TestingUtil.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/test/java/org/jboss/cache/misc/TestingUtil.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -7,16 +7,18 @@ package org.jboss.cache.misc; -import java.io.File; -import java.util.List; -import java.util.Random; - import org.jboss.cache.Cache; import org.jboss.cache.CacheImpl; import org.jboss.cache.CacheSPI; +import org.jboss.cache.CacheStatus; +import org.jboss.cache.Fqn; import org.jboss.cache.interceptors.Interceptor; import org.jboss.cache.util.CachePrinter; +import java.io.File; +import java.util.List; +import java.util.Random; + /** * Utilities for unit testing JBossCache. * @@ -374,4 +376,43 @@ //System.out.println("File " + f.toURI() + " deleted = " + f.delete()); f.delete(); } + + /** + * Kills a cache - stops it, clears any data in any cache loaders, and rolls back any associated txs + */ + public static void killCaches(Cache... caches) + { + for (Cache c: caches) + { + if (c != null && c.getCacheStatus() == CacheStatus.STARTED) + { + CacheImpl ci = (CacheImpl) c; + if (ci.getTransactionManager() != null) + { + try + { + ci.getTransactionManager().rollback(); + } + catch (Exception e) + { + // don't care + } + } + + if (ci.getCacheLoader() != null) + { + try + { + ci.getCacheLoader().remove(Fqn.ROOT); + } + catch (Exception e) + { + // don't care + } + } + + ci.destroy(); + } + } + } } Modified: core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionPersistenceTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -135,67 +135,6 @@ 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'; Modified: core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java 2007-10-22 19:13:05 UTC (rev 4662) +++ core/trunk/src/test/java/org/jboss/cache/optimistic/DataVersionTransferTest.java 2007-10-22 23:08:18 UTC (rev 4663) @@ -193,69 +193,6 @@ 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';