JBoss Cache SVN: r7091 - in core/branches/flat/src/main/java/org/jboss/starobrno: delta and 1 other directory.
by jbosscache-commits＠lists.jboss.org
Author: manik.surtani(a)jboss.com
Date: 2008-11-06 14:32:17 -0500 (Thu, 06 Nov 2008)
New Revision: 7091
Added:
core/branches/flat/src/main/java/org/jboss/starobrno/delta/
core/branches/flat/src/main/java/org/jboss/starobrno/delta/Delta.java
core/branches/flat/src/main/java/org/jboss/starobrno/delta/DeltaHashMap.java
Log:
delta interface
Added: core/branches/flat/src/main/java/org/jboss/starobrno/delta/Delta.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/delta/Delta.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/delta/Delta.java 2008-11-06 19:32:17 UTC (rev 7091)
@@ -0,0 +1,97 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.delta;
+
+import java.io.Externalizable;
+
+/**
+ * This interface allows for implementations to be palced as values in the cache, and report what has changed. This
+ * allows for finer grained replication messages.
+ * <p/>
+ * Basically, the first time a <tt>Delta</tt> object is placed in the cache, it is cached in its entirity. When a
+ * <tt>Delta</tt> is removed, similarly, it is removed in its entirity.
+ * <p/>
+ * Special behavior is seen when a <tt>Delta</tt> object is changed and replicated though. For example, consider the
+ * following code:
+ * <code>
+ * Person p = cache.get("personName");
+ * p.setAge(p.getAge() + 1);
+ * cache.put("personName", p);
+ * </code>
+ * <p/>
+ * where <tt>Person</tt> implements Delta.
+ * <p/>
+ * Normally, the put() call would involve serializing and replicating the entire <tt>Person</tt> instance, but since
+ * <tt>Person</tt> implements <tt>Delta</tt>, instead the marshaller will only expect the changes to be marshalled (when
+ * calling the {@link Externalizable} interfaces. As such, implementations could safely only marshall modified fields when
+ * {@link Externalizable#writeExternal(java.io.ObjectOutput)} is called, thereby reducing the time taken serializing
+ * and replicating changes.
+ * <p/>
+ * On the receiving end, changes are applied as such. In a {@link org.jboss.starobrno.commands.write.PutKeyValueCommand},
+ * if the value being put is a <tt>Delta</tt> and there is already a <tt>Delta</tt> under the same key, a merge operation
+ * is called by invoking {@link Delta#merge(Delta)} on the <i>replicated</i> <tt>Delta</tt> value and passing in the
+ * <i>original</i> <tt>Delta</tt> instance. It would then be up to the implementation to efficiently and correctly merge
+ * in state, and return a coherent and complete <tt>Delta</tt> instance that could be placed in the cache.
+ * <p/>
+ * If the command does not find anything under the key - or emor importantly, finds an object that does not implement
+ * <tt>Delta</tt> - it would pass a null into the {@link #merge(Delta)} method.
+ * <p/>
+ * It is important to note that {@link #merge(Delta)} is <b>only</b> called on remote nodes, after replication when
+ * merging state. This is never used on the local cache instance.
+ * <p/>
+ * In addition to {@link #merge(Delta)}, other important methods on this interface are {@link #rollback()}. If running
+ * within a JTA transaction scope, and a rollback occurs, no replication takes place so nothing needs to happen on
+ * remote instances. However, on your local cache instance, you may have changed internal state of a reference
+ * which already exists in the cache, such as in the above example. To correctly deal with JTA transaction rollbacks,
+ * all {@link #rollback()} methods on <tt>Delta</tt> instances involved in a transaction will be called and it is
+ * up to the implementation to reset internal state. There is a corresponding {@link #commit()} method where changes
+ * should be considered as accepted, are flushed and rollback information can be cleared.
+ * <p/>
+ * For an example of a <tt>Delta</tt> implementation, and for typical use cases, please refer to {@link org.jboss.starobrno.delta.DeltaHashMap}.
+ *
+ * @author Manik Surtani (<a href="mailto:manik AT jboss DOT org">manik AT jboss DOT org</a>)
+ * @see org.jboss.starobrno.delta.DeltaHashMap
+ */
+public interface Delta extends Externalizable
+{
+ /**
+ * Invoked if a transaction involving modifying state on this instance has rolled back, and state needs to be reverted.
+ */
+ void rollback();
+
+ /**
+ * Invoked if a transaction involving modifying state on this instance completes successfully, and any recorded
+ * rollback information can safely be discarded.
+ */
+ void commit();
+
+ /**
+ * Merges changes. Important to note that this method is always called on remote nodes, after replication, and is
+ * called on the de-serialized instance read off the wire. What is passed in is an extisting <tt>Delta</tt> instance
+ * to merge with, or a null. This method should return a fully coherent <tt>Delta</tt> instance than can be placed
+ * in the cache
+ *
+ * @param toMergeInto
+ * @return a fully coherent <tt>Delta</tt> instance
+ */
+ Delta merge(Delta toMergeInto);
+}
Added: core/branches/flat/src/main/java/org/jboss/starobrno/delta/DeltaHashMap.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/delta/DeltaHashMap.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/delta/DeltaHashMap.java 2008-11-06 19:32:17 UTC (rev 7091)
@@ -0,0 +1,301 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.delta;
+
+import org.jboss.starobrno.util.FastCopyHashMap;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Set;
+
+public class DeltaHashMap<K, V> implements Delta, Map<K, V>
+{
+ FastCopyHashMap<K, V> delegate;
+ List<Operation> changelog = new LinkedList<Operation>();
+
+ /**
+ * Constructs an empty <tt>HashMap</tt> with the specified initial
+ * capacity and load factor.
+ *
+ * @param initialCapacity The initial capacity.
+ * @param loadFactor The load factor.
+ * @throws IllegalArgumentException if the initial capacity is negative
+ * or the load factor is nonpositive.
+ */
+ public DeltaHashMap(int initialCapacity, float loadFactor)
+ {
+ delegate = new FastCopyHashMap(initialCapacity, loadFactor);
+ }
+
+ /**
+ * Constructs an empty <tt>HashMap</tt> with the specified initial
+ * capacity and the default load factor (0.75).
+ *
+ * @param initialCapacity the initial capacity.
+ * @throws IllegalArgumentException if the initial capacity is negative.
+ */
+ public DeltaHashMap(int initialCapacity)
+ {
+ delegate = new FastCopyHashMap<K, V>(initialCapacity);
+ }
+
+ /**
+ * Constructs an empty <tt>HashMap</tt> with the default initial capacity
+ * (16) and the default load factor (0.75).
+ */
+ public DeltaHashMap()
+ {
+ delegate = new FastCopyHashMap<K, V>();
+ }
+
+ /**
+ * Constructs a new <tt>HashMap</tt> with the same mappings as the
+ * specified <tt>Map</tt>. The <tt>HashMap</tt> is created with
+ * default load factor (0.75) and an initial capacity sufficient to
+ * hold the mappings in the specified <tt>Map</tt>.
+ *
+ * @param m the map whose mappings are to be placed in this map.
+ * @throws NullPointerException if the specified map is null.
+ */
+ public DeltaHashMap(Map<? extends K, ? extends V> m)
+ {
+ delegate = new FastCopyHashMap<K, V>(m);
+ }
+
+
+ public void rollback()
+ {
+ // replay reversal operations on the changelog, in reverse order
+ ListIterator<Operation> li = changelog.listIterator(changelog.size());
+ while (li.hasPrevious()) li.previous().rollback(delegate);
+ }
+
+ public void commit()
+ {
+ changelog.clear();
+ }
+
+ public Delta merge(Delta toMergeInto)
+ {
+ if (toMergeInto != null)
+ {
+ if (toMergeInto instanceof DeltaHashMap)
+ {
+ DeltaHashMap other = (DeltaHashMap) toMergeInto;
+ for (Operation o : changelog) o.replay(other.delegate);
+ commit();
+ other.commit();
+ return toMergeInto;
+ }
+ else
+ {
+ throw new IllegalArgumentException("This instance of " + getClass().getSimpleName() + " can only merge with other instances of the same type. Don't know how to deal with " + toMergeInto.getClass());
+ }
+ }
+ else
+ {
+ // use the current instance, since there is nothing to merge into.
+ for (Operation o : changelog) o.replay(delegate);
+ commit();
+ return this;
+ }
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException
+ {
+ out.writeObject(changelog);
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
+ {
+ changelog = (List<Operation>) in.readObject();
+ }
+
+ public int size()
+ {
+ return delegate.size();
+ }
+
+ public boolean isEmpty()
+ {
+ return delegate.isEmpty();
+ }
+
+ public boolean containsKey(Object key)
+ {
+ return delegate.containsKey(key);
+ }
+
+ public boolean containsValue(Object value)
+ {
+ return delegate.containsValue(value);
+ }
+
+ public V get(Object key)
+ {
+ return delegate.get(key);
+ }
+
+ public V put(K key, V value)
+ {
+ PutOperation<K, V> op = new PutOperation<K, V>();
+ op.key = key;
+ op.newValue = value;
+ op.oldValue = delegate.put(key, value);
+ changelog.add(op);
+ return op.oldValue;
+ }
+
+ public V remove(Object key)
+ {
+ RemoveOperation<K, V> op = new RemoveOperation<K, V>();
+ op.key = (K) key;
+ op.oldValue = delegate.remove(key);
+ changelog.add(op);
+ return op.oldValue;
+ }
+
+ public void putAll(Map<? extends K, ? extends V> t)
+ {
+ // this is crappy - need to do this more efficiently!
+ for (Entry<? extends K, ? extends V> e : t.entrySet()) put(e.getKey(), e.getValue());
+ }
+
+ public void clear()
+ {
+ ClearOperation<K, V> op = new ClearOperation<K, V>();
+ op.originalEntries = (FastCopyHashMap<K, V>) delegate.clone();
+ changelog.add(op);
+ delegate.clear();
+ }
+
+ public Set<K> keySet()
+ {
+ return delegate.keySet();
+ }
+
+ public Collection<V> values()
+ {
+ return delegate.values();
+ }
+
+ public Set<Entry<K, V>> entrySet()
+ {
+ return delegate.entrySet();
+ }
+
+ private static abstract class Operation<K, V> implements Externalizable
+ {
+ abstract void rollback(Map<K, V> delegate);
+
+ abstract void replay(Map<K, V> delegate);
+
+ public void writeExternal(ObjectOutput out) throws IOException
+ {
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
+ {
+ }
+ }
+
+ private static class PutOperation<K, V> extends Operation<K, V>
+ {
+ K key;
+ V oldValue;
+ V newValue;
+
+ void rollback(Map<K, V> delegate)
+ {
+ if (oldValue == null)
+ delegate.remove(key);
+ else
+ delegate.put(key, oldValue);
+ }
+
+ void replay(Map<K, V> delegate)
+ {
+ delegate.put(key, newValue);
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException
+ {
+ // don't bother writing out the old value since it will never be rolled back
+ out.writeObject(key);
+ out.writeObject(newValue);
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
+ {
+ key = (K) in.readObject();
+ newValue = (V) in.readObject();
+ }
+ }
+
+ private static class RemoveOperation<K, V> extends Operation<K, V>
+ {
+ K key;
+ V oldValue;
+
+ void rollback(Map<K, V> delegate)
+ {
+ if (oldValue != null) delegate.put(key, oldValue);
+ }
+
+ void replay(Map<K, V> delegate)
+ {
+ delegate.remove(key);
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException
+ {
+ out.writeObject(key);
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
+ {
+ key = (K) in.readObject();
+ }
+ }
+
+ private static class ClearOperation<K, V> extends Operation<K, V>
+ {
+ FastCopyHashMap<K, V> originalEntries;
+
+ void rollback(Map<K, V> delegate)
+ {
+ if (!originalEntries.isEmpty()) delegate.putAll(originalEntries);
+ }
+
+ void replay(Map<K, V> delegate)
+ {
+ delegate.clear();
+ }
+ }
+}
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7090 - in core/branches/flat/src: test/java/org/jboss/starobrno and 1 other directories.
by jbosscache-commits＠lists.jboss.org
Author: mircea.markus
Date: 2008-11-06 09:05:12 -0500 (Thu, 06 Nov 2008)
New Revision: 7090
Added:
core/branches/flat/src/test/java/org/jboss/starobrno/eviction/
core/branches/flat/src/test/java/org/jboss/starobrno/eviction/EvictionWatcher.java
core/branches/flat/src/test/java/org/jboss/starobrno/eviction/FIFOPolicyTest.java
Modified:
core/branches/flat/src/main/java/org/jboss/starobrno/commands/write/EvictCommand.java
Log:
ongoing eviction work
Modified: core/branches/flat/src/main/java/org/jboss/starobrno/commands/write/EvictCommand.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/commands/write/EvictCommand.java 2008-11-06 00:31:36 UTC (rev 7089)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/commands/write/EvictCommand.java 2008-11-06 14:05:12 UTC (rev 7090)
@@ -59,12 +59,12 @@
MVCCEntry e = ctx.lookupEntry(key);
if (e != null && !e.isNullEntry())
{
+ //todo - add a actual eviction from thr container
notifier.notifyCacheEntryEvicted(key, true, ctx);
e.setDeleted(true);
e.setValid(false);
notifier.notifyCacheEntryEvicted(key, false, ctx);
}
-
return null;
}
Added: core/branches/flat/src/test/java/org/jboss/starobrno/eviction/EvictionWatcher.java
===================================================================
--- core/branches/flat/src/test/java/org/jboss/starobrno/eviction/EvictionWatcher.java (rev 0)
+++ core/branches/flat/src/test/java/org/jboss/starobrno/eviction/EvictionWatcher.java 2008-11-06 14:05:12 UTC (rev 7090)
@@ -0,0 +1,56 @@
+package org.jboss.starobrno.eviction;
+
+import org.jboss.cache.Fqn;
+import org.jboss.starobrno.Cache;
+import org.jboss.starobrno.notifications.annotation.CacheListener;
+import org.jboss.starobrno.notifications.annotation.CacheEntryEvicted;
+import org.jboss.starobrno.notifications.event.CacheEntryEvictedEvent;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Watches and waits for eviction events
+ *
+ * @author Manik Surtani (<a href="mailto:manik AT jboss DOT org">manik AT jboss DOT org</a>)
+ * @since 3.0
+ */
+@CacheListener
+public class EvictionWatcher
+{
+ Cache<?, ?> cache;
+ List<Object> keysToWaitFor;
+
+ public EvictionWatcher(Cache<?, ?> cache, Fqn... keysToWaitFor)
+ {
+// this(cache, Arrays.asList(keysToWaitFor));
+ }
+
+ public EvictionWatcher(Cache<?, ?> cache, List<Object> keysToWaitFor)
+ {
+ this.cache = cache;
+ this.keysToWaitFor = new ArrayList<Object>(keysToWaitFor);
+ cache.addCacheListener(this);
+ }
+
+ @CacheEntryEvicted
+ public void receive(CacheEntryEvictedEvent ee)
+ {
+ boolean xpect = false;
+ if (ee.isPre() && keysToWaitFor.contains(ee.getKey()))
+ {
+ xpect = true;
+ keysToWaitFor.remove(ee.getKey());
+ }
+
+ if (ee.isPre()) System.out.println("Saw " + ee.getKey() + " was expecting? " + xpect);
+ }
+
+ public boolean allNodesEvicted()
+ {
+ return keysToWaitFor.isEmpty();
+ }
+}
\ No newline at end of file
Added: core/branches/flat/src/test/java/org/jboss/starobrno/eviction/FIFOPolicyTest.java
===================================================================
--- core/branches/flat/src/test/java/org/jboss/starobrno/eviction/FIFOPolicyTest.java (rev 0)
+++ core/branches/flat/src/test/java/org/jboss/starobrno/eviction/FIFOPolicyTest.java 2008-11-06 14:05:12 UTC (rev 7090)
@@ -0,0 +1,152 @@
+package org.jboss.starobrno.eviction;
+
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.Test;
+import static org.testng.AssertJUnit.fail;
+import static org.testng.AssertJUnit.assertNull;
+import static org.testng.AssertJUnit.assertNotNull;
+import static org.testng.AssertJUnit.assertEquals;
+import org.jboss.cache.Fqn;
+import org.jboss.cache.lock.IsolationLevel;
+import org.jboss.cache.transaction.DummyTransactionManagerLookup;
+import org.jboss.starobrno.CacheSPI;
+import org.jboss.starobrno.UnitTestCacheFactory;
+import org.jboss.starobrno.util.TestingUtil;
+import org.jboss.starobrno.eviction.algorithms.fifo.FIFOAlgorithmConfig;
+import org.jboss.starobrno.config.EvictionConfig;
+import org.jboss.starobrno.config.Configuration;
+import org.jboss.starobrno.config.EvictionCacheConfig;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author Mircea.Markus(a)jboss.com
+ */
+@Test(groups = "functional")
+public class FIFOPolicyTest
+{
+ CacheSPI<Object, Object> cache;
+ final String CACHE_NAME = "test";
+ Throwable t1_ex, t2_ex;
+ volatile boolean isTrue;
+ int maxNodes = 5;
+
+ @BeforeMethod(alwaysRun = true)
+ public void setUp() throws Exception
+ {
+ initCaches();
+ t1_ex = t2_ex = null;
+ isTrue = true;
+ }
+
+ private void log(String s)
+ {
+ System.out.println("---log :" + s);
+ }
+
+ void initCaches() throws Exception
+ {
+
+ Configuration config = new Configuration();
+ EvictionConfig evConfig = new EvictionConfig();
+ evConfig.setWakeupInterval(-1);//external thread
+ config.setEvictionConfig(evConfig);
+ config.setCacheMode(Configuration.CacheMode.LOCAL);
+ FIFOAlgorithmConfig algorithmConfig = new FIFOAlgorithmConfig(maxNodes);
+ EvictionCacheConfig ecc = new EvictionCacheConfig(2000000, algorithmConfig, EvictionConfig.EVICTION_ACTION_CLASS_DEFAULT);
+ config.addEvictionCacheConfig(this.CACHE_NAME, ecc);
+ config.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
+ config.setIsolationLevel(IsolationLevel.REPEATABLE_READ);
+ cache = (CacheSPI<Object, Object>) new UnitTestCacheFactory<Object, Object>().createCache(config, true);
+ }
+
+ @AfterMethod(alwaysRun = true)
+ public void tearDown() throws Exception
+ {
+ TestingUtil.killCaches(cache);
+ cache = null;
+ }
+
+ public void testEviction()
+ {
+ String rootStr = "root";
+ for (int i = 0; i < 10; i++)
+ {
+ String str = rootStr + i;
+ try
+ {
+ cache.put(str, str);
+ }
+ catch (Exception e)
+ {
+ fail("Failed to insert data" + e);
+ e.printStackTrace();
+ }
+ }
+ cache.getEvictionManager().runEviction();
+
+ try
+ {
+ String val = (String) cache.get(rootStr + "3");
+ assertNull("DataNode should be empty ", val);
+ assertNull(cache.get(rootStr + "1"));
+ assertNull(cache.get(rootStr + "2"));
+ assertNull(cache.get(rootStr + "0"));
+ assertNull(cache.get(rootStr + "4"));
+
+ assertNotNull(cache.get(rootStr + "5"));
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ fail("Failed to get" + e);
+ }
+ }
+
+ public void testNodeVisited() throws InterruptedException
+ {
+ String rootStr = "root";
+ List<Object> keysToBeEvicted = new ArrayList<Object>();
+ for (int i = 0; i < 5; i++) keysToBeEvicted.add(rootStr + i);
+ EvictionWatcher watcher = new EvictionWatcher(cache, keysToBeEvicted);
+
+ for (int i = 0; i < 10; i++)
+ {
+ String str = rootStr + i;
+ try
+ {
+ cache.put(str, str);
+ }
+ catch (Exception e)
+ {
+ fail("Failed to insert data" + e);
+ e.printStackTrace();
+ }
+ }
+
+ cache.getEvictionManager().runEviction();
+
+ assert watcher.allNodesEvicted();
+
+ try
+ {
+ for (int i = 0; i < 5; i++)
+ {
+ assertNull(cache.get(rootStr + i));
+ }
+ for (int i = 5; i < 10; i++)
+ {
+ assertNotNull(cache.get(rootStr + i));
+ }
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ fail("Failed to evict" + e);
+ }
+ }
+
+}
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7089 - in core/branches/flat/src: main/java/org/jboss/starobrno/container and 7 other directories.
by jbosscache-commits＠lists.jboss.org
Author: manik.surtani(a)jboss.com
Date: 2008-11-05 19:31:36 -0500 (Wed, 05 Nov 2008)
New Revision: 7089
Added:
core/branches/flat/src/main/java/org/jboss/starobrno/tree/
core/branches/flat/src/main/java/org/jboss/starobrno/tree/Fqn.java
core/branches/flat/src/main/java/org/jboss/starobrno/tree/FqnComparator.java
core/branches/flat/src/main/java/org/jboss/starobrno/tree/Node.java
core/branches/flat/src/main/java/org/jboss/starobrno/tree/NodeImpl.java
core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCache.java
core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCacheImpl.java
core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeStructureSupport.java
core/branches/flat/src/test/java/org/jboss/starobrno/tree/
core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/
core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/NodeAPITest.java
core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/TreeCacheAPITest.java
Modified:
core/branches/flat/src/main/java/org/jboss/starobrno/Cache.java
core/branches/flat/src/main/java/org/jboss/starobrno/CacheDelegate.java
core/branches/flat/src/main/java/org/jboss/starobrno/CacheSPI.java
core/branches/flat/src/main/java/org/jboss/starobrno/container/UnsortedDataContainer.java
core/branches/flat/src/main/java/org/jboss/starobrno/factories/EvictionManagerFactory.java
core/branches/flat/src/main/java/org/jboss/starobrno/manager/CacheManager.java
core/branches/flat/src/test/resources/configs/local-tx.xml
Log:
Initial tree adapter
Modified: core/branches/flat/src/main/java/org/jboss/starobrno/Cache.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/Cache.java 2008-11-05 20:34:07 UTC (rev 7088)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/Cache.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -24,11 +24,12 @@
import org.jboss.cache.CacheStatus;
import org.jboss.starobrno.config.Configuration;
import org.jboss.starobrno.context.InvocationContext;
+import org.jboss.starobrno.interceptors.base.CommandInterceptor;
import org.jboss.starobrno.lifecycle.Lifecycle;
import org.jgroups.Address;
+import java.util.List;
import java.util.Set;
-import java.util.List;
import java.util.concurrent.ConcurrentMap;
/**
@@ -59,4 +60,16 @@
List<Address> getMembers();
String getName();
+
+ Address getLocalAddress();
+
+ String getVersion();
+
+ void addInterceptor(CommandInterceptor i, int position);
+
+ void addInterceptor(CommandInterceptor i, Class<? extends CommandInterceptor> afterInterceptor);
+
+ void removeInterceptor(int position);
+
+ void removeInterceptor(Class<? extends CommandInterceptor> interceptorType);
}
Modified: core/branches/flat/src/main/java/org/jboss/starobrno/CacheDelegate.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/CacheDelegate.java 2008-11-05 20:34:07 UTC (rev 7088)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/CacheDelegate.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -22,11 +22,11 @@
package org.jboss.starobrno;
import org.jboss.cache.CacheStatus;
+import org.jboss.cache.Version;
import org.jboss.cache.buddyreplication.BuddyManager;
import org.jboss.cache.buddyreplication.GravitateResult;
import org.jboss.cache.loader.CacheLoaderManager;
import org.jboss.cache.marshall.Marshaller;
-import org.jboss.starobrno.statetransfer.StateTransferManager;
import org.jboss.starobrno.batch.BatchContainer;
import org.jboss.starobrno.commands.CommandsFactory;
import org.jboss.starobrno.commands.read.GetKeyValueCommand;
@@ -39,18 +39,18 @@
import org.jboss.starobrno.commands.write.ReplaceCommand;
import org.jboss.starobrno.config.Configuration;
import org.jboss.starobrno.config.ConfigurationException;
+import org.jboss.starobrno.container.DataContainer;
import org.jboss.starobrno.context.InvocationContext;
import org.jboss.starobrno.factories.ComponentRegistry;
import org.jboss.starobrno.factories.annotations.Inject;
import org.jboss.starobrno.factories.annotations.NonVolatile;
import org.jboss.starobrno.interceptors.InterceptorChain;
-import org.jboss.starobrno.interceptors.EvictionInterceptor;
import org.jboss.starobrno.interceptors.base.CommandInterceptor;
import org.jboss.starobrno.invocation.InvocationContextContainer;
import org.jboss.starobrno.notifications.Notifier;
+import org.jboss.starobrno.statetransfer.StateTransferManager;
import org.jboss.starobrno.transaction.GlobalTransaction;
import org.jboss.starobrno.transaction.TransactionTable;
-import org.jboss.starobrno.eviction.EvictionCacheManager;
import org.jgroups.Address;
import javax.transaction.Transaction;
@@ -77,7 +77,9 @@
protected RPCManager rpcManager;
private String name;
private EvictionManager evictionManager;
+ private DataContainer dataContainer;
+
@Inject
private void injectDependencies(EvictionManager evictionManager,
InvocationContextContainer invocationContextContainer,
@@ -88,7 +90,7 @@
ComponentRegistry componentRegistry,
TransactionManager transactionManager,
BatchContainer batchContainer,
- RPCManager rpcManager)
+ RPCManager rpcManager, DataContainer dataContainer)
{
this.invocationContextContainer = invocationContextContainer;
this.commandsFactory = commandsFactory;
@@ -100,6 +102,7 @@
this.batchContainer = batchContainer;
this.rpcManager = rpcManager;
this.evictionManager = evictionManager;
+ this.dataContainer = dataContainer;
}
public V putIfAbsent(K key, V value)
@@ -326,7 +329,7 @@
public String getClusterName()
{
- throw new IllegalStateException();//todo Implement me properly
+ return config.getClusterName();
}
public GlobalTransaction getCurrentTransaction(Transaction tx, boolean createIfNotExists)
@@ -370,7 +373,7 @@
public List<Address> getMembers()
{
- return rpcManager.getMembers();
+ return rpcManager.getMembers();
}
public Object getDirect(Object key)
@@ -383,8 +386,24 @@
return name;
}
+ public String getVersion()
+ {
+ return Version.getVersionString(Version.getVersionShort());
+ }
+
+ public Address getLocalAddress()
+ {
+ return rpcManager.getLocalAddress();
+ }
+
public void setName(String name)
{
this.name = name;
}
+
+ @Override
+ public String toString()
+ {
+ return dataContainer == null ? super.toString() : dataContainer.toString();
+ }
}
Modified: core/branches/flat/src/main/java/org/jboss/starobrno/CacheSPI.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/CacheSPI.java 2008-11-05 20:34:07 UTC (rev 7088)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/CacheSPI.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -21,13 +21,7 @@
*/
package org.jboss.starobrno;
-import java.util.List;
-
-import javax.transaction.Transaction;
-import javax.transaction.TransactionManager;
-
import net.jcip.annotations.ThreadSafe;
-
import org.jboss.cache.Node;
import org.jboss.cache.NodeSPI;
import org.jboss.cache.buddyreplication.BuddyManager;
@@ -43,6 +37,10 @@
import org.jboss.starobrno.transaction.GlobalTransaction;
import org.jboss.starobrno.transaction.TransactionTable;
+import javax.transaction.Transaction;
+import javax.transaction.TransactionManager;
+import java.util.List;
+
/**
* A more detailed interface to {@link Cache}, which is used when writing plugins for or extending JBoss Cache. A reference
* to this interface should only be obtained when it is passed in to your code, for example when you write an
@@ -102,39 +100,6 @@
Marshaller getMarshaller();
/**
- * Adds a custom interceptor to the interceptor chain, at specified position, where the first interceptor in the chain
- * is at position 0 and the last one at getInterceptorChain().size() - 1.
- *
- * @param i the interceptor to add
- * @param position the position to add the interceptor
- */
- void addInterceptor(CommandInterceptor i, int position);
-
- /**
- * Adds a custom interceptor to the interceptor chain, after an instance of the specified interceptor type. Throws a
- * cache exception if it cannot find an interceptor of the specified type.
- *
- * @param i interceptor to add
- * @param afterInterceptor interceptor type after which to place custom interceptor
- */
- void addInterceptor(CommandInterceptor i, Class<? extends CommandInterceptor> afterInterceptor);
-
- /**
- * Removes the interceptor at a specified position, where the first interceptor in the chain
- * is at position 0 and the last one at getInterceptorChain().size() - 1.
- *
- * @param position the position at which to remove an interceptor
- */
- void removeInterceptor(int position);
-
- /**
- * Removes the interceptor of specified type.
- *
- * @param interceptorType type of interceptor to remove
- */
- void removeInterceptor(Class<? extends CommandInterceptor> interceptorType);
-
- /**
* Retrieves the current CacheCacheLoaderManager instance associated with the current Cache instance.
* <p/>
* From 2.1.0, Interceptor authors should obtain this by injection rather than this method. See the
Modified: core/branches/flat/src/main/java/org/jboss/starobrno/container/UnsortedDataContainer.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/container/UnsortedDataContainer.java 2008-11-05 20:34:07 UTC (rev 7088)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/container/UnsortedDataContainer.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -74,4 +74,9 @@
{
throw new UnsupportedOperationException("Not implemented");//todo please implement!
}
+
+ public String toString()
+ {
+ return data.toString();
+ }
}
Modified: core/branches/flat/src/main/java/org/jboss/starobrno/factories/EvictionManagerFactory.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/factories/EvictionManagerFactory.java 2008-11-05 20:34:07 UTC (rev 7088)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/factories/EvictionManagerFactory.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -1,24 +1,28 @@
package org.jboss.starobrno.factories;
-import org.jboss.starobrno.factories.annotations.DefaultFactoryFor;
import org.jboss.starobrno.EvictionManager;
import org.jboss.starobrno.eviction.EvictionManagerImpl;
+import org.jboss.starobrno.factories.annotations.DefaultFactoryFor;
/**
* @author Mircea.Markus(a)jboss.com
*/
-@DefaultFactoryFor (classes = {EvictionManager.class})
+@DefaultFactoryFor(classes = {EvictionManager.class})
public class EvictionManagerFactory extends ComponentFactory
{
protected <T> T construct(Class<T> componentType)
{
- if ( componentType != EvictionManager.class)
+ if (componentType != EvictionManager.class)
{
throw new IllegalStateException();
}
EvictionManagerImpl evManager = new EvictionManagerImpl();
- long wakeupInterval = configuration.getEvictionConfig().getWakeupInterval();
- evManager.configureEvictionThread(wakeupInterval, configuration.getRuntimeConfig().getEvictionTimerThreadFactory());
- return (T) evManager;
+ if (configuration.getEvictionConfig() != null)
+ {
+ long wakeupInterval = configuration.getEvictionConfig().getWakeupInterval();
+ evManager.configureEvictionThread(wakeupInterval, configuration.getRuntimeConfig().getEvictionTimerThreadFactory());
+ return (T) evManager;
+ }
+ else return null;
}
}
Modified: core/branches/flat/src/main/java/org/jboss/starobrno/manager/CacheManager.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/manager/CacheManager.java 2008-11-05 20:34:07 UTC (rev 7088)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/manager/CacheManager.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -25,6 +25,8 @@
import org.jboss.starobrno.Cache;
import org.jboss.starobrno.config.Configuration;
import org.jboss.starobrno.lifecycle.Lifecycle;
+import org.jboss.starobrno.tree.TreeCache;
+import org.jboss.starobrno.tree.TreeCacheImpl;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
@@ -39,6 +41,7 @@
{
protected Configuration c;
private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<String, Cache>();
+ private final ConcurrentMap<String, TreeCache> treeCaches = new ConcurrentHashMap<String, TreeCache>();
public CacheManager(Configuration c)
{
@@ -47,7 +50,8 @@
//if a config is shared between multiple managers, then each registers it's
// own chnnel in runtime
this.c = c.clone();
- } catch (CloneNotSupportedException e)
+ }
+ catch (CloneNotSupportedException e)
{
throw new RuntimeException(e);
}
@@ -73,12 +77,36 @@
return c;
}
+ public TreeCache createTreeCache(String cacheName)
+ {
+ if (!treeCaches.containsKey(cacheName))
+ treeCaches.putIfAbsent(cacheName, createTreeCache());
+ TreeCache tc = treeCaches.get(cacheName);
+ return tc;
+ }
+
public void destroyCache(String cacheName)
{
Cache c = caches.remove(cacheName);
if (c != null) c.stop();
}
+ protected TreeCache createTreeCache()
+ {
+ Configuration cfg = null;
+ try
+ {
+ cfg = c.clone();
+ }
+ catch (CloneNotSupportedException e)
+ {
+
+ }
+ cfg.setInvocationBatchingEnabled(true); // needed for the TreeCache
+ DefaultCacheFactory dcf = new DefaultCacheFactory();
+ return new TreeCacheImpl(dcf.createCache(cfg));
+ }
+
protected Cache createNewCache()
{
// for now latch on to the existing cache creation mechanisms
Added: core/branches/flat/src/main/java/org/jboss/starobrno/tree/Fqn.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/tree/Fqn.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/tree/Fqn.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,615 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2000 - 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.tree;
+
+
+import net.jcip.annotations.Immutable;
+import org.jboss.cache.util.Immutables;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A Fully Qualified Name (Fqn) is a list of names (typically Strings but can be any Object),
+ * which represent a path to a particular {@link Node} or sometimes a {@link Region} in a {@link Cache}.
+ * <p/>
+ * This name can be absolute (i.e., relative from the root node - {@link #ROOT}), or relative to any node in the cache. Reading the
+ * documentation on each API call that makes use of {@link org.jboss.cache.Fqn}s will tell you whether the API expects a
+ * relative or absolute Fqn.
+ * <p/>
+ * For instance, using this class to fetch a particular node might look like
+ * this. (Here data on "Joe" is kept under the "Smith" surname node, under
+ * the "people" tree.)
+ * <pre>
+ * Fqn<String> abc = Fqn.fromString("/people/Smith/Joe/");
+ * Node joesmith = Cache.getRoot().getChild(abc);
+ * </pre>
+ * Alternatively, the same Fqn could be constructed using a List<Object> or varargs:
+ * <pre>
+ * Fqn<String> abc = Fqn.fromElements("people", "Smith", "Joe");
+ * </pre>
+ * This is a bit more efficient to construct.
+ * <p/>
+ * Note that<br>
+ * <p/>
+ * <code>Fqn<String> f = Fqn.fromElements("/a/b/c");</code>
+ * <p/>
+ * is <b>not</b> the same as
+ * <p/>
+ * <code>Fqn<String> f = Fqn.fromString("/a/b/c");</code>
+ * <p/>
+ * The former will result in a single Fqn, called "/a/b/c" which hangs directly under Fqn.ROOT.
+ * <p/>
+ * The latter will result in 3 Fqns, called "a", "b" and "c", where "c" is a child of "b", "b" is a child of "a", and "a" hangs off Fqn.ROOT.
+ * <p/>
+ * Another way to look at it is that the "/" separarator is only parsed when it forms
+ * part of a String passed in to Fqn.fromString() and not otherwise.
+ * <p/>
+ * <B>Best practices</B>: Always creating Fqns - even when using some factory methods - can be expensive in the long run,
+ * and as far as possible we recommend that client code holds on to their Fqn references and reuse them. E.g.:
+ * <code>
+ * // BAD!!
+ * for (int i=0; i<someBigNumber; i++)
+ * {
+ * cache.get(Fqn.fromString("/a/b/c"), "key" + i);
+ * }
+ * </code>
+ * instead, do:
+ * <code>
+ * // Much better
+ * Fqn f = Fqn.fromString("/a/b/c");
+ * for (int i=0; i<someBigNumber; i++)
+ * {
+ * cache.get(f, "key" + i);
+ * }
+ * </code>
+ *
+ * @version $Revision$
+ */
+@Immutable
+public class Fqn implements Comparable<Fqn>, Externalizable
+{
+ /**
+ * Separator between FQN elements.
+ */
+ public static final String SEPARATOR = "/";
+
+ protected List<Object> elements;
+ private transient int hash_code = 0;
+ protected int size = 0;
+
+ /**
+ * Immutable root Fqn.
+ */
+ public static final Fqn ROOT = new Fqn();
+
+ /**
+ * A cached string representation of this Fqn, used by toString to it isn't calculated again every time.
+ */
+ protected String stringRepresentation;
+
+ // ----------------- START: Private constructors for use by factory methods only. ----------------------
+
+ /**
+ * Public to satisfy Externalization. // TODO: Remove this ctor as well as Externalization!!
+ */
+ public Fqn()
+ {
+ elements = Collections.emptyList();
+ size = 0;
+ }
+
+ /**
+ * If safe is false, Collections.unmodifiableList() is used to wrap the list passed in. This is an optimisation so
+ * Fqn.fromString(), probably the most frequently used factory method, doesn't end up needing to use the unmodifiableList()
+ * since it creates the list internally.
+ *
+ * @param names List of names
+ * @param safe whether this list is referenced externally (safe = false) or not (safe = true).
+ * @deprecated use {@link #fromList(java.util.List)} instead. The boolean "safety" hint is calculated internally. This constructor will be removed in 3.0.0.
+ */
+ @SuppressWarnings("unchecked")
+ private Fqn(List names, boolean safe)
+ {
+ if (names != null)
+ {
+ // if not safe make a defensive copy
+ elements = safe ? names : Immutables.immutableListCopy(names);
+ size = elements.size();
+ }
+ else
+ {
+ elements = Collections.emptyList();
+ size = 0;
+ }
+ }
+
+ private Fqn(Fqn base, List relative)
+ {
+ elements = Immutables.immutableListMerge(base.elements, relative);
+ size = elements.size();
+ }
+
+ // ----------------- END: Private constructors for use by factory methods only. ----------------------
+
+ /**
+ * Retrieves an Fqn that represents the list of elements passed in.
+ *
+ * @param names list of elements that comprise the Fqn
+ * @return an Fqn
+ * @since 2.2.0
+ */
+ @SuppressWarnings("unchecked")
+ public static Fqn fromList(List names)
+ {
+ return new Fqn(names, false);
+ }
+
+ /**
+ * Retrieves an Fqn that represents the list of elements passed in.
+ *
+ * @param names list of elements that comprise the Fqn
+ * @param safe if true, the list passed in is not defensively copied but used directly. <b>Use with care.</b> Make sure
+ * you know what you are doing before you pass in a <tt>true</tt> value to <tt>safe</tt>, as it can have adverse effects on
+ * performance or correctness. The defensive copy of list elements is not just for safety but also for performance as
+ * an appropriare List implementation is used, which works well with Fqn operations.
+ * @return an Fqn
+ */
+ @SuppressWarnings("unchecked")
+ public static Fqn fromList(List names, boolean safe)
+ {
+ return new Fqn(names, safe);
+ }
+
+ /**
+ * Retrieves an Fqn that represents the array of elements passed in.
+ *
+ * @param elements array of elements that comprise the Fqn
+ * @return an Fqn
+ * @since 2.2.0
+ */
+ public static Fqn fromElements(Object... elements)
+ {
+ return new Fqn(Arrays.asList(elements), true);
+ }
+
+ /**
+ * Retrieves an Fqn that represents the absolute Fqn of the relative Fqn passed in.
+ *
+ * @param base base Fqn
+ * @param relative relative Fqn
+ * @return an Fqn
+ * @since 2.2.0
+ */
+ public static Fqn fromRelativeFqn(Fqn base, Fqn relative)
+ {
+ return new Fqn(base, relative.elements);
+ }
+
+ /**
+ * Retrieves an Fqn that represents the List<Object> of elements passed in, relative to the base Fqn.
+ *
+ * @param base base Fqn
+ * @param relativeElements relative List<Object> of elements
+ * @return an Fqn
+ * @since 2.2.0
+ */
+ public static Fqn fromRelativeList(Fqn base, List relativeElements)
+ {
+ return new Fqn(base, relativeElements);
+ }
+
+ /**
+ * Retrieves an Fqn that represents the array of elements passed in, relative to the base Fqn.
+ *
+ * @param base base Fqn
+ * @param relativeElements relative elements
+ * @return an Fqn
+ * @since 2.2.0
+ */
+ public static Fqn fromRelativeElements(Fqn base, Object... relativeElements)
+ {
+ return new Fqn(base, Arrays.asList(relativeElements));
+ }
+
+ /**
+ * Returns a new Fqn from a string, where the elements are deliminated by
+ * one or more separator ({@link #SEPARATOR}) characters.<br><br>
+ * Example use:<br>
+ * <pre>
+ * Fqn.fromString("/a/b/c/");
+ * </pre><br>
+ * is equivalent to:<br>
+ * <pre>
+ * Fqn.fromElements("a", "b", "c");
+ * </pre>
+ *
+ * @param stringRepresentation String representation of the Fqn
+ * @return an Fqn<String> constructed from the string representation passed in
+ */
+ @SuppressWarnings("unchecked")
+ public static Fqn fromString(String stringRepresentation)
+ {
+ if (stringRepresentation == null || stringRepresentation.equals(SEPARATOR) || stringRepresentation.equals(""))
+ return root();
+
+ String toMatch = stringRepresentation.startsWith(SEPARATOR) ? stringRepresentation.substring(1) : stringRepresentation;
+ Object[] el = toMatch.split(SEPARATOR);
+ return new Fqn(Immutables.immutableListWrap(el), true);
+ }
+
+ /**
+ * Retrieves an Fqn read from an object input stream, typically written to using {@link #writeExternal(java.io.ObjectOutput)}.
+ *
+ * @param in input stream
+ * @return an Fqn
+ * @throws IOException in the event of a problem reading the stream
+ * @throws ClassNotFoundException in the event of classes that comprise the element list of this Fqn not being found
+ * @since 2.2.0
+ */
+ public static Fqn fromExternalStream(ObjectInput in) throws IOException, ClassNotFoundException
+ {
+ Fqn f = new Fqn();
+ f.readExternal(in);
+ return f;
+ }
+
+
+ /**
+ * Obtains an ancestor of the current Fqn. Literally performs <code>elements.subList(0, generation)</code>
+ * such that if
+ * <code>
+ * generation == Fqn.size()
+ * </code>
+ * then the return value is the Fqn itself (current generation), and if
+ * <code>
+ * generation == Fqn.size() - 1
+ * </code>
+ * then the return value is the same as
+ * <code>
+ * Fqn.getParent()
+ * </code>
+ * i.e., just one generation behind the current generation.
+ * <code>
+ * generation == 0
+ * </code>
+ * would return Fqn.ROOT.
+ *
+ * @param generation the generation of the ancestor to retrieve
+ * @return an ancestor of the current Fqn
+ */
+ public Fqn getAncestor(int generation)
+ {
+ if (generation == 0) return root();
+ return getSubFqn(0, generation);
+ }
+
+ /**
+ * Obtains a sub-Fqn from the given Fqn. Literally performs <code>elements.subList(startIndex, endIndex)</code>
+ *
+ * @param startIndex starting index
+ * @param endIndex end index
+ * @return a subFqn
+ */
+ public Fqn getSubFqn(int startIndex, int endIndex)
+ {
+ List el = elements.subList(startIndex, endIndex);
+ return new Fqn(el, true);
+ }
+
+ /**
+ * @return the number of elements in the Fqn. The root node contains zero.
+ */
+ public int size()
+ {
+ return size;
+ }
+
+ /**
+ * @param n index of the element to return
+ * @return Returns the nth element in the Fqn.
+ */
+ public Object get(int n)
+ {
+ return elements.get(n);
+ }
+
+ /**
+ * @return the last element in the Fqn.
+ * @see #getLastElementAsString
+ */
+ public Object getLastElement()
+ {
+ if (isRoot()) return null;
+ return elements.get(size - 1);
+ }
+
+ /**
+ * @param element element to find
+ * @return true if the Fqn contains this element, false otherwise.
+ */
+ public boolean hasElement(Object element)
+ {
+ return elements.indexOf(element) != -1;
+ }
+
+ /**
+ * Returns true if obj is a Fqn with the same elements.
+ */
+ @Override
+ public boolean equals(Object obj)
+ {
+ if (this == obj)
+ {
+ return true;
+ }
+ if (!(obj instanceof Fqn))
+ {
+ return false;
+ }
+ Fqn other = (Fqn) obj;
+ return size == other.size() && elements.equals(other.elements);
+ }
+
+ /**
+ * Returns a hash code with Fqn elements.
+ */
+ @Override
+ public int hashCode()
+ {
+ if (hash_code == 0)
+ {
+ hash_code = calculateHashCode();
+ }
+ return hash_code;
+ }
+
+ /**
+ * Returns this Fqn as a string, prefixing the first element with a {@link Fqn#SEPARATOR} and
+ * joining each subsequent element with a {@link Fqn#SEPARATOR}.
+ * If this is the root Fqn, returns {@link Fqn#SEPARATOR}.
+ * Example:
+ * <pre>
+ * new Fqn(new Object[] { "a", "b", "c" }).toString(); // "/a/b/c"
+ * Fqn.ROOT.toString(); // "/"
+ * </pre>
+ */
+ @Override
+ public String toString()
+ {
+ if (stringRepresentation == null)
+ {
+ stringRepresentation = getStringRepresentation(elements);
+ }
+ return stringRepresentation;
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException
+ {
+ out.writeShort(size);
+ for (Object element : elements)
+ {
+ out.writeObject(element);
+ }
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
+ {
+ size = in.readShort();
+ this.elements = new ArrayList(size);
+ for (int i = 0; i < size; i++) elements.add(in.readObject());
+ }
+
+
+ /**
+ * Returns true if this Fqn is child of parentFqn.
+ * Example usage:
+ * <pre>
+ * Fqn<String> f1 = Fqn.fromString("/a/b");
+ * Fqn<String> f2 = Fqn.fromString("/a/b/c");
+ * assertTrue(f1.isChildOf(f2));
+ * assertFalse(f1.isChildOf(f1));
+ * assertFalse(f2.isChildOf(f1));
+ * </pre>
+ *
+ * @param parentFqn candidate parent to test against
+ * @return true if the target is a child of parentFqn
+ */
+ public boolean isChildOf(Fqn parentFqn)
+ {
+ return parentFqn.size() != size && isChildOrEquals(parentFqn);
+ }
+
+
+ /**
+ * Returns true if this Fqn is a <i>direct</i> child of a given Fqn.
+ *
+ * @param parentFqn parentFqn to compare with
+ * @return true if this is a direct child, false otherwise.
+ */
+ public boolean isDirectChildOf(Fqn parentFqn)
+ {
+ return size == parentFqn.size() + 1 && isChildOf(parentFqn);
+ }
+
+ /**
+ * Returns true if this Fqn is equals or the child of parentFqn.
+ * Example usage:
+ * <pre>
+ * Fqn<String> f1 = Fqn.fromString("/a/b");
+ * Fqn<String> f2 = Fqn.fromString("/a/b/c");
+ * assertTrue(f1.isChildOrEquals(f2));
+ * assertTrue(f1.isChildOrEquals(f1));
+ * assertFalse(f2.isChildOrEquals(f1));
+ * </pre>
+ *
+ * @param parentFqn candidate parent to test against
+ * @return true if this Fqn is equals or the child of parentFqn.
+ */
+ public boolean isChildOrEquals(Fqn parentFqn)
+ {
+ List parentList = parentFqn.elements;
+ if (parentList.size() > size)
+ {
+ return false;
+ }
+ for (int i = parentList.size() - 1; i >= 0; i--)
+ {
+ if (!parentList.get(i).equals(elements.get(i)))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Calculates a hash code by summing the hash code of all elements.
+ *
+ * @return a calculated hashcode
+ */
+ protected int calculateHashCode()
+ {
+ int hashCode = 19;
+ for (Object o : elements) hashCode = 31 * hashCode + (o == null ? 0 : o.hashCode());
+ if (hashCode == 0) hashCode = 0xDEADBEEF; // degenerate case
+ return hashCode;
+ }
+
+ protected String getStringRepresentation(List elements)
+ {
+ StringBuilder builder = new StringBuilder();
+ for (Object e : elements)
+ {
+ // incase user element 'e' does not implement equals() properly, don't rely on their implementation.
+ if (!SEPARATOR.equals(e) && !"".equals(e))
+ {
+ builder.append(SEPARATOR);
+ builder.append(e);
+ }
+ }
+ return builder.length() == 0 ? SEPARATOR : builder.toString();
+ }
+
+
+ /**
+ * Returns the parent of this Fqn.
+ * The parent of the root node is {@link #ROOT}.
+ * Examples:
+ * <pre>
+ * Fqn<String> f1 = Fqn.fromString("/a");
+ * Fqn<String> f2 = Fqn.fromString("/a/b");
+ * assertEquals(f1, f2.getParent());
+ * assertEquals(Fqn.ROOT, f1.getParent().getParent());
+ * assertEquals(Fqn.ROOT, Fqn.ROOT.getParent());
+ * </pre>
+ *
+ * @return the parent Fqn
+ */
+ public Fqn getParent()
+ {
+ switch (size)
+ {
+ case 0:
+ case 1:
+ return root();
+ default:
+ return new Fqn(elements.subList(0, size - 1), true);
+ }
+ }
+
+ public static final Fqn root() // declared final so compilers can optimise and in-line.
+ {
+ return ROOT;
+ }
+
+ /**
+ * Returns true if this is a root Fqn.
+ *
+ * @return true if the Fqn is Fqn.ROOT.
+ */
+ public boolean isRoot()
+ {
+ return size == 0;
+ }
+
+ /**
+ * If this is the root, returns {@link Fqn#SEPARATOR}.
+ *
+ * @return a String representation of the last element that makes up this Fqn.
+ */
+ public String getLastElementAsString()
+ {
+ if (isRoot())
+ {
+ return SEPARATOR;
+ }
+ else
+ {
+ Object last = getLastElement();
+ if (last instanceof String)
+ return (String) last;
+ else
+ return String.valueOf(getLastElement());
+ }
+ }
+
+ /**
+ * Peeks into the elements that build up this Fqn. The list returned is
+ * read-only, to maintain the immutable nature of Fqn.
+ *
+ * @return an unmodifiable list
+ */
+ public List peekElements()
+ {
+ return elements;
+ }
+
+ /**
+ * Compares this Fqn to another using {@link FqnComparator}.
+ */
+ public int compareTo(Fqn fqn)
+ {
+ return FqnComparator.INSTANCE.compare(this, fqn);
+ }
+
+ /**
+ * Creates a new Fqn whose ancestor has been replaced with the new ancestor passed in.
+ *
+ * @param oldAncestor old ancestor to replace
+ * @param newAncestor nw ancestor to replace with
+ * @return a new Fqn with ancestors replaced.
+ */
+ public Fqn replaceAncestor(Fqn oldAncestor, Fqn newAncestor)
+ {
+ if (!isChildOf(oldAncestor))
+ throw new IllegalArgumentException("Old ancestor must be an ancestor of the current Fqn!");
+ Fqn subFqn = this.getSubFqn(oldAncestor.size(), size());
+ return Fqn.fromRelativeFqn(newAncestor, subFqn);
+ }
+}
\ No newline at end of file
Copied: core/branches/flat/src/main/java/org/jboss/starobrno/tree/FqnComparator.java (from rev 7085, core/branches/flat/src/main/java/org/jboss/cache/FqnComparator.java)
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/tree/FqnComparator.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/tree/FqnComparator.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,121 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2000 - 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.tree;
+
+import net.jcip.annotations.Immutable;
+
+import java.io.Serializable;
+import java.util.Comparator;
+
+/**
+ * Compares the order of two FQN.
+ * Sorts by name, then by depth, e.g.
+ * <pre>
+ * aaa/bbb
+ * xxx
+ * xxx/ccc
+ * </pre>
+ *
+ * @author Manik Surtani (<a href="mailto:manik@jboss.org">manik(a)jboss.org</a>)
+ * @author Steve Woodcock (<a href="mailto:stevew@jofti.com">stevew(a)jofti.com</a>)
+ */
+@Immutable
+public class FqnComparator implements Comparator<Fqn>, Serializable
+{
+ public static final FqnComparator INSTANCE = new FqnComparator();
+
+ /**
+ * Returns -1 if the first comes before; 0 if they are the same; 1 if the
+ * second Fqn comes before. <code>null</code> always comes first.
+ */
+ public int compare(Fqn fqn1, Fqn fqn2)
+ {
+ int s1 = fqn1.size();
+ int s2 = fqn2.size();
+
+ if (s1 == 0)
+ {
+ return (s2 == 0) ? 0 : -1;
+ }
+
+ if (s2 == 0)
+ {
+ return 1;
+ }
+
+// if (fqn1.getClass().equals(StringFqn.class) && fqn2.getClass().equals(StringFqn.class))
+// {
+// StringFqn sfqn1 = (StringFqn) fqn1;
+// StringFqn sfqn2 = (StringFqn) fqn2;
+// return sfqn1.stringRepresentation.compareTo(sfqn2.stringRepresentation);
+// }
+ int size = Math.min(s1, s2);
+
+ for (int i = 0; i < size; i++)
+ {
+ Object e1 = fqn1.get(i);
+ Object e2 = fqn2.get(i);
+ if (e1 == e2)
+ {
+ continue;
+ }
+ if (e1 == null)
+ {
+ return 0;
+ }
+ if (e2 == null)
+ {
+ return 1;
+ }
+ if (!e1.equals(e2))
+ {
+ int c = compareElements(e1, e2);
+ if (c != 0)
+ {
+ return c;
+ }
+ }
+ }
+
+ return s1 - s2;
+ }
+
+ /**
+ * Compares two Fqn elements.
+ * If e1 and e2 are the same class and e1 implements Comparable,
+ * returns e1.compareTo(e2).
+ * Otherwise, returns e1.toString().compareTo(e2.toString()).
+ */
+ private int compareElements(Object e1, Object e2)
+ {
+ if (e1.getClass() == e2.getClass() && e1 instanceof Comparable)
+ {
+ return ((Comparable<Object>) e1).compareTo(e2);
+ }
+ else
+ {
+ return e1.toString().compareTo(e2.toString());
+ }
+ }
+
+
+}
\ No newline at end of file
Added: core/branches/flat/src/main/java/org/jboss/starobrno/tree/Node.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/tree/Node.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/tree/Node.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,299 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2000 - 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.tree;
+
+import net.jcip.annotations.ThreadSafe;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A Node is a {@link Fqn named} logical grouping of data in the JBoss {@link Cache}.
+ * A node should be used to contain data for a single data record, for example
+ * information about a particular person or account.
+ * <p/>
+ * One purpose of grouping cache data into separate nodes is to minimize transaction
+ * locking interference, and increase concurrency. So for example, when multiple threads or
+ * possibly distributed caches are acccessing different accounts simultaneously.
+ * <p/>
+ * Another is that when making changes to this node, its data might be kept in a single
+ * database row or file on disk. (Persisted via the use of a {@link org.jboss.cache.loader.CacheLoader}.)
+ * <p/>
+ * A node has references to its children, parent (each node except the root - defined by {@link Fqn#ROOT} - has
+ * a single parent) and data contained within the node (as key/value pairs). The
+ * data access methods are similar to the collections {@link Map} interface,
+ * but some are read-only or return copies of the underlying the data.
+ * <p/>
+ *
+ * @author <a href="mailto:manik AT jboss DOT org">Manik Surtani (manik AT jboss DOT org)</a>
+ * @see Cache
+ * @since 2.0.0
+ */
+@ThreadSafe
+public interface Node<K, V>
+{
+ /**
+ * Returns the parent node.
+ * If this is the root node, this method returns <code>null</code>.
+ *
+ * @return the parent node, or null if this is the root node
+ */
+ Node<K, V> getParent();
+
+ /**
+ * Returns an immutable set of children nodes.
+ *
+ * @return an immutable {@link Set} of child nodes. Empty {@link Set} if there aren't any children.
+ */
+ Set<Node<K, V>> getChildren();
+
+ /**
+ * Returns an immutable set of children node names.
+ *
+ * @return an immutable {@link Set} of child node names. Empty {@link Set} if there aren't any children.
+ */
+ Set<Object> getChildrenNames();
+
+ /**
+ * Returns a map containing the data in this {@link Node}.
+ *
+ * @return a {@link Map} containing the data in this {@link Node}. If there is no data, an empty {@link Map} is returned. The {@link Map} returned is always immutable.
+ */
+ Map<K, V> getData();
+
+ /**
+ * Returns a {@link Set} containing the data in this {@link Node}.
+ *
+ * @return a {@link Set} containing the data in this {@link Node}. If there is no data, an empty {@link Set} is returned. The {@link Set} returned is always immutable.
+ */
+ Set<K> getKeys();
+
+ /**
+ * Returns the {@link Fqn} which represents the location of this {@link Node} in the cache structure. The {@link Fqn} returned is absolute.
+ *
+ * @return The {@link Fqn} which represents the location of this {@link Node} in the cache structure. The {@link Fqn} returned is absolute.
+ */
+ Fqn getFqn();
+
+ /**
+ * Adds a child node with the given {@link Fqn} under the current node. Returns the newly created node.
+ * <p/>
+ * If the child exists returns the child node anyway. Guaranteed to return a non-null node.
+ * <p/>
+ * The {@link Fqn} passed in is relative to the current node. The new child node will have an absolute fqn
+ * calculated as follows: <pre>new Fqn(getFqn(), f)</pre>. See {@link Fqn} for the operation of this constructor.
+ *
+ * @param f {@link Fqn} of the child node, relative to the current node.
+ * @return the newly created node, or the existing node if one already exists.
+ */
+ Node<K, V> addChild(Fqn f);
+
+ /**
+ * Removes a child node specified by the given relative {@link Fqn}.
+ * <p/>
+ * If you wish to remove children based on absolute {@link Fqn}s, use the {@link Cache} interface instead.
+ *
+ * @param f {@link Fqn} of the child node, relative to the current node.
+ * @return true if the node was found and removed, false otherwise
+ */
+ boolean removeChild(Fqn f);
+
+ /**
+ * Removes a child node specified by the given name.
+ *
+ * @param childName name of the child node, directly under the current node.
+ * @return true if the node was found and removed, false otherwise
+ */
+ boolean removeChild(Object childName);
+
+
+ /**
+ * Returns the child node
+ *
+ * @param f {@link Fqn} of the child node
+ * @return null if the child does not exist.
+ */
+ Node<K, V> getChild(Fqn f);
+
+ /**
+ * @param name name of the child
+ * @return a direct child of the current node.
+ */
+ Node<K, V> getChild(Object name);
+
+ /**
+ * Associates the specified value with the specified key for this node.
+ * If this node previously contained a mapping for this key, the old value is replaced by the specified value.
+ *
+ * @param key key with which the specified value is to be associated.
+ * @param value value to be associated with the specified key.
+ * @return Returns the old value contained under this key. Null if key doesn't exist.
+ */
+ V put(K key, V value);
+
+ /**
+ * If the specified key is not already associated with a value, associate it with the given value, and returns the
+ * Object (if any) that occupied the space, or null.
+ * <p/>
+ * Equivalent to calling
+ * <pre>
+ * if (!node.getKeys().contains(key))
+ * return node.put(key, value);
+ * else
+ * return node.get(key);
+ * </pre>
+ * <p/>
+ * except that this is atomic.
+ *
+ * @param key key with which the specified value is to be associated.
+ * @param value value to be associated with the specified key.
+ * @return previous value associated with specified key, or null if there was no mapping for key.
+ */
+ V putIfAbsent(K key, V value);
+
+ /**
+ * Replace entry for key only if currently mapped to some value.
+ * Acts as
+ * <pre>
+ * if ((node.getKeys().contains(key))
+ * {
+ * return node.put(key, value);
+ * }
+ * else
+ * return null;
+ * </pre>
+ * <p/>
+ * except that this is atomic.
+ *
+ * @param key key with which the specified value is associated.
+ * @param value value to be associated with the specified key.
+ * @return previous value associated with specified key, or <tt>null</tt>
+ * if there was no mapping for key.
+ */
+ V replace(K key, V value);
+
+ /**
+ * Replace entry for key only if currently mapped to given value.
+ * Acts as
+ * <pre>
+ * if (node.get(key).equals(oldValue))
+ * {
+ * node.put(key, newValue);
+ * return true;
+ * }
+ * else
+ * return false;
+ * </pre>
+ * <p/>
+ * except that this is atomic.
+ *
+ * @param key key with which the specified value is associated.
+ * @param oldValue value expected to be associated with the specified key.
+ * @param newValue value to be associated with the specified key.
+ * @return true if the value was replaced
+ */
+ boolean replace(K key, V oldValue, V newValue);
+
+
+ /**
+ * Copies all of the mappings from the specified map to this node's map.
+ * If any data exists, existing keys are overwritten with the keys in the new map.
+ * The behavior is equivalent to:
+ * <pre>
+ * Node node;
+ * for (Map.Entry me : map.entrySet())
+ * node.put(me.getKey(), me.getValue());
+ * </pre>
+ *
+ * @param map map to copy from
+ */
+ void putAll(Map<? extends K, ? extends V> map);
+
+ /**
+ * Similar to {@link #putAll(java.util.Map)} except that it removes any entries that exists in
+ * the data map first. Note that this happens atomically, under a single lock. This is the analogous
+ * to doing a {@link #clearData()} followed by a {@link #putAll(java.util.Map)} in the same transaction.
+ *
+ * @param map map to copy from
+ */
+ void replaceAll(Map<? extends K, ? extends V> map);
+
+
+ /**
+ * Returns the value to which this node maps the specified key.
+ * Returns <code>null</code> if the node contains no mapping for this key.
+ *
+ * @param key key of the data to return
+ * @return the value to which this node maps the specified key, or <code>null</code> if the map contains no mapping for this key
+ */
+ V get(K key);
+
+ /**
+ * Removes the mapping for this key from this node if it is present.
+ * Returns the value to which the node previously associated the key,
+ * or <code>null</code> if the node contained no mapping for this key
+ *
+ * @param key key whose mapping is to be removed
+ * @return previous value associated with specified key, or <code>null</code>
+ * if there was no mapping for key
+ */
+ V remove(K key);
+
+ /**
+ * Removes all mappings from the node's data map.
+ */
+ void clearData();
+
+ /**
+ * @return the number of elements (key/value pairs) in the node's data map.
+ */
+ int dataSize();
+
+ /**
+ * Returns true if the child node denoted by the relative {@link Fqn} passed in exists.
+ *
+ * @param f {@link Fqn} relative to the current node of the child you are testing the existence of.
+ * @return true if the child node denoted by the relative {@link Fqn} passed in exists.
+ */
+ boolean hasChild(Fqn f);
+
+ /**
+ * Returns true if the child node denoted by the Object name passed in exists.
+ *
+ * @param o name of the child, relative to the current node
+ * @return true if the child node denoted by the name passed in exists.
+ */
+ boolean hasChild(Object o);
+
+ /**
+ * 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.
+ */
+ boolean isValid();
+
+ void evict();
+
+ void removeChildren();
+}
Added: core/branches/flat/src/main/java/org/jboss/starobrno/tree/NodeImpl.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/tree/NodeImpl.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/tree/NodeImpl.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,398 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.tree;
+
+import org.jboss.starobrno.Cache;
+import org.jboss.starobrno.util.Immutables;
+import org.jboss.starobrno.util.Util;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * // TODO: MANIK: Document this
+ *
+ * @author Manik Surtani (<a href="mailto:manik AT jboss DOT org">manik AT jboss DOT org</a>)
+ * @since 3.0
+ */
+public class NodeImpl<K, V> extends TreeStructureSupport implements Node<K, V>
+{
+ Fqn fqn;
+ Key dataKey, structureKey;
+
+ public NodeImpl(Fqn fqn, Cache cache, ThreadLocal<Boolean> atomicityContainer)
+ {
+ super(atomicityContainer, cache);
+ this.fqn = fqn;
+ dataKey = new Key(fqn, Type.DATA);
+ structureKey = new Key(fqn, Type.STRUCTURE);
+ }
+
+ public Node<K, V> getParent()
+ {
+ if (fqn.isRoot()) return this;
+ return new NodeImpl(fqn.getParent(), cache, batchStarted);
+ }
+
+ public Set<Node<K, V>> getChildren()
+ {
+ startAtomic();
+ try
+ {
+ Set set = new HashSet();
+ for (Fqn f : getStructure().children.values())
+ {
+ NodeImpl n = new NodeImpl(f, cache, batchStarted);
+ set.add(n);
+ }
+ return Immutables.immutableSetWrap(set);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public Set<Object> getChildrenNames()
+ {
+ return Immutables.immutableSetCopy(getStructure().children.keySet());
+ }
+
+ public Map<K, V> getData()
+ {
+ return Immutables.immutableMapCopy(getDataInternal());
+ }
+
+ public Set<K> getKeys()
+ {
+ startAtomic();
+ try
+ {
+ return getData().keySet();
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public Fqn getFqn()
+ {
+ return fqn;
+ }
+
+ public Node<K, V> addChild(Fqn f)
+ {
+ startAtomic();
+ try
+ {
+ Fqn absoluteChildFqn = Fqn.fromRelativeFqn(fqn, f);
+ NodeImpl child = new NodeImpl(absoluteChildFqn, cache, batchStarted);
+ Structure s = getStructure();
+ s.children.put(f.getLastElement(), absoluteChildFqn);
+ updateStructure(s);
+ createNodeInCache(absoluteChildFqn);
+ return child;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public boolean removeChild(Fqn f)
+ {
+ return removeChild(f.getLastElement());
+ }
+
+ public boolean removeChild(Object childName)
+ {
+ startAtomic();
+ try
+ {
+ Structure s = (Structure) cache.get(structureKey);
+ Fqn childFqn = s.children.remove(childName);
+ if (childFqn != null)
+ {
+ Node child = new NodeImpl(childFqn, cache, batchStarted);
+ child.removeChildren();
+ cache.remove(new Key(childFqn, Type.DATA));
+ cache.remove(new Key(childFqn, Type.STRUCTURE));
+ updateStructure(s);
+ return true;
+ }
+
+ return false;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public Node<K, V> getChild(Fqn f)
+ {
+ startAtomic();
+ try
+ {
+ if (hasChild(f))
+ return new NodeImpl(Fqn.fromRelativeFqn(fqn, f), cache, batchStarted);
+ else
+ return null;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public Node<K, V> getChild(Object name)
+ {
+ startAtomic();
+ try
+ {
+ if (hasChild(name))
+ return new NodeImpl(Fqn.fromRelativeElements(fqn, name), cache, batchStarted);
+ else
+ return null;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public V put(K key, V value)
+ {
+ startAtomic();
+ try
+ {
+ Map data = getDataInternal();
+ Object result = data.put(key, value);
+ putAll(data);
+ return (V) result;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public V putIfAbsent(K key, V value)
+ {
+ startAtomic();
+ try
+ {
+ Map data = getData();
+ Object result = null;
+ if (!data.containsKey(key))
+ {
+ result = data.put(key, value);
+ putAll(data);
+ }
+
+ return (V) result;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public V replace(K key, V value)
+ {
+ startAtomic();
+ try
+ {
+ Map data = getData();
+ V old = (V) data.put(key, value);
+ putData(data);
+ return old;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public boolean replace(K key, V oldValue, V newValue)
+ {
+ startAtomic();
+ try
+ {
+ Map data = getData();
+ V old = (V) data.get(key);
+ if (Util.safeEquals(oldValue, old))
+ {
+ data.put(key, newValue);
+ return true;
+ }
+ return false;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public void putAll(Map<? extends K, ? extends V> map)
+ {
+ startAtomic();
+ try
+ {
+ Map data = getDataInternal();
+ data.putAll(map);
+ putData(data);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public void replaceAll(Map<? extends K, ? extends V> map)
+ {
+ putData(map);
+ }
+
+ public V get(K key)
+ {
+ return getData().get(key);
+ }
+
+ public V remove(K key)
+ {
+ startAtomic();
+ try
+ {
+ Map data = getDataInternal();
+ V old = (V) data.remove(key);
+ putData(data);
+ return old;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public void clearData()
+ {
+ putData(Collections.emptyMap());
+ }
+
+ public int dataSize()
+ {
+ return getData().size();
+ }
+
+ public boolean hasChild(Fqn f)
+ {
+ if (f.size() > 1)
+ {
+ // indirect child.
+ Fqn absoluteFqn = Fqn.fromRelativeFqn(fqn, f);
+ return exists(absoluteFqn);
+ }
+ else
+ {
+ return hasChild(f.getLastElement());
+ }
+ }
+
+ public boolean hasChild(Object o)
+ {
+ return getStructure().children.containsKey(o);
+ }
+
+ public boolean isValid()
+ {
+ return cache.containsKey(dataKey);
+ }
+
+ public void removeChildren()
+ {
+ startAtomic();
+ try
+ {
+ Structure s = getStructure();
+ for (Object o : Immutables.immutableSetCopy(s.children.keySet())) removeChild(o);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public void evict()
+ {
+ startAtomic();
+ try
+ {
+ cache.evict(structureKey);
+ cache.evict(dataKey);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ void putData(Map m)
+ {
+ cache.put(dataKey, m);
+ }
+
+ Map<K, V> getDataInternal()
+ {
+ return (Map<K, V>) cache.get(dataKey);
+ }
+
+ void updateStructure(Structure s)
+ {
+ cache.put(structureKey, s);
+ }
+
+ Structure getStructure()
+ {
+ return (Structure) cache.get(structureKey);
+ }
+
+ public boolean equals(Object o)
+ {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ NodeImpl node = (NodeImpl) o;
+
+ if (fqn != null ? !fqn.equals(node.fqn) : node.fqn != null) return false;
+
+ return true;
+ }
+
+ public int hashCode()
+ {
+ return (fqn != null ? fqn.hashCode() : 0);
+ }
+}
Added: core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCache.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCache.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCache.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,495 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.tree;
+
+import org.jboss.cache.CacheStatus;
+import org.jboss.cache.NodeNotExistsException;
+import org.jboss.cache.Region;
+import org.jboss.starobrno.Cache;
+import org.jboss.starobrno.CacheException;
+import org.jboss.starobrno.config.Configuration;
+import org.jboss.starobrno.context.InvocationContext;
+import org.jboss.starobrno.interceptors.base.CommandInterceptor;
+import org.jboss.starobrno.lifecycle.Lifecycle;
+import org.jgroups.Address;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * // TODO: MANIK: Document this
+ *
+ * @author Manik Surtani (<a href="mailto:manik AT jboss DOT org">manik AT jboss DOT org</a>)
+ * @since 3.0
+ */
+public interface TreeCache<K, V> extends Lifecycle
+{
+ /**
+ * Returns the root node of this cache.
+ *
+ * @return the root node
+ */
+ Node<K, V> getRoot();
+
+ /**
+ * Adds a {@link org.jboss.cache.notifications.annotation.CacheListener}-annotated object to the entire cache. The object passed in needs to be properly annotated with the
+ * {@link org.jboss.cache.notifications.annotation.CacheListener} annotation otherwise an {@link org.jboss.cache.notifications.IncorrectCacheListenerException} will be thrown.
+ *
+ * @param listener listener to add
+ */
+ void addCacheListener(Object listener);
+
+ /**
+ * Removes a {@link org.jboss.cache.notifications.annotation.CacheListener}-annotated object from the cache. The object passed in needs to be properly annotated with the
+ * {@link org.jboss.cache.notifications.annotation.CacheListener} annotation otherwise an {@link org.jboss.cache.notifications.IncorrectCacheListenerException} will be thrown.
+ *
+ * @param listener listener to remove
+ */
+ void removeCacheListener(Object listener);
+
+ /**
+ * Retrieves an immutable {@link List} of objects annotated as {@link org.jboss.cache.notifications.annotation.CacheListener}s attached to the cache.
+ *
+ * @return an immutable {@link List} of objects annotated as {@link org.jboss.cache.notifications.annotation.CacheListener}s attached to the cache.
+ */
+ Set<Object> getCacheListeners();
+
+ /**
+ * Associates the specified value with the specified key for a {@link Node} in this cache.
+ * If the {@link Node} previously contained a mapping for this key, the old value is replaced by the specified value.
+ *
+ * @param fqn <b><i>absolute</i></b> {@link Fqn} to the {@link Node} to be accessed.
+ * @param key key with which the specified value is to be associated.
+ * @param value value to be associated with the specified key.
+ * @return previous value associated with specified key, or <code>null</code> if there was no mapping for key.
+ * A <code>null</code> return can also indicate that the Node previously associated <code>null</code> with the specified key, if the implementation supports null values.
+ * @throws IllegalStateException if the cache is not in a started state.
+ */
+ V put(Fqn fqn, K key, V value);
+
+ /**
+ * Convenience method that takes a string representation of an Fqn. Otherwise identical to {@link #put(Fqn, Object, Object)}
+ *
+ * @param fqn String representation of the Fqn
+ * @param key key with which the specified value is to be associated.
+ * @param value value to be associated with the specified key.
+ * @return previous value associated with specified key, or <code>null</code> if there was no mapping for key.
+ * A <code>null</code> return can also indicate that the Node previously associated <code>null</code> with the specified key, if the implementation supports null values.
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+
+ V put(String fqn, K key, V value);
+
+ /**
+ * Under special operating behavior, associates the value with the specified key for a node identified by the Fqn passed in.
+ * <ul>
+ * <li> Only goes through if the node specified does not exist; no-op otherwise.</i>
+ * <li> Force asynchronous mode for replication to prevent any blocking.</li>
+ * <li> invalidation does not take place. </li>
+ * <li> 0ms lock timeout to prevent any blocking here either. If the lock is not acquired, this method is a no-op, and swallows the timeout exception.</li>
+ * <li> Ongoing transactions are suspended before this call, so failures here will not affect any ongoing transactions.</li>
+ * <li> Errors and exceptions are 'silent' - logged at a much lower level than normal, and this method does not throw exceptions</li>
+ * </ul>
+ * This method is for caching data that has an external representation in storage, where, concurrent modification and
+ * transactions are not a consideration, and failure to put the data in the cache should be treated as a 'suboptimal outcome'
+ * rather than a 'failing outcome'.
+ * <p/>
+ * An example of when this method is useful is when data is read from, for example, a legacy datastore, and is cached before
+ * returning the data to the caller. Subsequent calls would prefer to get the data from the cache and if the data doesn't exist
+ * in the cache, fetch again from the legacy datastore.
+ * <p/>
+ * See <a href="http://jira.jboss.com/jira/browse/JBCACHE-848">JBCACHE-848</a> for details around this feature.
+ * <p/>
+ *
+ * @param fqn <b><i>absolute</i></b> {@link Fqn} to the {@link Node} to be accessed.
+ * @param key key with which the specified value is to be associated.
+ * @param value value to be associated with the specified key.
+ * @throws IllegalStateException if {@link #getCacheStatus()} would not return {@link org.jboss.cache.CacheStatus#STARTED}.
+ */
+ void putForExternalRead(Fqn fqn, K key, V value);
+
+ /**
+ * Copies all of the mappings from the specified map to a {@link Node}.
+ *
+ * @param fqn <b><i>absolute</i></b> {@link Fqn} to the {@link Node} to copy the data to
+ * @param data mappings to copy
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ void put(Fqn fqn, Map<? extends K, ? extends V> data);
+
+ /**
+ * Convenience method that takes a string representation of an Fqn. Otherwise identical to {@link #put(Fqn, java.util.Map)}
+ *
+ * @param fqn String representation of the Fqn
+ * @param data data map to insert
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ void put(String fqn, Map<? extends K, ? extends V> data);
+
+ /**
+ * Removes the mapping for this key from a Node.
+ * Returns the value to which the Node previously associated the key, or
+ * <code>null</code> if the Node contained no mapping for this key.
+ *
+ * @param fqn <b><i>absolute</i></b> {@link Fqn} to the {@link Node} to be accessed.
+ * @param key key whose mapping is to be removed from the Node
+ * @return previous value associated with specified Node's key
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ V remove(Fqn fqn, K key);
+
+ /**
+ * Convenience method that takes a string representation of an Fqn. Otherwise identical to {@link #remove(Fqn, Object)}
+ *
+ * @param fqn string representation of the Fqn to retrieve
+ * @param key key to remove
+ * @return old value removed, or null if the fqn does not exist
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ V remove(String fqn, K key);
+
+ /**
+ * Removes a {@link Node} indicated by absolute {@link Fqn}.
+ *
+ * @param fqn {@link Node} to remove
+ * @return true if the node was removed, false if the node was not found
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ boolean removeNode(Fqn fqn);
+
+ /**
+ * Convenience method that takes a string representation of an Fqn. Otherwise identical to {@link #removeNode(Fqn)}
+ *
+ * @param fqn string representation of the Fqn to retrieve
+ * @return true if the node was found and removed, false otherwise
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ boolean removeNode(String fqn);
+
+ /**
+ * A convenience method to retrieve a node directly from the cache. Equivalent to calling cache.getRoot().getChild(fqn).
+ *
+ * @param fqn fqn of the node to retrieve
+ * @return a Node object, or a null if the node does not exist.
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ Node<K, V> getNode(Fqn fqn);
+
+ /**
+ * Convenience method that takes a string representation of an Fqn. Otherwise identical to {@link #getNode(Fqn)}
+ *
+ * @param fqn string representation of the Fqn to retrieve
+ * @return node, or null if the node does not exist
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ Node<K, V> getNode(String fqn);
+
+
+ /**
+ * Convenience method that allows for direct access to the data in a {@link Node}.
+ *
+ * @param fqn <b><i>absolute</i></b> {@link Fqn} to the {@link Node} to be accessed.
+ * @param key key under which value is to be retrieved.
+ * @return returns data held under specified key in {@link Node} denoted by specified Fqn.
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ V get(Fqn fqn, K key);
+
+ /**
+ * Convenience method that takes a string representation of an Fqn. Otherwise identical to {@link #get(Fqn, Object)}
+ *
+ * @param fqn string representation of the Fqn to retrieve
+ * @param key key to fetch
+ * @return value, or null if the fqn does not exist.
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ V get(String fqn, K key);
+
+ /**
+ * Eviction call that evicts the specified {@link Node} from memory.
+ *
+ * @param fqn <b><i>absolute</i></b> {@link Fqn} to the {@link Node} to be evicted.
+ * @param recursive evicts children as well
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ void evict(Fqn fqn, boolean recursive);
+
+ /**
+ * Eviction call that evicts the specified {@link Node} from memory. Not recursive.
+ *
+ * @param fqn <b><i>absolute</i></b> {@link Fqn} to the {@link Node} to be evicted.
+ * @throws IllegalStateException if the cache is not in a started state
+ */
+ void evict(Fqn fqn);
+
+ /**
+ * Retrieves a {@link Region} for a given {@link Fqn}. If the region does not exist,
+ * and <li>createIfAbsent</li> is true, then one is created.
+ * <p/>
+ * If not, parent Fqns will be consulted in turn for registered regions, gradually working up to
+ * Fqn.ROOT. If no regions are defined in any of the parents either, a null is returned.
+ *
+ * @param fqn Fqn that is contained in a region.
+ * @param createIfAbsent If true, will create a new associated region if not found.
+ * @return a MarshRegion. Null if none is found.
+ * @see Region
+ */
+ Region getRegion(Fqn fqn, boolean createIfAbsent);
+
+ /**
+ * Removes a region denoted by the Fqn passed in.
+ *
+ * @param fqn of the region to remove
+ * @return true if a region did exist and was removed; false otherwise.
+ */
+ boolean removeRegion(Fqn fqn);
+
+ /**
+ * Gets where the cache currently is its lifecycle transitions.
+ *
+ * @return the CacheStatus. Will not return <code>null</code>.
+ */
+ CacheStatus getCacheStatus();
+
+ /**
+ * @return the current invocation context for the current invocation and cache instance.
+ * @throws IllegalStateException if the cache has been destroyed.
+ */
+ InvocationContext getInvocationContext();
+
+ /**
+ * Sets the passed in {@link org.jboss.cache.InvocationContext} as current.
+ *
+ * @param ctx invocation context to use
+ * @throws IllegalStateException if the cache has been destroyed.
+ */
+ void setInvocationContext(InvocationContext ctx);
+
+ /**
+ * Returns the local address of this cache in a cluster, or <code>null</code>
+ * if running in local mode.
+ *
+ * @return the local address of this cache in a cluster, or <code>null</code>
+ * if running in local mode.
+ */
+ Address getLocalAddress();
+
+ /**
+ * Returns a list of members in the cluster, or <code>null</code>
+ * if running in local mode.
+ *
+ * @return a {@link List} of members in the cluster, or <code>null</code>
+ * if running in local mode.
+ */
+ List<Address> getMembers();
+
+ /**
+ * Moves a part of the cache to a different subtree.
+ * <p/>
+ * E.g.:
+ * <p/>
+ * assume a cache structure such as:
+ * <p/>
+ * <pre>
+ * /a/b/c
+ * /a/b/d
+ * /a/b/e
+ * <p/>
+ * <p/>
+ * Fqn f1 = Fqn.fromString("/a/b/c");
+ * Fqn f2 = Fqn.fromString("/a/b/d");
+ * <p/>
+ * cache.move(f1, f2);
+ * </pre>
+ * <p/>
+ * Will result in:
+ * <pre>
+ * <p/>
+ * /a/b/d/c
+ * /a/b/e
+ * <p/>
+ * </pre>
+ * <p/>
+ * and now
+ * <p/>
+ * <pre>
+ * Fqn f3 = Fqn.fromString("/a/b/e");
+ * Fqn f4 = Fqn.fromString("/a");
+ * cache.move(f3, f4);
+ * </pre>
+ * <p/>
+ * will result in:
+ * <pre>
+ * /a/b/d/c
+ * /a/e
+ * </pre>
+ * No-op if the node to be moved is the root node.
+ * <p/>
+ * <b>Note</b>: As of 3.0.0 and when using MVCC locking, more specific behaviour is defined as follows:
+ * <ul>
+ * <li>A no-op if the node is moved unto itself. E.g., <tt>move(fqn, fqn.getParent())</tt> will not do anything.</li>
+ * <li>If a target node does not exist it will be created silently, to be more consistent with other APIs such as <tt>put()</tt> on a nonexistent node.</li>
+ * <li>If the source node does not exist this is a no-op, to be more consistent with other APIs such as <tt>get()</tt> on a nonexistent node.</li>
+ * </ul>
+ *
+ * @param nodeToMove the Fqn of the node to move.
+ * @param newParent new location under which to attach the node being moved.
+ * @throws NodeNotExistsException may throw one of these if the target node does not exist or if a different thread has moved this node elsewhere already.
+ * @throws IllegalStateException if {@link #getCacheStatus()} would not return {@link CacheStatus#STARTED}.
+ */
+ void move(Fqn nodeToMove, Fqn newParent) throws NodeNotExistsException;
+
+ /**
+ * Convenience method that takes in string representations of Fqns. Otherwise identical to {@link #move(Fqn, Fqn)}
+ *
+ * @throws IllegalStateException if {@link #getCacheStatus()} would not return {@link CacheStatus#STARTED}.
+ */
+ void move(String nodeToMove, String newParent) throws NodeNotExistsException;
+
+ /**
+ * Returns the version of the cache as a string.
+ *
+ * @return the version string of the cache.
+ * @see Version#printVersion
+ */
+ String getVersion();
+
+ /**
+ * Retrieves a defensively copied data map of the underlying node. A convenience method to retrieving a node and
+ * getting data from the node directly.
+ *
+ * @param fqn
+ * @return map of data, or an empty map
+ * @throws CacheException
+ * @throws IllegalStateException if {@link #getCacheStatus()} would not return {@link CacheStatus#STARTED}.
+ */
+ Map<K, V> getData(Fqn fqn);
+
+ /**
+ * Convenience method that takes in a String represenation of the Fqn. Otherwise identical to {@link #getKeys(Fqn)}.
+ */
+ Set<K> getKeys(String fqn);
+
+ /**
+ * Returns a set of attribute keys for the Fqn.
+ * Returns null if the node is not found, otherwise a Set.
+ * The set is a copy of the actual keys for this node.
+ * <p/>
+ * A convenience method to retrieving a node and
+ * getting keys from the node directly.
+ *
+ * @param fqn name of the node
+ * @throws IllegalStateException if {@link #getCacheStatus()} would not return {@link CacheStatus#STARTED}.
+ */
+ Set<K> getKeys(Fqn fqn);
+
+ /**
+ * Convenience method that takes in a String represenation of the Fqn. Otherwise identical to {@link #clearData(Fqn)}.
+ *
+ * @throws IllegalStateException if {@link #getCacheStatus()} would not return {@link CacheStatus#STARTED}.
+ */
+ void clearData(String fqn);
+
+ /**
+ * Removes the keys and properties from a named node.
+ * <p/>
+ * A convenience method to retrieving a node and
+ * getting keys from the node directly.
+ *
+ * @param fqn name of the node
+ * @throws IllegalStateException if {@link #getCacheStatus()} would not return {@link CacheStatus#STARTED}.
+ */
+ void clearData(Fqn fqn);
+
+ /**
+ * Starts a batch. This is a lightweight batching mechanism that groups cache writes together and finally performs the
+ * write, persistence and/or replication when {@link #endBatch(boolean)} is called rather than for each invocation on the
+ * cache.
+ * <p/>
+ * Note that if there is an existing transaction in scope and the cache has been configured to use a JTA compliant
+ * transaction manager, calls to {@link #startBatch()} and {@link #endBatch(boolean)} are ignored and treated as no-ops.
+ * <p/>
+ *
+ * @see #endBatch(boolean)
+ * @since 3.0
+ */
+ void startBatch();
+
+ /**
+ * Ends an existing ongoing batch. A no-op if a batch has not been started yet.
+ * <p/>
+ * Note that if there is an existing transaction in scope and the cache has been configured to use a JTA compliant
+ * transaction manager, calls to {@link #startBatch()} and {@link #endBatch(boolean)} are ignored and treated as no-ops.
+ * <p/>
+ *
+ * @param successful if <tt>true</tt>, changes made in the batch are committed. If <tt>false</tt>, they are discarded.
+ * @see #startBatch()
+ * @since 3.0
+ */
+ void endBatch(boolean successful);
+
+ /**
+ * Adds a custom interceptor to the interceptor chain, at specified position, where the first interceptor in the chain
+ * is at position 0 and the last one at getInterceptorChain().size() - 1.
+ *
+ * @param i the interceptor to add
+ * @param position the position to add the interceptor
+ * @since 3.0
+ */
+ void addInterceptor(CommandInterceptor i, int position);
+
+ /**
+ * Adds a custom interceptor to the interceptor chain, after an instance of the specified interceptor type. Throws a
+ * cache exception if it cannot find an interceptor of the specified type.
+ *
+ * @param i interceptor to add
+ * @param afterInterceptor interceptor type after which to place custom interceptor
+ * @since 3.0
+ */
+ void addInterceptor(CommandInterceptor i, Class<? extends CommandInterceptor> afterInterceptor);
+
+ /**
+ * Removes the interceptor at a specified position, where the first interceptor in the chain
+ * is at position 0 and the last one at getInterceptorChain().size() - 1.
+ *
+ * @param position the position at which to remove an interceptor
+ * @since 3.0
+ */
+ void removeInterceptor(int position);
+
+ /**
+ * Removes the interceptor of specified type.
+ *
+ * @param interceptorType type of interceptor to remove
+ * @since 3.0
+ */
+ void removeInterceptor(Class<? extends CommandInterceptor> interceptorType);
+
+ Configuration getConfiguration();
+
+ Cache getCache();
+
+ boolean exists(String fqn);
+
+ boolean exists(Fqn fqn);
+}
Added: core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCacheImpl.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCacheImpl.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeCacheImpl.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,379 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.tree;
+
+import org.jboss.cache.CacheStatus;
+import org.jboss.cache.NodeNotExistsException;
+import org.jboss.cache.Region;
+import org.jboss.starobrno.Cache;
+import org.jboss.starobrno.CacheException;
+import org.jboss.starobrno.config.Configuration;
+import org.jboss.starobrno.context.InvocationContext;
+import org.jboss.starobrno.interceptors.base.CommandInterceptor;
+import org.jgroups.Address;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author Manik Surtani (<a href="mailto:manik AT jboss DOT org">manik AT jboss DOT org</a>)
+ */
+public class TreeCacheImpl<K, V> extends TreeStructureSupport implements TreeCache<K, V>
+{
+ public TreeCacheImpl(Cache<K, V> cache)
+ {
+ super(new ThreadLocal<Boolean>()
+ {
+ @Override
+ protected Boolean initialValue()
+ {
+ return false;
+ }
+ }, cache);
+ createRoot();
+ }
+
+ public Node<K, V> getRoot()
+ {
+ return new NodeImpl(Fqn.ROOT, cache, batchStarted);
+ }
+
+ public V put(String fqn, K key, V value)
+ {
+ return put(Fqn.fromString(fqn), key, value);
+ }
+
+ public void putForExternalRead(Fqn fqn, K key, V value)
+ {
+ put(fqn, key, value); // TODO implement this properly
+ }
+
+ public void put(Fqn fqn, Map<? extends K, ? extends V> data)
+ {
+ startAtomic();
+ try
+ {
+ getNode(fqn).putAll(data);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public void put(String fqn, Map<? extends K, ? extends V> data)
+ {
+ put(Fqn.fromString(fqn), data);
+ }
+
+ public V remove(Fqn fqn, K key)
+ {
+ startAtomic();
+ try
+ {
+ return getNode(fqn).remove(key);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public V remove(String fqn, K key)
+ {
+ return remove(Fqn.fromString(fqn), key);
+ }
+
+ public boolean removeNode(Fqn fqn)
+ {
+ if (fqn.isRoot()) return false;
+ startAtomic();
+ try
+ {
+ Node n = getNode(fqn.getParent());
+ return n == null ? false : n.removeChild(fqn.getLastElement());
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public boolean removeNode(String fqn)
+ {
+ return removeNode(Fqn.fromString(fqn));
+ }
+
+ public Node<K, V> getNode(Fqn fqn)
+ {
+ startAtomic();
+ try
+ {
+ if (exists(fqn))
+ return new NodeImpl(fqn, cache, batchStarted);
+ else return null;
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public Node<K, V> getNode(String fqn)
+ {
+ return getNode(Fqn.fromString(fqn));
+ }
+
+ public V get(Fqn fqn, K key)
+ {
+ startAtomic();
+ try
+ {
+ Node n = getNode(fqn);
+
+ return (V) (n == null ? null : n.get(key));
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public boolean exists(String f)
+ {
+ return exists(Fqn.fromString(f));
+ }
+
+ public V get(String fqn, K key)
+ {
+ return get(Fqn.fromString(fqn), key);
+ }
+
+ public void evict(Fqn fqn, boolean recursive)
+ {
+ //TODO: Autogenerated. Implement me properly
+ }
+
+ public void evict(Fqn fqn)
+ {
+ startAtomic();
+ try
+ {
+ getNode(fqn).evict();
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public Region getRegion(Fqn fqn, boolean createIfAbsent)
+ {
+ return null; //TODO: Autogenerated. Implement me properly
+ }
+
+ public boolean removeRegion(Fqn fqn)
+ {
+ return false; //TODO: Autogenerated. Implement me properly
+ }
+
+ public void move(Fqn nodeToMove, Fqn newParent) throws NodeNotExistsException
+ {
+ //TODO: Autogenerated. Implement me properly
+ }
+
+ public void move(String nodeToMove, String newParent) throws NodeNotExistsException
+ {
+ move(Fqn.fromString(nodeToMove), Fqn.fromString(newParent));
+ }
+
+ public Map<K, V> getData(Fqn fqn)
+ {
+ startAtomic();
+ try
+ {
+ return getNode(fqn).getData();
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public Set<K> getKeys(String fqn)
+ {
+ return getKeys(Fqn.fromString(fqn));
+ }
+
+ public Set<K> getKeys(Fqn fqn)
+ {
+ startAtomic();
+ try
+ {
+ return getNode(fqn).getKeys();
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public void clearData(String fqn)
+ {
+ clearData(Fqn.fromString(fqn));
+ }
+
+ public void clearData(Fqn fqn)
+ {
+ startAtomic();
+ try
+ {
+ getNode(fqn).clearData();
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ public V put(Fqn fqn, K key, V value)
+ {
+ startAtomic();
+ try
+ {
+ createNodeInCache(fqn);
+ return getNode(fqn).put(key, value);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ // ------------------ nothing different; just delegate to the cache
+ public void addCacheListener(Object listener)
+ {
+ cache.addCacheListener(listener);
+ }
+
+ public void removeCacheListener(Object listener)
+ {
+ cache.removeCacheListener(listener);
+ }
+
+ public Set<Object> getCacheListeners()
+ {
+ return cache.getCacheListeners();
+ }
+
+ public void startBatch()
+ {
+ cache.startBatch();
+ }
+
+ public void endBatch(boolean successful)
+ {
+ cache.endBatch(successful);
+ }
+
+ public void addInterceptor(CommandInterceptor i, int position)
+ {
+ cache.addInterceptor(i, position);
+ }
+
+ public void addInterceptor(CommandInterceptor i, Class<? extends CommandInterceptor> afterInterceptor)
+ {
+ cache.addInterceptor(i, afterInterceptor);
+ }
+
+ public void removeInterceptor(int position)
+ {
+ cache.removeInterceptor(position);
+ }
+
+ public void removeInterceptor(Class<? extends CommandInterceptor> interceptorType)
+ {
+ cache.removeInterceptor(interceptorType);
+ }
+
+ public Configuration getConfiguration()
+ {
+ return cache.getConfiguration();
+ }
+
+ public Cache getCache()
+ {
+ return cache;
+ }
+
+ public String getVersion()
+ {
+ return cache.getVersion();
+ }
+
+ public CacheStatus getCacheStatus()
+ {
+ return cache.getCacheStatus();
+ }
+
+ public InvocationContext getInvocationContext()
+ {
+ return cache.getInvocationContext();
+ }
+
+ public void setInvocationContext(InvocationContext ctx)
+ {
+ cache.setInvocationContext(ctx);
+ }
+
+ public Address getLocalAddress()
+ {
+ return cache.getLocalAddress();
+ }
+
+ public List<Address> getMembers()
+ {
+ return cache.getMembers();
+ }
+
+ public void start() throws CacheException
+ {
+ cache.start();
+ createRoot();
+ }
+
+ public void stop()
+ {
+ cache.stop();
+ }
+
+ private void createRoot()
+ {
+ createNodeInCache(Fqn.ROOT);
+ }
+
+ public String toString()
+ {
+ return cache.toString();
+ }
+}
Added: core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeStructureSupport.java
===================================================================
--- core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeStructureSupport.java (rev 0)
+++ core/branches/flat/src/main/java/org/jboss/starobrno/tree/TreeStructureSupport.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,161 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.starobrno.tree;
+
+import org.jboss.starobrno.Cache;
+import org.jboss.starobrno.util.Util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class TreeStructureSupport
+{
+ ThreadLocal<Boolean> batchStarted;
+ Cache cache;
+ boolean batchOwner;
+
+ public TreeStructureSupport(ThreadLocal<Boolean> batchStarted, Cache cache)
+ {
+ this.batchStarted = batchStarted;
+ this.cache = cache;
+ }
+
+ void startAtomic()
+ {
+ if (!batchStarted.get())
+ {
+ cache.startBatch();
+ batchStarted.set(true);
+ batchOwner = true;
+ }
+ }
+
+ void endAtomic()
+ {
+ if (batchOwner)
+ {
+ cache.endBatch(true);
+ batchStarted.set(false);
+ }
+ }
+
+ public boolean exists(Fqn f)
+ {
+ startAtomic();
+ try
+ {
+ return cache.containsKey(new Key(f, Type.DATA)) && cache.containsKey(new Key(f, Type.STRUCTURE));
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ void createNodeInCache(Fqn fqn)
+ {
+ startAtomic();
+ try
+ {
+ Fqn parent = fqn.getParent();
+ if (!fqn.isRoot())
+ {
+ if (!exists(parent)) createNodeInCache(parent);
+ Structure parentStructure = getStructure(parent);
+ parentStructure.children.put(fqn.getLastElement(), fqn);
+ updateStructure(parent, parentStructure);
+ }
+ Key dataKey = new Key(fqn, Type.DATA);
+ Key structureKey = new Key(fqn, Type.STRUCTURE);
+ if (cache.containsKey(dataKey) && cache.containsKey(structureKey)) return;
+ Structure s = new Structure();
+ s.parent = fqn.getParent();
+ cache.put(dataKey, new HashMap());
+ cache.put(structureKey, s);
+ }
+ finally
+ {
+ endAtomic();
+ }
+ }
+
+ enum Type
+ {
+ DATA, STRUCTURE
+ }
+
+ static class Key
+ {
+ Type contents;
+ Fqn fqn;
+
+ Key(Fqn fqn, Type contents)
+ {
+ this.contents = contents;
+ this.fqn = fqn;
+ }
+
+ public boolean equals(Object o)
+ {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ Key key = (Key) o;
+
+ if (contents != key.contents) return false;
+ if (!Util.safeEquals(fqn, key.fqn)) return false;
+
+ return true;
+ }
+
+ public int hashCode()
+ {
+ int hc = (contents != null ? contents.hashCode() : 1);
+ hc = 31 * hc + fqn.hashCode();
+ return hc;
+ }
+
+ public String toString()
+ {
+ return "Key{" +
+ "contents=" + contents +
+ ", fqn=" + fqn +
+ '}';
+ }
+ }
+
+ static class Structure
+ {
+ Map<Object, Fqn> children = new HashMap<Object, Fqn>();
+ Fqn parent;
+ }
+
+ Structure getStructure(Fqn fqn)
+ {
+ return (Structure) cache.get(new Key(fqn, Type.STRUCTURE));
+ }
+
+ void updateStructure(Fqn fqn, Structure s)
+ {
+ cache.put(new Key(fqn, Type.STRUCTURE), s);
+ }
+}
Added: core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/NodeAPITest.java
===================================================================
--- core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/NodeAPITest.java (rev 0)
+++ core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/NodeAPITest.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,391 @@
+package org.jboss.cache.api;
+
+import org.jboss.starobrno.CacheSPI;
+import org.jboss.starobrno.UnitTestCacheFactory;
+import org.jboss.starobrno.tree.Fqn;
+import org.jboss.starobrno.tree.Node;
+import org.jboss.starobrno.tree.TreeCache;
+import org.jboss.starobrno.tree.TreeCacheImpl;
+import org.jboss.starobrno.util.TestingUtil;
+import static org.testng.AssertJUnit.*;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import javax.transaction.TransactionManager;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Tests {@link org.jboss.cache.Node}-centric operations
+ *
+ * @author <a href="mailto:manik AT jboss DOT org">Manik Surtani</a>
+ * @since 2.0.0
+ */
+@Test(groups = {"functional", "pessimistic"})
+public class NodeAPITest
+{
+ protected ThreadLocal<TreeCache<Object, Object>> cacheTL = new ThreadLocal<TreeCache<Object, Object>>();
+ protected static final Fqn A = Fqn.fromString("/a"), B = Fqn.fromString("/b"), C = Fqn.fromString("/c"), D = Fqn.fromString("/d");
+ protected Fqn A_B = Fqn.fromRelativeFqn(A, B);
+ protected Fqn A_C = Fqn.fromRelativeFqn(A, C);
+ protected TransactionManager tm;
+
+ @BeforeMethod(alwaysRun = true)
+ public void setUp() throws Exception
+ {
+ // start a single cache instance
+ CacheSPI<Object, Object> cache = (CacheSPI<Object, Object>) new UnitTestCacheFactory<Object, Object>().createCache("configs/local-tx.xml", false);
+ cache.getConfiguration().setInvocationBatchingEnabled(true);
+ cache.start();
+ cacheTL.set(new TreeCacheImpl(cache));
+ tm = cache.getTransactionManager();
+ }
+
+ @AfterMethod(alwaysRun = true)
+ public void tearDown()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ TestingUtil.killCaches(cache.getCache());
+ cacheTL.set(null);
+ }
+
+ public void testAddingData()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+ Node<Object, Object> nodeA = rootNode.addChild(A);
+ nodeA.put("key", "value");
+
+ assertEquals("value", nodeA.get("key"));
+ }
+
+ public void testAddingDataTx() throws Exception
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+ tm.begin();
+ Node<Object, Object> nodeA = rootNode.addChild(A);
+ nodeA.put("key", "value");
+
+ assertEquals("value", nodeA.get("key"));
+ tm.commit();
+ }
+
+ public void testOverwritingDataTx() throws Exception
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ Node<Object, Object> nodeA = rootNode.addChild(A);
+ nodeA.put("key", "value");
+ assertEquals("value", nodeA.get("key"));
+ tm.begin();
+ rootNode.removeChild(A);
+ cache.put(A, "k2", "v2");
+ tm.commit();
+ assertNull(nodeA.get("key"));
+ assertEquals("v2", nodeA.get("k2"));
+ }
+
+
+ /**
+ * Remember, Fqns are relative!!
+ */
+ public void testParentsAndChildren()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ Node<Object, Object> nodeA = rootNode.addChild(A);
+ Node<Object, Object> nodeB = nodeA.addChild(B);
+ Node<Object, Object> nodeC = nodeA.addChild(C);
+ Node<Object, Object> nodeD = rootNode.addChild(D);
+
+ assertEquals(rootNode, nodeA.getParent());
+ assertEquals(nodeA, nodeB.getParent());
+ assertEquals(nodeA, nodeC.getParent());
+ assertEquals(rootNode, nodeD.getParent());
+
+ assertTrue(rootNode.hasChild(A));
+ assertFalse(rootNode.hasChild(B));
+ assertFalse(rootNode.hasChild(C));
+ assertTrue(rootNode.hasChild(D));
+
+ assertTrue(nodeA.hasChild(B));
+ assertTrue(nodeA.hasChild(C));
+
+ assertEquals(nodeA, rootNode.getChild(A));
+ assertEquals(nodeD, rootNode.getChild(D));
+ assertEquals(nodeB, nodeA.getChild(B));
+ assertEquals(nodeC, nodeA.getChild(C));
+
+ assertTrue(nodeA.getChildren().contains(nodeB));
+ assertTrue(nodeA.getChildren().contains(nodeC));
+ assertEquals(2, nodeA.getChildren().size());
+
+ assertTrue(rootNode.getChildren().contains(nodeA));
+ assertTrue(rootNode.getChildren().contains(nodeD));
+ assertEquals(2, rootNode.getChildren().size());
+
+ assertEquals(true, rootNode.removeChild(A));
+ assertFalse(rootNode.getChildren().contains(nodeA));
+ assertTrue(rootNode.getChildren().contains(nodeD));
+ assertEquals(1, rootNode.getChildren().size());
+
+ assertEquals("double remove", false, rootNode.removeChild(A));
+ assertEquals("double remove", false, rootNode.removeChild(A.getLastElement()));
+ }
+
+
+ public void testImmutabilityOfData()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ rootNode.put("key", "value");
+ Map<Object, Object> m = rootNode.getData();
+ try
+ {
+ m.put("x", "y");
+ fail("Map should be immutable!!");
+ }
+ catch (Exception e)
+ {
+ // expected
+ }
+
+ try
+ {
+ rootNode.getKeys().add(new Object());
+ fail("Key set should be immutable");
+ }
+ catch (Exception e)
+ {
+ // expected
+ }
+ }
+
+ public void testDefensiveCopyOfData()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ rootNode.put("key", "value");
+ Map<Object, Object> data = rootNode.getData();
+ Set<Object> keys = rootNode.getKeys();
+
+ assert keys.size() == 1;
+ assert keys.contains("key");
+
+ assert data.size() == 1;
+ assert data.containsKey("key");
+
+ // now change stuff.
+
+ rootNode.put("key2", "value2");
+
+ // assert that the collections we initially got have not changed.
+ assert keys.size() == 1;
+ assert keys.contains("key");
+
+ assert data.size() == 1;
+ assert data.containsKey("key");
+ }
+
+ public void testDefensiveCopyOfChildren()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ Fqn childFqn = Fqn.fromString("/child");
+ rootNode.addChild(childFqn).put("k", "v");
+ Set<Node<Object, Object>> children = rootNode.getChildren();
+ Set<Object> childrenNames = rootNode.getChildrenNames();
+
+ assert childrenNames.size() == 1;
+ assert childrenNames.contains(childFqn.getLastElement());
+
+ assert children.size() == 1;
+ assert children.iterator().next().getFqn().equals(childFqn);
+
+ // now change stuff.
+
+ rootNode.addChild(Fqn.fromString("/child2"));
+
+ // assert that the collections we initially got have not changed.
+ assert childrenNames.size() == 1;
+ assert childrenNames.contains(childFqn.getLastElement());
+
+ assert children.size() == 1;
+ assert children.iterator().next().getFqn().equals(childFqn);
+ }
+
+
+ public void testImmutabilityOfChildren()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ rootNode.addChild(A);
+
+ try
+ {
+ rootNode.getChildren().clear();
+ fail("Collection of child nodes returned in getChildren() should be immutable");
+ }
+ catch (Exception e)
+ {
+ // expected
+ }
+ }
+
+ public void testGetChildAPI()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ // creates a Node<Object, Object> with fqn /a/b/c
+ Node childA = rootNode.addChild(A);
+ childA.addChild(B).addChild(C);
+
+ rootNode.getChild(A).put("key", "value");
+ rootNode.getChild(A).getChild(B).put("key", "value");
+ rootNode.getChild(A).getChild(B).getChild(C).put("key", "value");
+
+ assertEquals("value", rootNode.getChild(A).get("key"));
+ assertEquals("value", rootNode.getChild(A).getChild(B).get("key"));
+ assertEquals("value", rootNode.getChild(A).getChild(B).getChild(C).get("key"));
+
+ assertNull(rootNode.getChild(Fqn.fromElements("nonexistent")));
+ }
+
+ public void testClearingData()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ rootNode.put("k", "v");
+ rootNode.put("k2", "v2");
+ assertEquals(2, rootNode.getKeys().size());
+ rootNode.clearData();
+ assertEquals(0, rootNode.getKeys().size());
+ assertTrue(rootNode.getData().isEmpty());
+ }
+
+ public void testClearingDataTx() throws Exception
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ tm.begin();
+ rootNode.put("k", "v");
+ rootNode.put("k2", "v2");
+ assertEquals(2, rootNode.getKeys().size());
+ rootNode.clearData();
+ assertEquals(0, rootNode.getKeys().size());
+ assertTrue(rootNode.getData().isEmpty());
+ tm.commit();
+ assertTrue(rootNode.getData().isEmpty());
+ }
+
+ public void testPutData()
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ assertTrue(rootNode.getData().isEmpty());
+
+ Map<Object, Object> map = new HashMap<Object, Object>();
+ map.put("k1", "v1");
+ map.put("k2", "v2");
+
+ rootNode.putAll(map);
+
+ assertEquals(2, rootNode.getData().size());
+ assertEquals("v1", rootNode.get("k1"));
+ assertEquals("v2", rootNode.get("k2"));
+
+ map.clear();
+ map.put("k3", "v3");
+
+ rootNode.putAll(map);
+ assertEquals(3, rootNode.getData().size());
+ assertEquals("v1", rootNode.get("k1"));
+ assertEquals("v2", rootNode.get("k2"));
+ assertEquals("v3", rootNode.get("k3"));
+
+ map.clear();
+ map.put("k4", "v4");
+ map.put("k5", "v5");
+
+ rootNode.replaceAll(map);
+ assertEquals(2, rootNode.getData().size());
+ assertEquals("v4", rootNode.get("k4"));
+ assertEquals("v5", rootNode.get("k5"));
+ }
+
+ public void testGetChildrenNames() throws Exception
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+ Node<Object, Object> rootNode = cache.getRoot();
+
+ rootNode.addChild(A).put("k", "v");
+ rootNode.addChild(B).put("k", "v");
+
+ Set<Object> childrenNames = new HashSet<Object>();
+ childrenNames.add(A.getLastElement());
+ childrenNames.add(B.getLastElement());
+
+ assertEquals(childrenNames, rootNode.getChildrenNames());
+
+ // now delete a child, within a tx
+ tm.begin();
+ rootNode.removeChild(B);
+ assertFalse(rootNode.hasChild(B));
+ childrenNames.remove(B.getLastElement());
+ assertEquals(childrenNames, rootNode.getChildrenNames());
+ tm.commit();
+ assertEquals(childrenNames, rootNode.getChildrenNames());
+ }
+
+ public void testDoubleRemovalOfData() throws Exception
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+
+ cache.put("/foo/1/2/3", "item", 1);
+ assert 1 == (Integer) cache.get("/foo/1/2/3", "item");
+ tm.begin();
+ assert 1 == (Integer) cache.get("/foo/1/2/3", "item");
+ cache.removeNode("/foo/1");
+ assertNull(cache.getNode("/foo/1"));
+ assertNull(cache.get("/foo/1", "item"));
+ cache.removeNode("/foo/1/2/3");
+ System.out.println("Cache: " + cache);
+ assertNull(cache.get("/foo/1/2/3", "item"));
+ assertNull(cache.get("/foo/1", "item"));
+ tm.commit();
+ assertFalse(cache.exists("/foo/1"));
+ assertNull(cache.get("/foo/1/2/3", "item"));
+ assertNull(cache.get("/foo/1", "item"));
+ }
+
+ public void testDoubleRemovalOfData2() throws Exception
+ {
+ TreeCache<Object, Object> cache = cacheTL.get();
+
+ cache.put("/foo/1/2", "item", 1);
+ tm.begin();
+ assertEquals(cache.get("/foo/1", "item"), null);
+ cache.removeNode("/foo/1");
+ assertNull(cache.get("/foo/1", "item"));
+ cache.removeNode("/foo/1/2");
+ assertNull(cache.get("/foo/1", "item"));
+ tm.commit();
+ assertFalse(cache.exists("/foo/1"));
+ assertNull(cache.get("/foo/1/2", "item"));
+ assertNull(cache.get("/foo/1", "item"));
+ }
+}
Added: core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/TreeCacheAPITest.java
===================================================================
--- core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/TreeCacheAPITest.java (rev 0)
+++ core/branches/flat/src/test/java/org/jboss/starobrno/tree/api/TreeCacheAPITest.java 2008-11-06 00:31:36 UTC (rev 7089)
@@ -0,0 +1,236 @@
+package org.jboss.starobrno.tree.api;
+
+import org.jboss.starobrno.CacheSPI;
+import org.jboss.starobrno.config.Configuration;
+import org.jboss.starobrno.config.parsing.XmlConfigurationParser;
+import org.jboss.starobrno.manager.CacheManager;
+import org.jboss.starobrno.tree.Fqn;
+import org.jboss.starobrno.tree.Node;
+import org.jboss.starobrno.tree.TreeCache;
+import org.jboss.starobrno.util.TestingUtil;
+import static org.testng.AssertJUnit.*;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import javax.transaction.TransactionManager;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Tests the {@link org.jboss.cache.Cache} public API at a high level
+ *
+ * @author <a href="mailto:manik AT jboss DOT org">Manik Surtani</a>
+ */
+
+@Test(groups = {"functional", "pessimistic"}, sequential = true)
+public class TreeCacheAPITest
+{
+ private TreeCache<String, String> cache;
+ private TransactionManager tm;
+
+ @BeforeMethod(alwaysRun = true)
+ public void setUp() throws Exception
+ {
+ // start a single cache instance
+ XmlConfigurationParser parser = new XmlConfigurationParser();
+ Configuration c;
+ c = parser.parseFile("configs/local-tx.xml");
+ c.setEvictionConfig(null);
+ CacheManager cm = new CacheManager(c);
+
+ cache = cm.createTreeCache(getClass().getSimpleName());
+ tm = ((CacheSPI) cache.getCache()).getTransactionManager();
+ }
+
+ @AfterMethod(alwaysRun = true)
+ public void tearDown()
+ {
+ if (cache != null) TestingUtil.killCaches(cache.getCache());
+ cache = null;
+ }
+
+ /**
+ * All cache operations should happen on a {@link Node} - I.e., you look up a {@link Node} and perform data operations
+ * on this {@link Node}. For convenience and familiarity with JBoss Cache 1.x, we provide some helpers in {@link Cache}
+ * which dives you direct data access to nodes.
+ * <p/>
+ * This test exercises these.
+ */
+ public void testConvenienceMethods()
+ {
+ Fqn fqn = Fqn.fromString("/test/fqn");
+ String key = "key", value = "value";
+ Map<String, String> data = new HashMap<String, String>();
+ data.put(key, value);
+
+ assertNull(cache.get(fqn, key));
+
+ cache.put(fqn, key, value);
+
+ assertEquals(value, cache.get(fqn, key));
+
+ cache.remove(fqn, key);
+
+ assertNull(cache.get(fqn, key));
+
+ cache.put(fqn, data);
+
+ assertEquals(value, cache.get(fqn, key));
+ }
+
+
+ /**
+ * Another convenience method that tests node removal
+ */
+ public void testNodeConvenienceNodeRemoval()
+ {
+ // this fqn is relative, but since it is from the root it may as well be absolute
+ Fqn fqn = Fqn.fromString("/test/fqn");
+ cache.getRoot().addChild(fqn);
+ assertTrue(cache.getRoot().hasChild(fqn));
+
+ assertEquals(true, cache.removeNode(fqn));
+ assertFalse(cache.getRoot().hasChild(fqn));
+ // remove should REALLY remove though and not just mark as deleted/invalid.
+ Node n = cache.getNode(fqn);
+ assert n == null;
+
+ assertEquals(false, cache.removeNode(fqn));
+
+ // remove should REALLY remove though and not just mark as deleted/invalid.
+ n = cache.getNode(fqn);
+ assert n == null;
+
+ // Check that it's removed if it has a child
+ Fqn child = Fqn.fromString("/test/fqn/child");
+ cache.getRoot().addChild(child);
+ assertTrue(cache.getRoot().hasChild(child));
+
+ assertEquals(true, cache.removeNode(fqn));
+ assertFalse(cache.getRoot().hasChild(fqn));
+ assertEquals(false, cache.removeNode(fqn));
+ }
+
+ /**
+ * Tests basic eviction
+ */
+ public void testEvict()
+ {
+ Fqn one = Fqn.fromString("/one");
+ Fqn two = Fqn.fromString("/one/two");
+ String key = "key", value = "value";
+
+ cache.getRoot().addChild(one).put(key, value);
+ cache.getRoot().addChild(two).put(key, value);
+
+ assertTrue(cache.getRoot().hasChild(one));
+ assertFalse(cache.getRoot().getChild(one).getData().isEmpty());
+ assertTrue(cache.getRoot().hasChild(two));
+ assertFalse(cache.getRoot().getChild(two).getData().isEmpty());
+
+ // evict two
+ cache.evict(two, false);
+
+ assertTrue(cache.getRoot().hasChild(one));
+ assertTrue(cache.getRoot().getChild(one).getKeys().contains(key));
+ assertFalse(cache.getRoot().hasChild(two));
+
+ // now add 2 again...
+ cache.getRoot().addChild(two).put(key, value);
+
+ // now evict one, NOT recursive
+ cache.evict(one, false);
+
+ // one will NOT be removed, just emptied.
+ assertTrue(cache.getRoot().hasChild(one));
+ assertFalse(cache.getRoot().getChild(one).getKeys().contains(key));
+
+ // two will be unaffected
+ assertTrue(cache.getRoot().hasChild(two));
+ assertTrue(cache.getRoot().getChild(two).getKeys().contains(key));
+ }
+
+
+ /**
+ * Tests recursive eviction
+ */
+ public void testEvictRecursive()
+ {
+ Fqn one = Fqn.fromString("/one");
+ Fqn two = Fqn.fromString("/one/two");
+ String key = "key", value = "value";
+
+ cache.getRoot().addChild(one).put(key, value);
+ cache.getRoot().addChild(two).put(key, value);
+
+ assertTrue(cache.getRoot().hasChild(one));
+ assertFalse(cache.getRoot().getChild(one).getData().isEmpty());
+ assertTrue(cache.getRoot().hasChild(two));
+ assertFalse(cache.getRoot().getChild(two).getData().isEmpty());
+
+ // evict two
+ cache.evict(two, true);
+
+ assertTrue(cache.getRoot().hasChild(one));
+ assertFalse(cache.getRoot().getChild(one).getData().isEmpty());
+ assertFalse(cache.getRoot().hasChild(two));
+
+ // now add 2 again...
+ cache.getRoot().addChild(two).put(key, value);
+
+ // now evict one, recursive
+ cache.evict(one, true);
+
+ assertFalse(cache.getRoot().hasChild(one));
+ assertFalse(cache.getRoot().hasChild(two));
+ }
+
+ public void testStopClearsData() throws Exception
+ {
+ Fqn a = Fqn.fromString("/a");
+ Fqn b = Fqn.fromString("/a/b");
+ String key = "key", value = "value";
+ cache.getRoot().addChild(a).put(key, value);
+ cache.getRoot().addChild(b).put(key, value);
+ cache.getRoot().put(key, value);
+
+ assertEquals(value, cache.getRoot().get(key));
+ assertEquals(value, cache.getRoot().getChild(a).get(key));
+ assertEquals(value, cache.getRoot().getChild(b).get(key));
+
+ cache.stop();
+
+ cache.start();
+
+ assertNull(cache.getRoot().get(key));
+ assertTrue(cache.getRoot().getData().isEmpty());
+ assertTrue(cache.getRoot().getChildren().isEmpty());
+ }
+
+ public void testPhantomStructuralNodesOnRemove()
+ {
+ assert cache.getNode(Fqn.fromString("/a/b/c")) == null;
+ assert !cache.removeNode("/a/b/c");
+ assert cache.getNode(Fqn.fromString("/a/b/c")) == null;
+ assert cache.getNode(Fqn.fromString("/a/b")) == null;
+ assert cache.getNode(Fqn.fromString("/a")) == null;
+ }
+
+ public void testPhantomStructuralNodesOnRemoveTransactional() throws Exception
+ {
+ assert cache.getNode(Fqn.fromString("/a/b/c")) == null;
+ tm.begin();
+ assert !cache.removeNode("/a/b/c");
+ tm.commit();
+ assert cache.getNode(Fqn.fromString("/a/b/c")) == null;
+ assert cache.getNode(Fqn.fromString("/a/b")) == null;
+ assert cache.getNode(Fqn.fromString("/a")) == null;
+ }
+
+ public void testRpcManagerElements()
+ {
+ assertEquals("CacheMode.LOCAL cache has no address", null, cache.getLocalAddress());
+ assertEquals("CacheMode.LOCAL cache has no members list", null, cache.getMembers());
+ }
+}
Modified: core/branches/flat/src/test/resources/configs/local-tx.xml
===================================================================
--- core/branches/flat/src/test/resources/configs/local-tx.xml 2008-11-05 20:34:07 UTC (rev 7088)
+++ core/branches/flat/src/test/resources/configs/local-tx.xml 2008-11-06 00:31:36 UTC (rev 7089)
@@ -7,18 +7,4 @@
<serialization useRegionBasedMarshalling="false"/>
<stateRetrieval timeout="20000"/>
<transport clusterName="JBossCache-Cluster"/>
- <eviction wakeUpInterval="5000">
- <default algorithmClass="org.jboss.starobrno.eviction.algorithms.lru.LRUAlgorithm" eventQueueSize="200000">
- <attribute name="maxNodes">5000</attribute>
- <attribute name="timeToLive">1000000</attribute>
- </default>
- <region name="/org/jboss/data">
- <attribute name="maxNodes">5000</attribute>
- <attribute name="timeToLive">1000000</attribute>
- </region>
- <region name="/org/jboss/test/data">
- <attribute name="maxNodes">5</attribute>
- <attribute name="timeToLive">4000</attribute>
- </region>
- </eviction>
</jbosscache>
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7088 - core/trunk/src/main/java/org/jboss/cache/interceptors.
by jbosscache-commits＠lists.jboss.org
Author: genman
Date: 2008-11-05 15:34:07 -0500 (Wed, 05 Nov 2008)
New Revision: 7088
Modified:
core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java
Log:
JBCACHE-1439
Fix CacheLoaderInterceptor calls both CacheLoader.exist() and get() for every load
Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java 2008-11-05 19:01:32 UTC (rev 7087)
+++ core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java 2008-11-05 20:34:07 UTC (rev 7088)
@@ -283,10 +283,22 @@
if (isNew && n != null) n.setDataLoaded(false);
}
+ // This is really convoluted
if (n == null || !n.isDeleted())
{
- if (n == null && loader.exists(fqn))
+ boolean exists;
+ Map nodeData = null;
+ if (bypassLoadingData)
{
+ exists = loader.exists(fqn);
+ }
+ else
+ {
+ nodeData = loadData(fqn);
+ exists = nodeData != null;
+ }
+ if (n == null && exists)
+ {
// just create a dummy node in memory
n = helper.wrapNodeForWriting(ctx, fqn, true, true, true, false, false);
n.setDataLoaded(false);
@@ -295,9 +307,9 @@
{
this.cacheMisses++;
}
- if (!bypassLoadingData && n != null)
+ if (nodeData != null && n != null)
{
- n = loadNode(ctx, fqn, n);
+ setNodeState(ctx, fqn, n, nodeData);
}
}
}
@@ -428,14 +440,11 @@
* If it doesn't exist on disk but in memory, clears the
* uninitialized flag, otherwise returns null.
*/
- private NodeSPI loadNode(InvocationContext ctx, Fqn fqn, NodeSPI n) throws Exception
+ private void setNodeState(InvocationContext ctx, Fqn fqn, NodeSPI n, Map nodeData) throws Exception
{
- if (trace) log.trace("loadNode " + fqn + " node is " + n);
- Map nodeData = loadData(fqn);
+ if (trace) log.trace("setNodeState node is " + n);
if (nodeData != null)
{
- if (trace) log.trace("Node data is not null, loading");
-
notifier.notifyNodeLoaded(fqn, true, Collections.emptyMap(), ctx);
if (isActivation)
{
@@ -445,7 +454,7 @@
n.setInternalState(nodeData);
// set this node as valid?
-// if (usingVersionedInvalidation) n.setValid(true, false);
+ // if (usingVersionedInvalidation) n.setValid(true, false);
n.setValid(true, false);
notifier.notifyNodeLoaded(fqn, false, nodeData, ctx);
@@ -454,12 +463,11 @@
notifier.notifyNodeActivated(fqn, false, nodeData, ctx);
}
}
- if (n != null && !n.isDataLoaded())
+ if (!n.isDataLoaded())
{
if (trace) log.trace("Setting dataLoaded to true");
n.setDataLoaded(true);
}
- return n;
}
private Map loadData(Fqn fqn) throws Exception
@@ -496,6 +504,7 @@
}
@ManagedOperation
+ @Override
public void resetStatistics()
{
cacheLoads = 0;
@@ -503,6 +512,7 @@
}
@ManagedOperation
+ @Override
public Map<String, Object> dumpStatistics()
{
Map<String, Object> retval = new HashMap<String, Object>();
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7087 - core/trunk/src/main/java/org/jboss/cache/loader.
by jbosscache-commits＠lists.jboss.org
Author: genman
Date: 2008-11-05 14:01:32 -0500 (Wed, 05 Nov 2008)
New Revision: 7087
Modified:
core/trunk/src/main/java/org/jboss/cache/loader/AsyncCacheLoader.java
Log:
Related to JBCACHE-1438
Make one phase commit operation work the same as an async put
Modified: core/trunk/src/main/java/org/jboss/cache/loader/AsyncCacheLoader.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/loader/AsyncCacheLoader.java 2008-11-05 18:39:35 UTC (rev 7086)
+++ core/trunk/src/main/java/org/jboss/cache/loader/AsyncCacheLoader.java 2008-11-05 19:01:32 UTC (rev 7087)
@@ -187,7 +187,46 @@
return null;
}
+ /**
+ * TODO this is the same as the AbstractCacheLoader.
+ */
@Override
+ public void prepare(Object tx, List<Modification> modifications, boolean one_phase) throws Exception
+ {
+ if (one_phase)
+ {
+ put(modifications);
+ }
+ else
+ {
+ transactions.put(tx, modifications);
+ }
+ }
+
+ /**
+ * TODO this is the same as the AbstractCacheLoader.
+ */
+ @Override
+ public void commit(Object tx) throws Exception
+ {
+ List<Modification> modifications = transactions.remove(tx);
+ if (modifications == null)
+ {
+ throw new Exception("transaction " + tx + " not found in transaction table");
+ }
+ put(modifications);
+ }
+
+ /**
+ * TODO this is the same as the AbstractCacheLoader.
+ */
+ @Override
+ public void rollback(Object tx)
+ {
+ transactions.remove(tx);
+ }
+
+ @Override
public Object put(Fqn name, Object key, Object value) throws Exception
{
if (config.getUseAsyncPut())
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7086 - in core/trunk/src/main/java/org/jboss/cache/loader: jdbm and 1 other directory.
by jbosscache-commits＠lists.jboss.org
Author: genman
Date: 2008-11-05 13:39:35 -0500 (Wed, 05 Nov 2008)
New Revision: 7086
Modified:
core/trunk/src/main/java/org/jboss/cache/loader/AbstractCacheLoader.java
core/trunk/src/main/java/org/jboss/cache/loader/jdbm/JdbmCacheLoader.java
Log:
JBCACHE-1438 - Optimize state transfer; batch modifications
Modified: core/trunk/src/main/java/org/jboss/cache/loader/AbstractCacheLoader.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/loader/AbstractCacheLoader.java 2008-11-05 18:36:58 UTC (rev 7085)
+++ core/trunk/src/main/java/org/jboss/cache/loader/AbstractCacheLoader.java 2008-11-05 18:39:35 UTC (rev 7086)
@@ -29,6 +29,7 @@
import org.jboss.cache.Modification;
import org.jboss.cache.Region;
import org.jboss.cache.RegionManager;
+import org.jboss.cache.Modification.ModificationType;
import org.jboss.cache.buddyreplication.BuddyFqnTransformer;
import org.jboss.cache.buddyreplication.BuddyManager;
import org.jboss.cache.marshall.Marshaller;
@@ -39,6 +40,7 @@
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
+import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
@@ -126,6 +128,7 @@
protected void storeStateHelper(Fqn subtree, List nodeData, boolean moveToBuddy) throws Exception
{
+ List<Modification> mod = new ArrayList<Modification>(nodeData.size());
for (Object aNodeData : nodeData)
{
NodeData nd = (NodeData) aNodeData;
@@ -144,15 +147,9 @@
fqn = nd.getFqn();
}
if (trace) log.trace("Storing state in Fqn " + fqn);
- if (nd.getAttributes() != null)
- {
- this.put(fqn, nd.getAttributes(), true);// creates a node with 0 or more attributes
- }
- else
- {
- this.put(fqn, null);// creates a node with null attributes
- }
+ mod.add(new Modification(ModificationType.PUT_DATA_ERASE, fqn, nd.getAttributes()));
}
+ prepare(null, mod, true);
}
public void loadEntireState(ObjectOutputStream os) throws Exception
@@ -313,8 +310,8 @@
remove(m.getFqn());
break;
case MOVE:
- // involve moving all children too,
- _move(m.getFqn(), m.getFqn2());
+ // involve moving all children too
+ move(m.getFqn(), m.getFqn2());
break;
default:
throw new CacheException("Unknown modification " + m.getType());
@@ -322,7 +319,7 @@
}
}
- private void _move(Fqn fqn, Fqn parent) throws Exception
+ protected void move(Fqn fqn, Fqn parent) throws Exception
{
Object name = fqn.getLastElement();
Fqn newFqn = Fqn.fromRelativeElements(parent, name);
@@ -333,7 +330,7 @@
{
for (Object c : childrenNames)
{
- _move(Fqn.fromRelativeElements(fqn, c), newFqn);
+ move(Fqn.fromRelativeElements(fqn, c), newFqn);
}
}
// get data for node.
Modified: core/trunk/src/main/java/org/jboss/cache/loader/jdbm/JdbmCacheLoader.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/loader/jdbm/JdbmCacheLoader.java 2008-11-05 18:36:58 UTC (rev 7085)
+++ core/trunk/src/main/java/org/jboss/cache/loader/jdbm/JdbmCacheLoader.java 2008-11-05 18:39:35 UTC (rev 7086)
@@ -29,6 +29,7 @@
import net.jcip.annotations.ThreadSafe;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
+import org.jboss.cache.CacheException;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.FqnComparator;
@@ -562,11 +563,39 @@
public void put(List<Modification> modifications)
throws Exception
{
-
checkOpen();
checkNonNull(modifications, "modifications");
- super.put(modifications);
+ for (Modification m : modifications)
+ {
+ switch (m.getType())
+ {
+ case PUT_DATA:
+ put0(m.getFqn(), m.getData());
+ break;
+ case PUT_DATA_ERASE:
+ erase0(m.getFqn(), false);
+ put0(m.getFqn(), m.getData());
+ break;
+ case PUT_KEY_VALUE:
+ put0(m.getFqn(), m.getKey(), m.getValue());
+ break;
+ case REMOVE_DATA:
+ erase0(m.getFqn(), false);
+ break;
+ case REMOVE_KEY_VALUE:
+ eraseKey0(m.getFqn(), m.getKey());
+ break;
+ case REMOVE_NODE:
+ erase0(m.getFqn());
+ break;
+ case MOVE:
+ move(m.getFqn(), m.getFqn2());
+ break;
+ default:
+ throw new CacheException("Unknown modification " + m.getType());
+ }
+ }
commit();
}
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7085 - core/trunk/src/main/java/org/jboss/cache/lock.
by jbosscache-commits＠lists.jboss.org
Author: manik.surtani(a)jboss.com
Date: 2008-11-05 13:36:58 -0500 (Wed, 05 Nov 2008)
New Revision: 7085
Modified:
core/trunk/src/main/java/org/jboss/cache/lock/MVCCLockManager.java
Log:
JBCACHE-1437: IllegalMonitorStateException on shutdown "breaking locks"
Modified: core/trunk/src/main/java/org/jboss/cache/lock/MVCCLockManager.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/lock/MVCCLockManager.java 2008-11-05 14:55:13 UTC (rev 7084)
+++ core/trunk/src/main/java/org/jboss/cache/lock/MVCCLockManager.java 2008-11-05 18:36:58 UTC (rev 7085)
@@ -139,7 +139,14 @@
{
if (trace) log.trace("Attempting to unlock " + fqn);
Lock lock = lockContainer.getLock(fqn);
- lock.unlock();
+ try
+ {
+ lock.unlock();
+ }
+ catch (IllegalMonitorStateException imse)
+ {
+ if (trace) log.trace("Caught exception and ignoring.", imse);
+ }
}
@SuppressWarnings("unchecked")
@@ -154,7 +161,14 @@
{
Fqn f = it.previous();
if (trace) log.trace("Attempting to unlock " + f);
- lockContainer.getLock(f).unlock();
+ try
+ {
+ lockContainer.getLock(f).unlock();
+ }
+ catch (IllegalMonitorStateException imse)
+ {
+ if (trace) log.trace("Caught exception and ignoring.", imse);
+ }
}
}
}
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7084 - in core/trunk/src: main/java/org/jboss/cache/interceptors and 9 other directories.
by jbosscache-commits＠lists.jboss.org
Author: mircea.markus
Date: 2008-11-05 09:55:13 -0500 (Wed, 05 Nov 2008)
New Revision: 7084
Modified:
core/trunk/src/main/java/org/jboss/cache/eviction/LRUQueue.java
core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java
core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java
core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/PassivationTest.java
core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/PassivationTest.java
core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationContentTest.java
core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationTestsBase.java
core/trunk/src/test/java/org/jboss/cache/loader/DummySharedInMemoryCacheLoader.java
core/trunk/src/test/java/org/jboss/cache/loader/JDBCCacheLoaderStateTransferTest.java
core/trunk/src/test/java/org/jboss/cache/options/cachemodelocal/AsyncReplOptLocksTest.java
core/trunk/src/test/java/org/jboss/cache/util/TestingUtil.java
core/trunk/src/test/java/org/jboss/cache/util/internals/ReplicationListener.java
core/trunk/src/test/resources/configs/parser-test.xml
Log:
fixed tests
Modified: core/trunk/src/main/java/org/jboss/cache/eviction/LRUQueue.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/eviction/LRUQueue.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/main/java/org/jboss/cache/eviction/LRUQueue.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -22,6 +22,8 @@
package org.jboss.cache.eviction;
import org.jboss.cache.Fqn;
+import org.apache.commons.logging.LogFactory;
+import org.apache.commons.logging.Log;
import java.util.Iterator;
import java.util.LinkedHashMap;
@@ -38,6 +40,8 @@
*/
public class LRUQueue implements EvictionQueue
{
+
+ private static Log log = LogFactory.getLog(LRUQueue.class);
private Map<Fqn, NodeEntry> maxAgeQueue;
private Map<Fqn, NodeEntry> lruQueue;
private long alternatingCount = 0;
@@ -165,6 +169,7 @@
public int getNumberOfNodes()
{
+ if (log.isTraceEnabled()) log.trace("LRUQUeue.size() = " + maxAgeQueue.size());
return maxAgeQueue.size();
}
Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/main/java/org/jboss/cache/interceptors/CacheLoaderInterceptor.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -291,6 +291,10 @@
n = helper.wrapNodeForWriting(ctx, fqn, true, true, true, false, false);
n.setDataLoaded(false);
}
+ else
+ {
+ this.cacheMisses++;
+ }
if (!bypassLoadingData && n != null)
{
n = loadNode(ctx, fqn, n);
Modified: core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/main/java/org/jboss/cache/util/reflect/ReflectionUtil.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -145,8 +145,7 @@
}
catch (Exception e)
{
- throw new CacheException("Unable to invoke method " + method + " on object " + //instance +
- (parameters != null ? " with parameters " + Arrays.asList(parameters) : ""), e);
+ throw new CacheException(e);
}
}
Modified: core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/PassivationTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/PassivationTest.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/PassivationTest.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -27,7 +27,7 @@
String binName = "bin-" + Thread.currentThread().getName();
- CacheLoaderConfig clc = getSingleCacheLoaderConfig("", DummySharedInMemoryCacheLoader.class.getName(), "debug=true,bin=" + binName, false, true, false);
+ CacheLoaderConfig clc = getSingleCacheLoaderConfig("", DummySharedInMemoryCacheLoader.class.getName(), "debug=true\nbin=" + binName, false, true, false);
clc.setPassivation(true);
cache.getConfiguration().setCacheLoaderConfig(clc);
}
Modified: core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/PassivationTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/PassivationTest.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/PassivationTest.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -14,7 +14,7 @@
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
-@Test(groups = {"functional", "mvcc"})
+@Test(groups = {"functional", "mvcc"})
public class PassivationTest extends PassivationTestsBase
{
@Override
@@ -23,7 +23,7 @@
CacheSPI<Object, Object> cache = cacheTL.get();
cache.getConfiguration().setNodeLockingScheme(NodeLockingScheme.MVCC);
cache.getConfiguration().setIsolationLevel(IsolationLevel.REPEATABLE_READ);
- CacheLoaderConfig clc = getSingleCacheLoaderConfig("", DummySharedInMemoryCacheLoader.class.getName(), "", false, true, false);
+ CacheLoaderConfig clc = getSingleCacheLoaderConfig("", DummySharedInMemoryCacheLoader.class.getName(), "bin=" + Thread.currentThread().getName() + getClass().getName(), false, true, false);
clc.setPassivation(true);
cache.getConfiguration().setCacheLoaderConfig(clc);
}
Modified: core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationContentTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationContentTest.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationContentTest.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -30,12 +30,10 @@
@Test(groups = {"functional"})
public class BuddyReplicationContentTest extends BuddyReplicationTestsBase
{
- private String key = "key";
- private String value = "value";
+ private final String key = "key";
+ private final String value = "value";
private Log log = LogFactory.getLog(BuddyGroupAssignmentTest.class);
- BuddyFqnTransformer fqnTransformer = new BuddyFqnTransformer();
-
private void assertNoStaleLocks(List<CacheSPI<Object, Object>> caches)
{
for (CacheSPI<Object, Object> cache : caches) assertNoStaleLocks(cache);
Modified: core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationTestsBase.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationTestsBase.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/buddyreplication/BuddyReplicationTestsBase.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -38,8 +38,8 @@
@Test(groups = {"functional", "jgroups"})
public abstract class BuddyReplicationTestsBase
{
- protected ThreadLocal<List<CacheSPI<Object, Object>>> cachesTL = new ThreadLocal<List<CacheSPI<Object, Object>>>();
- protected BuddyFqnTransformer fqnTransformer = new BuddyFqnTransformer();
+ protected final ThreadLocal<List<CacheSPI<Object, Object>>> cachesTL = new ThreadLocal<List<CacheSPI<Object, Object>>>();
+ protected final BuddyFqnTransformer fqnTransformer = new BuddyFqnTransformer();
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
Modified: core/trunk/src/test/java/org/jboss/cache/loader/DummySharedInMemoryCacheLoader.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/loader/DummySharedInMemoryCacheLoader.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/loader/DummySharedInMemoryCacheLoader.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -28,7 +28,11 @@
if (config != null && config.getProperties() != null)
{
- bin = config.getProperties().getProperty("bin", "_default_bin_");
+ bin = config.getProperties().getProperty("bin");
+ if (bin == null)
+ {
+ throw new IllegalStateException("bin MUST be present for shared state CL. This is because tests might run concurrently!");
+ }
}
if (!BINS.containsKey(bin)) BINS.put(bin, new ConcurrentHashMap<Fqn, DummyNode>());
Modified: core/trunk/src/test/java/org/jboss/cache/loader/JDBCCacheLoaderStateTransferTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/loader/JDBCCacheLoaderStateTransferTest.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/loader/JDBCCacheLoaderStateTransferTest.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -36,7 +36,7 @@
* @author Mircea.Markus(a)jboss.com
* @since 3.0
*/
-@Test(groups = "functional")
+@Test(groups = "functional", sequential = true)
public class JDBCCacheLoaderStateTransferTest extends AbstractCacheLoaderTestBase
{
Modified: core/trunk/src/test/java/org/jboss/cache/options/cachemodelocal/AsyncReplOptLocksTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/options/cachemodelocal/AsyncReplOptLocksTest.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/options/cachemodelocal/AsyncReplOptLocksTest.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -8,19 +8,85 @@
import org.jboss.cache.config.Configuration;
import org.jboss.cache.util.TestingUtil;
+import org.jboss.cache.CacheSPI;
import org.testng.annotations.Test;
+import static org.testng.AssertJUnit.assertEquals;
+import static org.testng.AssertJUnit.assertNull;
+import javax.transaction.TransactionManager;
+
@Test(groups = {"functional", "jgroups"})
public class AsyncReplOptLocksTest extends CacheModeLocalTestBase
{
- public AsyncReplOptLocksTest()
- {
- cacheMode = Configuration.CacheMode.REPL_ASYNC;
- nodeLockingScheme = "OPTIMISTIC";
- }
+ public AsyncReplOptLocksTest()
+ {
+ cacheMode = Configuration.CacheMode.REPL_ASYNC;
+ nodeLockingScheme = "OPTIMISTIC";
+ }
- protected void delay()
- {
- TestingUtil.sleepThread(500);
- }
+ protected void delay()
+ {
+ TestingUtil.sleepThread(500);
+ }
+
+ public void testRemoveKey() throws Exception
+ {
+ super.testRemoveKey();
+ }
+
+ public void testPutKeyValue() throws Exception
+ {
+ super.testPutKeyValue();
+ }
+
+ public void testPutKeyValueViaNodeAPI() throws Exception
+ {
+ super.testPutKeyValueViaNodeAPI();
+ }
+
+ public void testPutData() throws Exception
+ {
+ super.testPutData();
+ }
+
+ public void testPutDataViaNodeAPI() throws Exception
+ {
+ super.testPutDataViaNodeAPI();
+ }
+
+ public void testRemoveNode() throws Exception
+ {
+ super.testRemoveNode();
+ }
+
+ public void testRemoveNodeViaNodeAPI() throws Exception
+ {
+ super.testRemoveNodeViaNodeAPI();
+ }
+
+ public void testRemoveKeyViaNodeAPI() throws Exception
+ {
+ super.testRemoveKeyViaNodeAPI();
+ }
+
+ public void testTransactionalBehaviourCommit() throws Exception
+ {
+ super.testTransactionalBehaviourCommit();
+ }
+
+ public void testTransactionalBehaviourRollback() throws Exception
+ {
+ super.testTransactionalBehaviourRollback();
+ }
+
+ public void testTransactionalBehaviourViaNodeAPI() throws Exception
+ {
+ super.testTransactionalBehaviourViaNodeAPI();
+ }
+
+ public void testAddChild() throws Exception
+ {
+ super.testAddChild();
+ }
+
}
Modified: core/trunk/src/test/java/org/jboss/cache/util/TestingUtil.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/util/TestingUtil.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/util/TestingUtil.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -334,10 +334,6 @@
return true;
}
- /**
- * @param c
- * @param memberCount
- */
public static boolean isCacheViewComplete(Cache c, int memberCount)
{
return isCacheViewComplete(c, memberCount, true);
Modified: core/trunk/src/test/java/org/jboss/cache/util/internals/ReplicationListener.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/util/internals/ReplicationListener.java 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/java/org/jboss/cache/util/internals/ReplicationListener.java 2008-11-05 14:55:13 UTC (rev 7084)
@@ -63,6 +63,10 @@
CommandAwareRpcDispatcher realDispatcher = (CommandAwareRpcDispatcher) TestingUtil.extractField(rpcManager, "rpcDispatcher");
RpcDispatcher.Marshaller2 realMarshaller = (RpcDispatcher.Marshaller2) realDispatcher.getMarshaller();
RpcDispatcher.Marshaller2 delegate = null;
+ if ( (realMarshaller instanceof RegionMarshallerDelegate) || (realMarshaller instanceof MarshallerDelegate) )
+ {
+ throw new RuntimeException("Illegal state");
+ }
if (realDispatcher instanceof InactiveRegionAwareRpcDispatcher)
delegate = new RegionMarshallerDelegate((Marshaller) realMarshaller);
else
Modified: core/trunk/src/test/resources/configs/parser-test.xml
===================================================================
--- core/trunk/src/test/resources/configs/parser-test.xml 2008-11-04 16:24:20 UTC (rev 7083)
+++ core/trunk/src/test/resources/configs/parser-test.xml 2008-11-05 14:55:13 UTC (rev 7084)
@@ -5,10 +5,11 @@
<jbosscache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="urn:jboss:jbosscache-core:config:3.0">
-
+ <!-- perCache -> differrent EntryFactory-->
<locking isolationLevel="REPEATABLE_READ" lockParentForChildInsertRemove="true" lockAcquisitionTimeout="10234"
nodeLockingScheme="mvcc" writeSkewCheck="false" concurrencyLevel="21"/>
+ <!-- perCM -->
<transaction transactionManagerLookupClass="org.jboss.cache.transaction.GenericTransactionManagerLookup"
syncRollbackPhase="true" syncCommitPhase="true"/>
@@ -17,12 +18,15 @@
<startup regionsInactiveOnStartup="true"/>
<shutdown hookBehavior="REGISTER"/>
<listeners asyncPoolSize="5"/>
+ <!-- perCache -->
<invocationBatching enabled="true"/>
+ <!-- per CM-->
<!-- serialization related configuration, used for replication and cache loading -->
<serialization objectInputStreamPoolSize="12" objectOutputStreamPoolSize="14" version="1.2.4"
marshallerClass="some.Clazz" useLazyDeserialization="true" useRegionBasedMarshalling="true"/>
+ <!-- per Cache -->
<clustering mode="replication" clusterName="JBossCache-cluster">
<stateRetrieval timeout="15124" fetchInMemoryState="true"/>
<buddy enabled="true" poolName="myBuddyPoolReplicationGroup" communicationTimeout="2000">
@@ -34,10 +38,11 @@
</properties>
</locator>
</buddy>
- <sync replTimeout="15421"/>
+ <sync replTimeout="15421"/>
<jgroupsConfig multiplexerStack="file_name" />
</clustering>
+ <!-- per cache, 1) algo/cache 2) what/cache 3) collecting data 4) timer thread / per CM -->
<eviction wakeUpInterval="5">
<default algorithmClass="org.jboss.cache.eviction.LRUAlgorithm" eventQueueSize="200000">
<property name="maxNodes" value="5000" />
@@ -52,6 +57,7 @@
</region>
</eviction>
+ <!-- cacheLoaders/Cache; optimization - reusing CL through caches -->
<!-- this should be deprecated in 3.0 and should be replaced with CacheLoaderConfig-->
<loaders passivation="true" shared="true">
<preload>
@@ -76,6 +82,7 @@
</loader>
</loaders>
+ <!-- per CacheInstance -->
<!-- this is new behavior added within 3.x only. it support configuring custom interceptors through configurations -->
<customInterceptors>
<interceptor position="first" class="org.jboss.cache.config.parsing.custominterceptors.AaaCustomInterceptor">
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7083 - core/trunk/src/test/java/org/jboss/cache/passivation.
by jbosscache-commits＠lists.jboss.org
Author: mircea.markus
Date: 2008-11-04 11:24:20 -0500 (Tue, 04 Nov 2008)
New Revision: 7083
Modified:
core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java
Log:
make the test sequential as it shares a static dummy in memory cache loader
Modified: core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java 2008-11-04 16:12:57 UTC (rev 7082)
+++ core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java 2008-11-04 16:24:20 UTC (rev 7083)
@@ -54,32 +54,7 @@
public void testStateTransferOfPassivatedStatePessimistic() throws Exception
{
-// doTest(NodeLockingScheme.PESSIMISTIC, false);
- Cache cache1=null, cache2=null;
- Fqn A = Fqn.fromRelativeElements(Fqn.ROOT, "a"), B = Fqn.fromRelativeElements(Fqn.ROOT, "b"), C = Fqn.fromRelativeElements(Fqn.ROOT, "c");
- try
- {
- Set<Object> nameSet = new HashSet<Object>();
- nameSet.add(A.getLastElement());
- nameSet.add(B.getLastElement());
- nameSet.add(C.getLastElement());
-
- cache1 = new UnitTestCacheFactory().createCache(buildConf(NodeLockingScheme.PESSIMISTIC, "cache1", false, false, true));
-
- cache1.put(A, "k", "v");
- cache1.put(B, "k", "v");
- cache1.put(C, "k", "v");
- assert cache1.getNode(Fqn.ROOT).getChildrenNames().equals(nameSet);
-
- cache1.evict(A);
-
- cache2 = new UnitTestCacheFactory().createCache(buildConf(NodeLockingScheme.PESSIMISTIC, "cache2", false, false, true));
- assert cache2.getRoot().getChildrenNames().equals(nameSet) : "Expecting " + nameSet + " but got " + cache2.getRoot().getChildrenNames();
- }
- finally
- {
- TestingUtil.killCaches(cache1, cache2);
- }
+ doTest(NodeLockingScheme.PESSIMISTIC, false);
}
public void testStateTransferOfPassivatedPartialState() throws Exception
15 years, 6 months
- 1
- 0
JBoss Cache SVN: r7082 - core/trunk/src/test/java/org/jboss/cache/passivation.
by jbosscache-commits＠lists.jboss.org
Author: mircea.markus
Date: 2008-11-04 11:12:57 -0500 (Tue, 04 Nov 2008)
New Revision: 7082
Modified:
core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java
Log:
make the test sequential as it shares a static dummy in memory cache loader
Modified: core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java
===================================================================
--- core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java 2008-11-04 14:57:30 UTC (rev 7081)
+++ core/trunk/src/test/java/org/jboss/cache/passivation/ReplAndStateTransferWithPassivationTest.java 2008-11-04 16:12:57 UTC (rev 7082)
@@ -27,6 +27,7 @@
import org.jboss.cache.Node;
import org.jboss.cache.Region;
import org.jboss.cache.UnitTestCacheFactory;
+import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.jboss.cache.buddyreplication.BuddyFqnTransformer;
import org.jboss.cache.config.BuddyReplicationConfig;
import org.jboss.cache.config.CacheLoaderConfig;
@@ -37,11 +38,13 @@
import org.jboss.cache.loader.DummySharedInMemoryCacheLoader;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.Test;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
import java.util.HashSet;
import java.util.Set;
-@Test(groups = "functional")
+@Test(groups = "functional", sequential = true)
public class ReplAndStateTransferWithPassivationTest extends AbstractCacheLoaderTestBase
{
public void testStateTransferOfPassivatedState() throws Exception
@@ -51,7 +54,32 @@
public void testStateTransferOfPassivatedStatePessimistic() throws Exception
{
- doTest(NodeLockingScheme.PESSIMISTIC, false);
+// doTest(NodeLockingScheme.PESSIMISTIC, false);
+ Cache cache1=null, cache2=null;
+ Fqn A = Fqn.fromRelativeElements(Fqn.ROOT, "a"), B = Fqn.fromRelativeElements(Fqn.ROOT, "b"), C = Fqn.fromRelativeElements(Fqn.ROOT, "c");
+ try
+ {
+ Set<Object> nameSet = new HashSet<Object>();
+ nameSet.add(A.getLastElement());
+ nameSet.add(B.getLastElement());
+ nameSet.add(C.getLastElement());
+
+ cache1 = new UnitTestCacheFactory().createCache(buildConf(NodeLockingScheme.PESSIMISTIC, "cache1", false, false, true));
+
+ cache1.put(A, "k", "v");
+ cache1.put(B, "k", "v");
+ cache1.put(C, "k", "v");
+ assert cache1.getNode(Fqn.ROOT).getChildrenNames().equals(nameSet);
+
+ cache1.evict(A);
+
+ cache2 = new UnitTestCacheFactory().createCache(buildConf(NodeLockingScheme.PESSIMISTIC, "cache2", false, false, true));
+ assert cache2.getRoot().getChildrenNames().equals(nameSet) : "Expecting " + nameSet + " but got " + cache2.getRoot().getChildrenNames();
+ }
+ finally
+ {
+ TestingUtil.killCaches(cache1, cache2);
+ }
}
public void testStateTransferOfPassivatedPartialState() throws Exception
@@ -166,7 +194,7 @@
}
}
- private Configuration buildConf(NodeLockingScheme nls, String n, boolean regionbased, boolean useBR, boolean brSearchSubtrees) throws Exception
+ private Configuration buildConf(NodeLockingScheme nls, String name, boolean regionbased, boolean useBR, boolean brSearchSubtrees) throws Exception
{
Configuration c = new Configuration();
if (regionbased)
@@ -176,7 +204,7 @@
}
c.setCacheMode(CacheMode.REPL_SYNC);
c.setNodeLockingScheme(nls);
- CacheLoaderConfig clc = getSingleCacheLoaderConfig("", DummySharedInMemoryCacheLoader.class.getName(), "bin="+n, false, true, false);
+ CacheLoaderConfig clc = getSingleCacheLoaderConfig("", DummySharedInMemoryCacheLoader.class.getName(), "bin="+name, false, true, false);
clc.setPassivation(true);
c.setCacheLoaderConfig(clc);
if (useBR)
15 years, 6 months
- 1
- 0