Merged DEV/DEREK_2.1 to HEAD

- Removed Node.parentAssocs mapping
 - Added parentAssocs transactional cache to NodeDAO
 - Added concurrency detection to TransactionalCache
 - Fixed cluster sample config


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@5948 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

config/alfresco/action-services-context.xml

@@ -24,6 +24,9 @@
     </bean>
     
     <bean id="asynchronousActionExecutionQueue" class="org.alfresco.repo.action.AsynchronousActionExecutionQueueImpl">
+      <property name="threadPoolExecutor">
+         <ref bean="threadPoolExecutor"/>
+      </property>
     	<property name="transactionService">
     		<ref bean="transactionService"/>
     	</property>

config/alfresco/cache-context.xml

@@ -27,6 +27,42 @@
    <bean name="internalEHCacheManager" class="org.alfresco.repo.cache.InternalEhCacheManagerFactoryBean" />
    
    
+   <!-- ===================================== -->
+   <!-- Parent Associations lookup for nodes  -->
+   <!-- ===================================== -->
+
+   <!-- The cross-transaction shared cache for Parent Associations -->
+   
+   <bean name="parentAssocsSharedCache" class="org.alfresco.repo.cache.EhCacheAdapter">
+      <property name="cache">
+         <bean class="org.springframework.cache.ehcache.EhCacheFactoryBean" >
+            <property name="cacheManager">
+               <ref bean="internalEHCacheManager" />
+            </property>
+            <property name="cacheName">
+               <value>org.alfresco.cache.parentAssocsCache</value>
+            </property>
+         </bean>
+      </property>
+   </bean>
+   
+   <!-- The transactional cache for Parent Associations -->
+   
+   <bean name="parentAssocsCache" class="org.alfresco.repo.cache.TransactionalCache">
+      <property name="sharedCache">
+         <ref bean="parentAssocsSharedCache" />
+      </property>
+      <property name="cacheManager" >
+         <ref bean="transactionalEHCacheManager" />
+      </property>
+      <property name="name">
+         <value>org.alfresco.parentAssocsTransactionalCache</value>
+      </property>
+      <property name="maxCacheSize">
+         <value>1000</value>
+      </property>
+   </bean>
+   
    <!-- ===================================== -->
    <!-- Authority container look up for users -->
    <!-- ===================================== -->

config/alfresco/ehcache-default.xml

@@ -75,13 +75,6 @@
         eternal="true"
         overflowToDisk="false"
         />
-    <!-- approx 10MB memory required -->
-    <cache 
-        name="org.alfresco.repo.domain.hibernate.NodeImpl.parentAssocs" 
-        maxElementsInMemory="10000"
-        eternal="true"
-        overflowToDisk="false"
-        />
     <!-- approx 250MB memory required -->
     <cache 
         name="org.alfresco.repo.domain.hibernate.ChildAssocImpl" 
@@ -92,7 +85,7 @@
     <!-- general use node associations are not common  -->
     <cache 
         name="org.alfresco.repo.domain.hibernate.NodeAssocImpl" 
-        maxElementsInMemory="1000" 
+        maxElementsInMemory="5000" 
         eternal="true"
         overflowToDisk="false"
         />
@@ -263,6 +256,12 @@
         /> 
 
     <!-- Internally used caches -->
+    <cache 
+        name="org.alfresco.cache.parentAssocsCache"
+        maxElementsInMemory="10000"
+        eternal="true"
+        overflowToDisk="false"
+        />
     <cache 
         name="org.alfresco.cache.userToAuthorityCache" 
         maxElementsInMemory="10000"

config/alfresco/extension/ehcache-custom.xml.sample.cluster

@@ -176,25 +176,6 @@
                                 replicateAsynchronously = false"/>
 
 
-    </cache>
-
-    <cache
-        name="org.alfresco.repo.domain.hibernate.NodeImpl.parentAssocs"
-        maxElementsInMemory="10000"
-        eternal="true"
-        timeToIdleSeconds="0"
-        timeToLiveSeconds="0"
-        overflowToDisk="false">
-
-            <cacheEventListenerFactory
-                    class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
-                    properties="replicatePuts = false,
-                                replicateUpdates = true,
-                                replicateRemovals = true,
-                                replicateUpdatesViaCopy = false,
-                                replicateAsynchronously = false"/>
-                                
-
     </cache>
 
     <cache
@@ -434,6 +415,23 @@
 
     <!-- Non-Hibernate -->
     
+    <cache
+        name="org.alfresco.cache.parentAssocsCache"
+        maxElementsInMemory="10000"
+        eternal="true"
+        overflowToDisk="false">
+
+            <cacheEventListenerFactory
+                    class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
+                    properties="replicatePuts = false,
+                                replicateUpdates = true,
+                                replicateRemovals = true,
+                                replicateUpdatesViaCopy = false,
+                                replicateAsynchronously = false"/>
+
+
+    </cache>
+
     <cache
         name="org.alfresco.cache.userToAuthorityCache"
         maxElementsInMemory="10000"

config/alfresco/hibernate-context.xml

@@ -172,7 +172,9 @@
             <props>
                 <prop key="org.alfresco.repo.domain.hibernate.NodeImpl.properties">${cache.strategy}</prop>
                 <prop key="org.alfresco.repo.domain.hibernate.NodeImpl.aspects">${cache.strategy}</prop>
+<!--
                 <prop key="org.alfresco.repo.domain.hibernate.NodeImpl.parentAssocs">${cache.strategy}</prop>
+-->
 
                 <prop key="org.alfresco.repo.domain.hibernate.DbAccessControlListImpl.entries">${cache.strategy}</prop>
                 <prop key="org.alfresco.repo.domain.hibernate.DbAuthorityImpl.externalKeys">${cache.strategy}</prop>
@@ -231,6 +233,9 @@
       <property name="sessionFactory">
          <ref bean="sessionFactory" />
       </property>
+      <property name="parentAssocsCache">
+         <ref bean="parentAssocsCache"/>
+      </property>
    </bean>
     
    <bean id="dbNodeDaoServiceTxnRegistration" class="org.alfresco.repo.transaction.TransactionalDaoInterceptor" >

source/java/org/alfresco/repo/admin/patch/impl/UniqueChildNamePatch.java

@@ -223,7 +223,7 @@ public class UniqueChildNamePatch extends AbstractPatch
                                 {
                                     // Try removing the secondary parent associations
                                     writeLine("   Removing secondary parents of node " + childNode.getId());
-                                    Collection<ChildAssoc> parentAssocs = childNode.getParentAssocs();
+                                    Collection<ChildAssoc> parentAssocs = nodeDaoService.getParentAssocs(childNode);
                                     for (ChildAssoc parentAssoc : parentAssocs)
                                     {
                                         if (!parentAssoc.getIsPrimary())
@@ -241,7 +241,7 @@ public class UniqueChildNamePatch extends AbstractPatch
                                 else if (duplicateNumber > 10)
                                 {
                                     // after 10 attempts, we have to admit defeat.  Perhaps there is a larger issue.
-                                    Collection<ChildAssoc> parentAssocs = childNode.getParentAssocs();
+                                    Collection<ChildAssoc> parentAssocs = nodeDaoService.getParentAssocs(childNode);
                                     write("   Unable to set child name '" + usedChildName + "' for node " + childNode.getId());
                                     writeLine(" with parent associations:");
                                     for (ChildAssoc parentAssoc : parentAssocs)

source/java/org/alfresco/repo/cache/CacheTest.java

@@ -30,15 +30,17 @@ import java.util.Collection;
 import javax.transaction.Status;
 import javax.transaction.UserTransaction;
 
+import junit.framework.TestCase;
 import net.sf.ehcache.CacheManager;
 
+import org.alfresco.error.ExceptionStackUtil;
+import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
 import org.alfresco.service.ServiceRegistry;
 import org.alfresco.service.transaction.TransactionService;
 import org.alfresco.util.ApplicationContextHelper;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
-
+import org.springframework.dao.ConcurrencyFailureException;
-import junit.framework.TestCase;
 
 /**
  * @see org.alfresco.repo.cache.EhCacheAdapter
@@ -133,7 +135,7 @@ public class CacheTest extends TestCase
         assertNull("Non-transactional remove didn't go to backing cache", backingCache.get(key));
     }
     
-    public void testTransactionalCacheWithTxn() throws Throwable
+    public void testTransactionalCacheWithSingleTxn() throws Throwable
     {
         String newGlobalOne = "new_global_one";
         String newGlobalTwo = "new_global_two";
@@ -253,4 +255,269 @@ public class CacheTest extends TestCase
                     "   transaction: " + timeTxn/((long)count) + " ns\\count"); 
         }
     }
+    
+    /**
+     * Starts off with a <tt>null</tt> in the backing cache and adds a value to the
+     * transactional cache.  There should be no problem with this.
+     */
+    public void testNullValue() throws Exception
+    {
+        TransactionService transactionService = serviceRegistry.getTransactionService();
+        UserTransaction txn = transactionService.getUserTransaction();
+        try
+        {
+            txn.begin();
+            
+            backingCache.put("A", null);
+            transactionalCache.put("A", "AAA");
+            
+            txn.commit();
+        }
+        finally
+        {
+            try { txn.rollback(); } catch (Throwable ee) {}
+        }
+    }
+    
+    private static final Class[] CONCURRENCY_EXCEPTIONS = {ConcurrencyFailureException.class};
+    /** Execute the callback and ensure that the concurrent condition is detected */
+    private void executeAndCheck(RetryingTransactionCallback callback) throws Exception
+    {
+        TransactionService transactionService = serviceRegistry.getTransactionService();
+        UserTransaction txn = transactionService.getUserTransaction();
+        try
+        {
+            txn.begin();
+            callback.execute();
+            txn.commit();
+            fail("Failed to detect concurrent modification");
+        }
+        catch (Throwable e)
+        {
+            assertNotNull(
+                    "Expected a concurrency failure",
+                    ExceptionStackUtil.getCause(e, CONCURRENCY_EXCEPTIONS));
+        }
+        finally
+        {
+            try { txn.rollback(); } catch (Throwable ee) {}
+        }
+    }
+    
+    /**
+     * <ul>
+     *   <li>Add to the transaction cache</li>
+     *   <li>Add to the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentAddAgainstAdd() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                transactionalCache.put("A", "AAA");
+                backingCache.put("A", "aaa");
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the transaction cache</li>
+     *   <li>Clear the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentAddAgainstClear() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                transactionalCache.put("A", "AAA");
+                backingCache.clear();
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Update the transactional cache</li>
+     *   <li>Update the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentUpdateAgainstUpdate() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.put("A", "AAA");
+                backingCache.put("A", "aaa2");
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Update the transactional cache</li>
+     *   <li>Update the backing cache with a <tt>null</tt> value</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentUpdateAgainstUpdateNull() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.put("A", "AAA");
+                backingCache.put("A", null);
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Update the transactional cache with a <tt>null</tt> value</li>
+     *   <li>Update the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentUpdateNullAgainstUpdate() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.put("A", null);
+                backingCache.put("A", "aaa2");
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Update the transactional cache</li>
+     *   <li>Remove from the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentUpdateAgainstRemove() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.put("A", "AAA");
+                backingCache.remove("A");
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Update the transactional cache</li>
+     *   <li>Clear the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentUpdateAgainstClear() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.put("A", "AAA");
+                backingCache.clear();
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Remove from the transactional cache</li>
+     *   <li>Add to the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentRemoveAgainstUpdate() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.remove("A");
+                backingCache.put("A", "aaa2");
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Remove from the transactional cache</li>
+     *   <li>Remove from the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentRemoveAgainstRemove() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.remove("A");
+                backingCache.remove("A");
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
+    /**
+     * <ul>
+     *   <li>Add to the backing cache</li>
+     *   <li>Remove from the transactional cache</li>
+     *   <li>Clear the backing cache</li>
+     *   <li>Commit</li>
+     * </ul>
+     */
+    public void testConcurrentRemoveAgainstClear() throws Exception
+    {
+        RetryingTransactionCallback callback = new RetryingTransactionCallback()
+        {
+            public Object execute() throws Throwable
+            {
+                backingCache.put("A", "aaa1");
+                transactionalCache.remove("A");
+                backingCache.clear();
+                return null;
+            }
+        };
+        executeAndCheck(callback);
+    }
 }

source/java/org/alfresco/repo/cache/SimpleCache.java

@@ -34,19 +34,48 @@ import java.util.Collection;
  * <tt>Serializable</tt> for both keys and values ensures that the underlying
  * cache implementations can support both clustered caches as well as persistent
  * caches.
+ * <p>
+ * All implementations must support <tt>null</tt> values.  It therefore follows
+ * that
+ * <pre>
+ *    (simpleCache.contains(key) == true) does not imply (simpleCache.get(key) != null)
+ * </pre>
+ * but
+ * <pre>
+ *    (simpleCache.contains(key) == false) implies (simpleCache.get(key) == null)
+ * <pre>
  * 
  * @author Derek Hulley
  */
 public interface SimpleCache<K extends Serializable, V extends Object>
 {
+    /**
+     * @param key       the cache key to check up on
+     * @return          Returns <tt>true</tt> if there is a cache entry,
+     *                  regardless of whether the value itself is <tt>null</tt>
+     */
     public boolean contains(K key);
     
     public Collection<K> getKeys();
     
+    /**
+     * @param key
+     * @return          Returns the value associated with the key.  It will be <tt>null</tt>
+     *                  if the value is <tt>null</tt> or if the cache doesn't have an entry.
+     */
     public V get(K key);
     
+    /**
+     * @param key       the key against which to store the value
+     * @param value     the value to store.  <tt>null</tt> is allowed.
+     */
     public void put(K key, V value);
     
+    /**
+     * Removes the cache entry whether or not the value stored against it is <tt>null</tt>.
+     * 
+     * @param key       the key value to remove
+     */
     public void remove(K key);
     
     public void clear();

source/java/org/alfresco/repo/cache/TransactionalCache.java

@@ -41,6 +41,7 @@ import org.alfresco.util.EqualsHelper;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.beans.factory.InitializingBean;
+import org.springframework.dao.ConcurrencyFailureException;
 import org.springframework.util.Assert;
 
 /**
@@ -54,12 +55,13 @@ import org.springframework.util.Assert;
  * directly with the shared cache when no transaction is present.  There is
  * virtually no overhead when running out-of-transaction.
  * <p>
- * 3 caches are maintained.
+ * The first phase of the commit ensures that any values written to the cache in the
- * <ul>
+ * current transaction are not already superceded by values in the shared cache.  In
- *   <li>Shared backing cache that should only be accessed by instances of this class</li>
+ * this case, the transaction is failed for concurrency reasons and will have to retry.
- *   <li>Lazily created cache of updates made during the transaction</li>
+ * The second phase occurs post-commit.  We are sure that the transaction committed
- *   <li>Lazily created cache of deletions made during the transaction</li>
+ * correctly, but things may have changed in the cache between the commit and post-commit.
- * </ul>
+ * If this is the case, then the offending values are merely removed from the shared
+ * cache.
  * <p>
  * When the cache is {@link #clear() cleared}, a flag is set on the transaction.
  * The shared cache, instead of being cleared itself, is just ignored for the remainder
@@ -69,7 +71,8 @@ import org.springframework.util.Assert;
  * Because there is a limited amount of space available to the in-transaction caches,
  * when either of these becomes full, the cleared flag is set.  This ensures that
  * the shared cache will not have stale data in the event of the transaction-local
- * caches dropping items.
+ * caches dropping items.  It is therefore important to size the transactional caches
+ * correctly.
  * 
  * @author Derek Hulley
  */
@@ -77,15 +80,15 @@ public class TransactionalCache<K extends Serializable, V extends Object>
         implements SimpleCache<K, V>, TransactionListener, InitializingBean
 {
     private static final String RESOURCE_KEY_TXN_DATA = "TransactionalCache.TxnData"; 
-    private static final String VALUE_DELETE = "TransactionalCache.DeleteMarker";
     
     private static Log logger = LogFactory.getLog(TransactionalCache.class);
+    private static boolean isDebugEnabled = logger.isDebugEnabled();
 
     /** a name used to uniquely identify the transactional caches */
     private String name;
     
     /** the shared cache that will get updated after commits */
-    private SimpleCache<Serializable, Object> sharedCache;
+    private SimpleCache<Serializable, V> sharedCache;
 
     /** the manager to control Ehcache caches */
     private CacheManager cacheManager;
@@ -96,6 +99,13 @@ public class TransactionalCache<K extends Serializable, V extends Object>
     /** a unique string identifying this instance when binding resources */
     private String resourceKeyTxnData;
 
+    /**
+     * Public constructor.
+     */
+    public TransactionalCache()
+    {
+    }
+    
     /**
      * @see #setName(String)
      */
@@ -133,7 +143,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
      * 
      * @param sharedCache
      */
-    public void setSharedCache(SimpleCache<Serializable, Object> sharedCache)
+    public void setSharedCache(SimpleCache<Serializable, V> sharedCache)
     {
         this.sharedCache = sharedCache;
     }
@@ -284,13 +294,13 @@ public class TransactionalCache<K extends Serializable, V extends Object>
             TransactionData txnData = getTransactionData();
             try
             {
-                if (!txnData.isClearOn)   // deletions cache is still reliable
+                if (!txnData.isClearOn)   // deletions cache only useful before a clear
                 {
                     // check to see if the key is present in the transaction's removed items
                     if (txnData.removedItemsCache.get(key) != null)
                     {
                         // it has been removed in this transaction
-                        if (logger.isDebugEnabled())
+                        if (isDebugEnabled)
                         {
                             logger.debug("get returning null - item has been removed from transactional cache: \n" +
                                     "   cache: " + this + "\n" +
@@ -304,15 +314,17 @@ public class TransactionalCache<K extends Serializable, V extends Object>
                 Element element = txnData.updatedItemsCache.get(key);
                 if (element != null)
                 {
+                    CacheBucket<V> bucket = (CacheBucket<V>) element.getValue();
+                    V value = bucket.getValue();
                     // element was found in transaction-specific updates/additions
-                    if (logger.isDebugEnabled())
+                    if (isDebugEnabled)
                     {
                         logger.debug("Found item in transactional cache: \n" +
                                 "   cache: " + this + "\n" +
                                 "   key: " + key + "\n" +
-                                "   value: " + element.getValue());
+                                "   value: " + value);
                     }
-                    return (V) element.getValue();
+                    return value;
                 }
             }
             catch (CacheException e)
@@ -325,19 +337,20 @@ public class TransactionalCache<K extends Serializable, V extends Object>
         // no value found - must we ignore the shared cache?
         if (!ignoreSharedCache)
         {
+            V value = sharedCache.get(key);
             // go to the shared cache
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("No value found in transaction - fetching instance from shared cache: \n" +
                         "   cache: " + this + "\n" +
                         "   key: " + key + "\n" +
-                        "   value: " + sharedCache.get(key));
+                        "   value: " + value);
             }
-            return (V) sharedCache.get(key);
+            return value;
         }
         else        // ignore shared cache
         {
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("No value found in transaction and ignoring shared cache: \n" +
                         "   cache: " + this + "\n" +
@@ -361,7 +374,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
             // no transaction
             sharedCache.put(key, value);
             // done
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("No transaction - adding item direct to shared cache: \n" +
                         "   cache: " + this + "\n" +
@@ -381,12 +394,24 @@ public class TransactionalCache<K extends Serializable, V extends Object>
                 // shared cache needs to be ignored for the rest of the transaction.
                 txnData.isClearOn = true;
             }
-            Element element = new Element(key, value);
+            CacheBucket<V> bucket = null;
+            if (sharedCache.contains(key))
+            {
+                V existingValue = sharedCache.get(key);
+                // The value needs to be kept for later checks
+                bucket = new UpdateCacheBucket<V>(existingValue, value);
+            }
+            else
+            {
+                // The value didn't exist before
+                bucket = new NewCacheBucket<V>(value);
+            }
+            Element element = new Element(key, bucket);
             txnData.updatedItemsCache.put(element);
             // remove the item from the removed cache, if present
             txnData.removedItemsCache.remove(key);
             // done
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("In transaction - adding item direct to transactional update cache: \n" +
                         "   cache: " + this + "\n" +
@@ -410,7 +435,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
             // no transaction
             sharedCache.remove(key);
             // done
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("No transaction - removing item from shared cache: \n" +
                         "   cache: " + this + "\n" +
@@ -423,7 +448,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
             // is the shared cache going to be cleared?
             if (txnData.isClearOn)
             {
-                // don't store removals
+                // don't store removals if we're just going to clear it all out later
             }
             else
             {
@@ -434,7 +459,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
                     // data by clearing the shared cache after the transaction.  Also, the
                     // shared cache needs to be ignored for the rest of the transaction.
                     txnData.isClearOn = true;
-                    if (logger.isDebugEnabled())
+                    if (isDebugEnabled)
                     {
                         logger.debug("In transaction - removal cache reach capacity reached: \n" +
                                 "   cache: " + this + "\n" +
@@ -443,15 +468,24 @@ public class TransactionalCache<K extends Serializable, V extends Object>
                 }
                 else
                 {
-                    // add it from the removed cache for this txn
+                    V existingValue = sharedCache.get(key);
-                    Element element = new Element(key, VALUE_DELETE);
+                    if (existingValue == null)
+                    {
+                        // There is no point doing a remove for a value that doesn't exist
+                    }
+                    else
+                    {
+                        // Create a bucket to remove the value from the shared cache
+                        CacheBucket<V> removeBucket = new RemoveCacheBucket<V>(existingValue);
+                        Element element = new Element(key, removeBucket);
                         txnData.removedItemsCache.put(element);
                     }
                 }
+            }
             // remove the item from the udpated cache, if present
             txnData.updatedItemsCache.remove(key);
             // done
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("In transaction - adding item direct to transactional removed cache: \n" +
                         "   cache: " + this + "\n" +
@@ -468,7 +502,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
         // clear local caches
         if (AlfrescoTransactionSupport.getTransactionId() != null)
         {
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("In transaction clearing cache: \n" +
                         "   cache: " + this + "\n" +
@@ -485,7 +519,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
         }
         else            // no transaction
         {
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("No transaction - clearing shared cache");
             }
@@ -501,12 +535,40 @@ public class TransactionalCache<K extends Serializable, V extends Object>
     {
     }
 
-    public void beforeCommit(boolean readOnly)
+    public void beforeCompletion()
     {
     }
 
-    public void beforeCompletion()
+    /**
+     * Check that the cache used is not out of date with the shared cache.
+     * Note that the clear flag is ignored as this would have removed all
+     * entries from the local caches anyway.
+     */
+    @SuppressWarnings("unchecked")
+    public void beforeCommit(boolean readOnly)
     {
+        if (isDebugEnabled)
+        {
+            logger.debug("Processing pre-commit");
+        }
+        
+        TransactionData txnData = getTransactionData();
+        // Process all the updates or new entries
+        for (Object obj : txnData.updatedItemsCache.getKeys())
+        {
+            Serializable key = (Serializable) obj;
+            Element element = txnData.updatedItemsCache.get(key);
+            CacheBucket<V> bucket = (CacheBucket<V>) element.getValue();
+            bucket.doPreCommit(sharedCache, key);
+        }
+        // Process all the removals
+        for (Object obj : txnData.removedItemsCache.getKeys())
+        {
+            Serializable key = (Serializable) obj;
+            Element element = txnData.removedItemsCache.get(key);
+            CacheBucket<V> bucket = (CacheBucket<V>) element.getValue();
+            bucket.doPreCommit(sharedCache, key);
+        }
     }
 
     /**
@@ -515,9 +577,9 @@ public class TransactionalCache<K extends Serializable, V extends Object>
     @SuppressWarnings("unchecked")
     public void afterCommit()
     {
-        if (logger.isDebugEnabled())
+        if (isDebugEnabled)
         {
-            logger.debug("Processing end of transaction commit");
+            logger.debug("Processing post-commit");
         }
         
         TransactionData txnData = getTransactionData();
@@ -527,7 +589,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
             {
                 // clear shared cache
                 sharedCache.clear();
-                if (logger.isDebugEnabled())
+                if (isDebugEnabled)
                 {
                     logger.debug("Clear notification recieved at end of transaction - clearing shared cache");
                 }
@@ -542,7 +604,7 @@ public class TransactionalCache<K extends Serializable, V extends Object>
                 {
                     sharedCache.remove(key);
                 }
-                if (logger.isDebugEnabled())
+                if (isDebugEnabled)
                 {
                     logger.debug("Removed " + keys.size() + " values from shared cache");
                 }
@@ -553,9 +615,10 @@ public class TransactionalCache<K extends Serializable, V extends Object>
             for (Serializable key : keys)
             {
                 Element element = txnData.updatedItemsCache.get(key);
-                sharedCache.put(key, element.getValue());
+                CacheBucket<V> bucket = (CacheBucket<V>) element.getObjectValue();
+                sharedCache.put(key, bucket.getValue());
             }
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("Added " + keys.size() + " values to shared cache");
             }
@@ -591,6 +654,206 @@ public class TransactionalCache<K extends Serializable, V extends Object>
         cacheManager.removeCache(txnData.removedItemsCache.getName());
     }
     
+    /**
+     * Interface for the transactional cache buckets.  These hold the actual values along
+     * with some state and behaviour around writing from the in-transaction caches to the
+     * shared.
+     * 
+     * @author Derek Hulley
+     */
+    private interface CacheBucket<BV extends Object> extends Serializable
+    {
+        /**
+         * @return                  Returns the bucket's value
+         */
+        BV getValue();
+        /**
+         * Check that any new cache values have not been superceded by new values in the shared cache.
+         * 
+         * @param sharedCache       the cache to check
+         * @param key               the key that the bucket was stored against
+         */
+        void doPreCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key);
+        /**
+         * Flush the current bucket to the shared cache as far as possible.
+         * 
+         * @param sharedCache       the cache to flush to
+         * @param key               the key that the bucket was stored against
+         */
+        public void doPostCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key);
+    }
+    
+    /**
+     * A bucket class to hold values for the caches.<br/>
+     * The cache ID and timestamp of the bucket is stored to ensure cache consistency.
+     * 
+     * @author Derek Hulley
+     */
+    private class NewCacheBucket<BV> implements CacheBucket<BV>
+    {
+        private static final long serialVersionUID = -8536386687213957425L;
+        
+        private final BV value;
+        public NewCacheBucket(BV value)
+        {
+            this.value = value;
+        }
+        public BV getValue()
+        {
+            return value;
+        }
+        public void doPreCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key)
+        {
+            if (sharedCache.contains(key))
+            {
+                // The shared cache has a value where there wasn't one before.  More than likely,
+                // this transaction would have used or modified that shared value.
+                throw new ConcurrencyFailureException(
+                        "New cache bucket found new shared cache entry: \n" +
+                        "   Cache: " + name + "\n" +
+                        "   Key:   " + key);
+                        
+            }
+        }
+        public void doPostCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key)
+        {
+            if (sharedCache.contains(key))
+            {
+                // The shared cache has a value where there wasn't one before.
+                // Just lose both of them.
+                sharedCache.remove(key);
+            }
+            else
+            {
+                // There is nothing in the shared cache, so add this entry
+                sharedCache.put(key, getValue());
+            }
+        }
+    }
+    
+    /**
+     * Data holder to keep track of a cached value's timestamps in order to detect stale
+     * shared cache values.  This bucket assumes the presence of a pre-existing entry in
+     * the shared cache.
+     */
+    private class UpdateCacheBucket<BV> extends NewCacheBucket<BV>
+    {
+        private static final long serialVersionUID = 7885689778259779578L;
+        
+        private final BV originalValue;
+        public UpdateCacheBucket(BV originalValue, BV value)
+        {
+            super(value);
+            this.originalValue = originalValue;
+        }
+        protected BV getOriginalValue()
+        {
+            return originalValue;
+        }
+        public void doPreCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key)
+        {
+            if (sharedCache.contains(key))
+            {
+                BV sharedValue = sharedCache.get(key);
+                if (sharedValue == getOriginalValue())
+                {
+                    // The cache entry is safe for writing
+                }
+                else
+                {
+                    // The shared value has moved on since
+                    throw new ConcurrencyFailureException(
+                            "Update cache bucket found newer shared cache entry: \n" +
+                            "   Cache: " + name + "\n" +
+                            "   Key:   " + key);
+                }
+            }
+            else
+            {
+                // The key was removed from the shared cache.  This instance cannot update the entry.
+                throw new ConcurrencyFailureException(
+                        "Update cache bucket couldn't fine entry to update: \n" +
+                        "   Cache: " + name + "\n" +
+                        "   Key:   " + key);
+            }
+        }
+        public void doPostCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key)
+        {
+            BV sharedValue = sharedCache.get(key);
+            if (sharedValue != null)
+            {
+                if (sharedValue == getOriginalValue())
+                {
+                    // The cache entry is safe for writing
+                    sharedCache.put(key, getValue());
+                }
+                else
+                {
+                    // The shared value has moved on since
+                    sharedCache.remove(key);
+                }
+            }
+            else
+            {
+                // The shared cache no longer has a value
+            }
+        }
+    }
+    
+    /**
+     * Data holder to keep track of cache removals.  This bucket assumes the previous existence
+     * of an entry in the shared cache.
+     */
+    private class RemoveCacheBucket<BV> extends UpdateCacheBucket<BV>
+    {
+        private static final long serialVersionUID = -7736719065158540252L;
+
+        public RemoveCacheBucket(BV originalValue)
+        {
+            super(originalValue, null);
+        }
+        public void doPreCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key)
+        {
+            BV sharedValue = sharedCache.get(key);
+            if (sharedValue != null)
+            {
+                if (sharedValue == getOriginalValue())
+                {
+                    // The shared cache entry is the same as the one we were flagged to remove
+                }
+                else
+                {
+                    // The shared value has moved on since
+                    throw new ConcurrencyFailureException(
+                            "Remove cache bucket found newer shared cache entry: \n" +
+                            "   Cache: " + name + "\n" +
+                            "   Key:   " + key);
+                }
+            }
+            else
+            {
+                // The shared cache no longer has the value.  It is possible that the removal of the
+                // item is something that would have affected the behaviour of the current transaction.
+                throw new ConcurrencyFailureException(
+                        "Remove cache bucket found new shared cache entry: \n" +
+                        "   Cache: " + name + "\n" +
+                        "   Key:   " + key);
+            }
+        }
+        public void doPostCommit(SimpleCache<Serializable, BV> sharedCache, Serializable key)
+        {
+            if (sharedCache.contains(key))
+            {
+                // We remove the shared entry whether it has moved on or not
+                sharedCache.remove(key);
+            }
+            else
+            {
+                // The shared cache no longer has a value
+            }
+        }
+    }
+    
     /** Data holder to bind data to the transaction */
     private class TransactionData
     {

source/java/org/alfresco/repo/domain/Node.java

@@ -71,7 +71,7 @@ public interface Node
 
     public Set<QName> getAspects();
     
-    public Collection<ChildAssoc> getParentAssocs();
+//    public Collection<ChildAssoc> getParentAssocs();
 
     public Map<QName, PropertyValue> getProperties();
 

source/java/org/alfresco/repo/domain/hibernate/ChildAssocImpl.java

@@ -71,13 +71,13 @@ public class ChildAssocImpl implements ChildAssoc, Serializable
         // add the forward associations
         this.setParent(parentNode);
         this.setChild(childNode);
-        childNode.getParentAssocs().add(this);
+//        childNode.getParentAssocs().add(this);
     }
     
     public void removeAssociation()
     {
-        // maintain inverse assoc from child node to this instance
+//        // maintain inverse assoc from child node to this instance
-        this.getChild().getParentAssocs().remove(this);
+//        this.getChild().getParentAssocs().remove(this);
     }
     
     public ChildAssociationRef getChildAssocRef()

source/java/org/alfresco/repo/domain/hibernate/HibernateNodeTest.java

@@ -45,6 +45,7 @@ import org.alfresco.repo.domain.Server;
 import org.alfresco.repo.domain.Store;
 import org.alfresco.repo.domain.StoreKey;
 import org.alfresco.repo.domain.Transaction;
+import org.alfresco.repo.node.db.hibernate.HibernateNodeDaoServiceImpl;
 import org.alfresco.repo.transaction.AlfrescoTransactionSupport;
 import org.alfresco.repo.transaction.TransactionListenerAdapter;
 import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
@@ -55,9 +56,11 @@ import org.alfresco.service.transaction.TransactionService;
 import org.alfresco.util.BaseSpringTest;
 import org.alfresco.util.GUID;
 import org.hibernate.CacheMode;
+import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.exception.ConstraintViolationException;
 import org.hibernate.exception.GenericJDBCException;
+import org.springframework.orm.hibernate3.HibernateCallback;
 
 /**
  * Test persistence and retrieval of Hibernate-specific implementations of the
@@ -292,7 +295,7 @@ public class HibernateNodeTest extends BaseSpringTest
         assertNotNull("Node not found", containerNode);
 
         // check that we can traverse the association from the child
-        Collection<ChildAssoc> parentAssocs = contentNode.getParentAssocs();
+        Collection<ChildAssoc> parentAssocs = getParentAssocs(contentNode);
         assertEquals("Expected exactly 2 parent assocs", 2, parentAssocs.size());
         parentAssocs = new HashSet<ChildAssoc>(parentAssocs);
         for (ChildAssoc assoc : parentAssocs)
@@ -304,10 +307,25 @@ public class HibernateNodeTest extends BaseSpringTest
         }
         
         // check that the child now has zero parents
-        parentAssocs = contentNode.getParentAssocs();
+        parentAssocs = getParentAssocs(contentNode);
         assertEquals("Expected exactly 0 parent assocs", 0, parentAssocs.size());
     }
     
+    @SuppressWarnings("unchecked")
+    private List<ChildAssoc> getParentAssocs(final Node childNode)
+    {
+        Query query = getSession()
+                .createQuery(
+                    "select assoc from org.alfresco.repo.domain.hibernate.ChildAssocImpl as assoc " +
+                    "where " +
+                    "   assoc.child.id = :childId " +
+                    "order by " +
+                    "assoc.index, assoc.id")
+                .setLong("childId", childNode.getId());
+        List<ChildAssoc> parentAssocs = query.list();
+        return parentAssocs;
+    }
+    
     /**
      * Allows tracing of L2 cache
      */

source/java/org/alfresco/repo/domain/hibernate/Node.hbm.xml

@@ -91,6 +91,7 @@
          <element column="qname" type="QName" length="200"/>
       </set>
       <!-- inverse assoc to parent childassocs -->
+<!--
       <set
             name="parentAssocs"
             inverse="true" 
@@ -101,6 +102,7 @@
          <key column="child_node_id" />
          <one-to-many class="org.alfresco.repo.domain.hibernate.ChildAssocImpl" />
       </set>
+-->
    </class>
 
    <class
@@ -236,6 +238,18 @@
          assoc.id = :childAssocId
    </query>
    
+   <query name="node.GetParentAssocs">
+      select
+         assoc
+      from
+         org.alfresco.repo.domain.hibernate.ChildAssocImpl as assoc
+      where
+         assoc.child.id = :childId
+      order by
+         assoc.index,
+         assoc.id
+   </query>
+   
    <query name="node.GetPrimaryChildNodeStatuses">
       select
          status
@@ -283,9 +297,9 @@
          assoc.id
    </query>
    
-   <query name="node.GetChildAssocByShortName">
+   <query name="node.GetChildAssocIdByShortName">
       select
-         assoc
+         assoc.id
       from
          org.alfresco.repo.domain.hibernate.ChildAssocImpl as assoc
       where

source/java/org/alfresco/repo/node/db/NodeDaoService.java

@@ -217,18 +217,18 @@ public interface NodeDaoService
     /**
      * Finds the association between the node's primary parent and the node itself
      * 
-     * @param node the child node
+     * @param childNode the child node
      * @return Returns the primary <code>ChildAssoc</code> instance where the given node is the child.
      *      The return value could be null for a root node - but ONLY a root node
      */
-    public ChildAssoc getPrimaryParentAssoc(Node node);
+    public ChildAssoc getPrimaryParentAssoc(Node childNode);
     
     /**
      * Get all parent associations for the node.  This methods includes a cache safety check.
-     * @param node the child node
+     * @param childNode the child node
      * @return Returns all parent associations for the node.
      */
-    public Collection<ChildAssoc> getParentAssocs(Node node);
+    public Collection<ChildAssoc> getParentAssocs(Node childNode);
     
     /**
      * @return Returns the persisted and filled association

source/java/org/alfresco/repo/node/db/hibernate/HibernateNodeDaoServiceImpl.java

@@ -37,6 +37,7 @@ import java.util.zip.CRC32;
 
 import org.alfresco.error.AlfrescoRuntimeException;
 import org.alfresco.model.ContentModel;
+import org.alfresco.repo.cache.SimpleCache;
 import org.alfresco.repo.domain.ChildAssoc;
 import org.alfresco.repo.domain.Node;
 import org.alfresco.repo.domain.NodeAssoc;
@@ -92,10 +93,11 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
     private static final String QUERY_GET_PRIMARY_CHILD_NODE_STATUSES = "node.GetPrimaryChildNodeStatuses";
     private static final String QUERY_GET_CHILD_ASSOCS = "node.GetChildAssocs";
     private static final String QUERY_GET_CHILD_ASSOCS_BY_ALL = "node.GetChildAssocsByAll";
-    private static final String QUERY_GET_CHILD_ASSOC_BY_NAME = "node.GetChildAssocByShortName";
+    private static final String QUERY_GET_CHILD_ASSOC_ID_BY_NAME = "node.GetChildAssocIdByShortName";
     private static final String QUERY_GET_CHILD_ASSOC_BY_TYPE_AND_NAME = "node.GetChildAssocByTypeAndName";
     private static final String QUERY_GET_CHILD_ASSOC_REFS = "node.GetChildAssocRefs";
     private static final String QUERY_GET_CHILD_ASSOC_REFS_BY_QNAME = "node.GetChildAssocRefsByQName";
+    private static final String QUERY_GET_PARENT_ASSOCS = "node.GetParentAssocs";
     private static final String QUERY_GET_NODE_ASSOC = "node.GetNodeAssoc";
     private static final String QUERY_GET_NODE_ASSOCS_TO_AND_FROM = "node.GetNodeAssocsToAndFrom";
     private static final String QUERY_GET_TARGET_ASSOCS = "node.GetTargetAssocs";
@@ -104,7 +106,13 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
     private static final String QUERY_GET_SERVER_BY_IPADDRESS = "server.getServerByIpAddress";
     
     private static Log logger = LogFactory.getLog(HibernateNodeDaoServiceImpl.class);
-    private static Log loggerChildAssoc = LogFactory.getLog(HibernateNodeDaoServiceImpl.class.getName() + ".ChildAssoc");
+    /** Log to trace parent association caching: <b>classname + .ParentAssocsCache</b> */
+    private static Log loggerParentAssocsCache = LogFactory.getLog(HibernateNodeDaoServiceImpl.class.getName() + ".ParentAssocsCache");
+    
+    /** A cache for more performant lookups of the parent associations */
+    private SimpleCache<Long, Set<Long>> parentAssocsCache;
+    private boolean isDebugEnabled = logger.isDebugEnabled();
+    private boolean isDebugParentAssocCacheEnabled = loggerParentAssocsCache.isDebugEnabled();
     
     /** a uuid identifying this unique instance */
     private final String uuid;
@@ -158,6 +166,16 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
         return uuid.hashCode();
     }
 
+    /**
+     * Set the transaction-aware cache to store parent associations by child node id
+     * 
+     * @param parentAssocsCache     the cache
+     */
+    public void setParentAssocsCache(SimpleCache<Long, Set<Long>> parentAssocsCache)
+    {
+        this.parentAssocsCache = parentAssocsCache;
+    }
+
     /**
      * Gets/creates the <b>server</b> instance to use for the life of this instance
      */
@@ -232,7 +250,7 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
             // bind the id
             AlfrescoTransactionSupport.bindResource(RESOURCE_KEY_TRANSACTION_ID, txnId);
             
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 if (!changeTxnIdSet.add(changeTxnId))
                 {
@@ -245,7 +263,7 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
         else
         {
             transaction = (Transaction) getHibernateTemplate().get(TransactionImpl.class, txnId);
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("Using existing transaction: " + transaction);
             }
@@ -476,19 +494,19 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
     private void deleteNodeInternal(Node node, boolean cascade, Set<Long> deletedChildAssocIds)
     {
         // delete all parent assocs
-        if (logger.isDebugEnabled())
+        if (isDebugEnabled)
         {
             logger.debug("Deleting parent assocs of node " + node.getId());
         }
         
-        Collection<ChildAssoc> parentAssocs = node.getParentAssocs();
+        Collection<ChildAssoc> parentAssocs = getParentAssocsInternal(node);
         parentAssocs = new ArrayList<ChildAssoc>(parentAssocs);
         for (ChildAssoc assoc : parentAssocs)
         {
             deleteChildAssocInternal(assoc, false, deletedChildAssocIds);  // we don't cascade upwards
         }
         // delete all child assocs
-        if (logger.isDebugEnabled())
+        if (isDebugEnabled)
         {
             logger.debug("Deleting child assocs of node " + node.getId());
         }
@@ -499,7 +517,7 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
             deleteChildAssocInternal(assoc, cascade, deletedChildAssocIds);   // potentially cascade downwards
         }
         // delete all node associations to and from
-        if (logger.isDebugEnabled())
+        if (isDebugEnabled)
         {
             logger.debug("Deleting source and target assocs of node " + node.getId());
         }
@@ -514,9 +532,16 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
         nodeStatus.setNode(null);
         nodeStatus.getTransaction().setChangeTxnId(AlfrescoTransactionSupport.getTransactionId());
         // finally delete the node
+        Long nodeId = node.getId();
         getHibernateTemplate().delete(node);
-//        // flush to ensure constraints can't be violated
+        // Remove node from cache
-//        getSession().flush();
+        parentAssocsCache.remove(nodeId);
+        if (isDebugParentAssocCacheEnabled)
+        {
+            loggerParentAssocsCache.debug("\n" +
+                    "Parent associations cache - Removing entry: \n" +
+                    "   Node:   " + nodeId);
+        }
         // done
     }
     
@@ -550,20 +575,6 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
             QName assocTypeQName,
             QName qname)
     {
-        /*
-         * This initial child association creation will fail IFF there is already
-         * an association of the given type and name between the two nodes.  For new association
-         * creation, this can only occur if two transactions attempt to create a secondary
-         * child association between the same two nodes.  As this is unlikely, it is
-         * appropriate to just throw a runtime exception and let the second transaction
-         * fail.
-         * 
-         * We don't need to flush the session beforehand as there won't be any deletions
-         * of the assocation pending.  The association deletes, on the other hand, have
-         * to flush early in order to ensure that the database unique index isn't violated
-         * if the association is recreated subsequently.
-         */
-        
         // assign a random name to the node
         String randomName = GUID.generate();
         
@@ -576,7 +587,24 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
         // maintain inverse sets
         assoc.buildAssociation(parentNode, childNode);
         // persist it
-        getHibernateTemplate().save(assoc);
+        Long assocId = (Long) getHibernateTemplate().save(assoc);
+        // Add it to the cache
+        Long childNodeId = childNode.getId();
+        Set<Long> oldParentAssocIds = parentAssocsCache.get(childNode.getId());
+        if (oldParentAssocIds != null)
+        {
+            Set<Long> newParentAssocIds = new HashSet<Long>(oldParentAssocIds);
+            newParentAssocIds.add(assocId);
+            parentAssocsCache.put(childNodeId, newParentAssocIds);
+            if (isDebugParentAssocCacheEnabled)
+            {
+                loggerParentAssocsCache.debug("\n" +
+                        "Parent associations cache - Updating entry: \n" +
+                        "   Node:   " + childNodeId +  "\n" +
+                        "   Before: " + oldParentAssocIds + "\n" +
+                        "   After:  " + newParentAssocIds);
+            }
+        }
         // done
         return assoc;
     }
@@ -622,7 +650,7 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
          * transactions modifying the unique index without this transaction's knowledge.
          */
         final Node parentNode = childAssoc.getParent();
-//        if (loggerChildAssoc.isDebugEnabled())
+//        if (loggerChildAssoc.Enabled())
 //        {
 //            loggerChildAssoc.debug(
 //                    "Locking parent node for modifying child assoc: \n" +
@@ -649,23 +677,23 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
             public Object doInHibernate(Session session)
             {
                 Query query = session
-                    .getNamedQuery(HibernateNodeDaoServiceImpl.QUERY_GET_CHILD_ASSOC_BY_NAME)
+                    .getNamedQuery(HibernateNodeDaoServiceImpl.QUERY_GET_CHILD_ASSOC_ID_BY_NAME)
                     .setLong("parentId", parentNode.getId())
                     .setParameter("childNodeName", childNameNewShort)
                     .setLong("childNodeNameCrc", childNameNewCrc);
                 return query.uniqueResult();
             }
         };
-        ChildAssoc childAssocExisting = (ChildAssoc) getHibernateTemplate().execute(callback);
+        Long childAssocIdExisting = (Long) getHibernateTemplate().execute(callback);
-        if (childAssocExisting != null)
+        if (childAssocIdExisting != null)
         {
             // There is already an entity
-            if (loggerChildAssoc.isDebugEnabled())
+            if (isDebugEnabled)
             {
-                loggerChildAssoc.debug(
+                logger.debug(
                         "Duplicate child association detected: \n" +
-                        "   Child Assoc:          " + childAssoc + "\n" +
+                        "   Existing Child Assoc: " + childAssocIdExisting + "\n" +
-                        "   Existing Child Assoc: " + childName);
+                        "   Assoc Name:           " + childName);
             }
             throw new DuplicateChildNodeNameException(
                     parentNode.getNodeRef(),
@@ -678,9 +706,9 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
         childAssoc.setChildNodeNameCrc(childNameNewCrc);
         
         // Done
-        if (loggerChildAssoc.isDebugEnabled())
+        if (isDebugEnabled)
         {
-            loggerChildAssoc.debug(
+            logger.debug(
                     "Updated child association: \n" +
                     "   Parent:      " + parentNode + "\n" +
                     "   Child Assoc: " + childAssoc);
@@ -881,33 +909,50 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
      * @param cascade true to cascade to the child node of the association
      * @param deletedChildAssocIds already-deleted associations
      */
-    private void deleteChildAssocInternal(ChildAssoc assoc, boolean cascade, Set<Long> deletedChildAssocIds)
+    private void deleteChildAssocInternal(final ChildAssoc assoc, boolean cascade, Set<Long> deletedChildAssocIds)
     {
         Long childAssocId = assoc.getId();
+        
         if (deletedChildAssocIds.contains(childAssocId))
         {
-            if (logger.isDebugEnabled())
+            if (isDebugEnabled)
             {
                 logger.debug("Ignoring parent-child association " + assoc.getId());
             }
             return;
         }
         
-        if (loggerChildAssoc.isDebugEnabled())
+        if (isDebugEnabled)
         {
-            loggerChildAssoc.debug(
+            logger.debug(
                     "Deleting parent-child association " + assoc.getId() +
                     (cascade ? " with" : " without") + " cascade:" +
                     assoc.getParent().getId() + " -> " + assoc.getChild().getId());
         }
 
         Node childNode = assoc.getChild();
+        Long childNodeId = childNode.getId();
+        
+        // Add remove the child association from the cache
+        Set<Long> oldParentAssocIds = parentAssocsCache.get(childNodeId);
+        if (oldParentAssocIds != null)
+        {
+            Set<Long> newParentAssocIds = new HashSet<Long>(oldParentAssocIds);
+            newParentAssocIds.remove(childAssocId);
+            parentAssocsCache.put(childNodeId, newParentAssocIds);
+            loggerParentAssocsCache.debug("\n" +
+                    "Parent associations cache - Updating entry: \n" +
+                    "   Node:   " + childNodeId +  "\n" +
+                    "   Before: " + oldParentAssocIds + "\n" +
+                    "   After:  " + newParentAssocIds);
+        }
         
         // maintain inverse association sets
         assoc.removeAssociation();
         // remove instance
         getHibernateTemplate().delete(assoc);
-        deletedChildAssocIds.add(childAssocId);         // ensure that we don't attempt to delete it twice
+        // ensure that we don't attempt to delete it twice
+        deletedChildAssocIds.add(childAssocId);
         
         if (cascade && assoc.getIsPrimary())   // the assoc is primary
         {
@@ -919,25 +964,97 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
              * duplicate call will be received to do this
              */
         }
-//        
+    }
-//        // To ensure the validity of the constraint enforcement by the database,
+
-//        // we have to flush here.  It is possible to delete and recreate the instance
+    /**
-//        getSession().flush();
+     * @param childNode         the child node
+     * @return                  Returns the parent associations without any interpretation
+     */
+    @SuppressWarnings("unchecked")
+    private Collection<ChildAssoc> getParentAssocsInternal(Node childNode)
+    {
+        final Long childNodeId = childNode.getId();
+        List<ChildAssoc> parentAssocs = null;
+        // First check the cache
+        Set<Long> parentAssocIds = parentAssocsCache.get(childNodeId);
+        if (parentAssocIds != null)
+        {
+            if (isDebugParentAssocCacheEnabled)
+            {
+                loggerParentAssocsCache.debug("\n" +
+                        "Parent associations cache - Hit: \n" +
+                        "   Node:   " + childNodeId + "\n" +
+                        "   Assocs: " + parentAssocIds);
+            }
+            parentAssocs = new ArrayList<ChildAssoc>(parentAssocIds.size());
+            for (Long parentAssocId : parentAssocIds)
+            {
+                ChildAssoc parentAssoc = (ChildAssoc) getSession().get(ChildAssocImpl.class, parentAssocId);
+                if (parentAssoc == null)
+                {
+                    // The cache is out of date, so just repopulate it
+                    parentAssoc = null;
+                    break;
+                }
+                else
+                {
+                    parentAssocs.add(parentAssoc);
+                }
+            }
+        }
+        // Did we manage to get the parent assocs
+        if (parentAssocs == null)
+        {
+            if (isDebugParentAssocCacheEnabled)
+            {
+                loggerParentAssocsCache.debug("\n" +
+                        "Parent associations cache - Miss: \n" +
+                        "   Node:   " + childNodeId + "\n" +
+                        "   Assocs: " + parentAssocIds);
+            }
+            HibernateCallback callback = new HibernateCallback()
+            {
+                public Object doInHibernate(Session session)
+                {
+                    Query query = session
+                        .getNamedQuery(HibernateNodeDaoServiceImpl.QUERY_GET_PARENT_ASSOCS)
+                        .setLong("childId", childNodeId);
+                    return query.list();
+                }
+            };
+            parentAssocs = (List) getHibernateTemplate().execute(callback);
+            // Populate the cache
+            parentAssocIds = new HashSet<Long>(parentAssocs.size());
+            for (ChildAssoc parentAssoc : parentAssocs)
+            {
+                parentAssocIds.add(parentAssoc.getId());
+            }
+            parentAssocsCache.put(childNodeId, parentAssocIds);
+            if (isDebugParentAssocCacheEnabled)
+            {
+                loggerParentAssocsCache.debug("\n" +
+                        "Parent associations cache - Adding entry: \n" +
+                        "   Node:   " + childNodeId + "\n" +
+                        "   Assocs: " + parentAssocIds);
+            }
+        }
+        // Done
+        return parentAssocs;
     }
     
     /**
      * @inheritDoc
      * 
-     * This method includes a check to ensure that the <b>parentAssocs</b> cache
+     * This includes a check to ensuret that only root nodes don't have primary parents
-     * isn't incorrectly empty.
      */
-    public Collection<ChildAssoc> getParentAssocs(Node node)
+    public Collection<ChildAssoc> getParentAssocs(final Node childNode)
     {
-        Collection<ChildAssoc> parentAssocs = node.getParentAssocs();
+        Collection<ChildAssoc> parentAssocs = getParentAssocsInternal(childNode);
+
         if (parentAssocs.size() == 0)
         {
             // the only condition where this is allowed is if the given node is a root node
-            Store store = node.getStore();
+            Store store = childNode.getStore();
             Node rootNode = store.getRootNode();
             if (rootNode == null)
             {
@@ -945,22 +1062,23 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
                 throw new DataIntegrityViolationException("Store has no root node: \n" +
                         "   store: " + store);
             }
-            if (!rootNode.equals(node))
+            if (!rootNode.equals(childNode))
             {
-                // Reload the node to ensure that it is properly initialized
+                parentAssocsCache.remove(childNode.getId());
-                getSession().refresh(node);
+                if (isDebugParentAssocCacheEnabled)
+                {
+                    loggerParentAssocsCache.debug("\n" +
+                            "Parent associations cache - Removing entry: \n" +
+                            "   Node:   " + childNode.getId());
+                }
+                parentAssocs = getParentAssocsInternal(childNode);
                 // Check if it has any parents yet.
-                if (node.getParentAssocs().size() == 0)
+                if (parentAssocs.size() == 0)
                 {
                     // It wasn't the root node and definitely has no parent
                     throw new DataIntegrityViolationException(
                             "Non-root node has no primary parent: \n" +
-                            "   child: " + node);
+                            "   child: " + childNode);
-                }
-                else
-                {
-                    // Repeat this method with confidence
-                    return getParentAssocs(node);
                 }
             }
         }
@@ -977,10 +1095,10 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
      * the error.  It is up to the administrator to fix the issue at the moment, but
      * the server will not stop working.
      */
-    public ChildAssoc getPrimaryParentAssoc(Node node)
+    public ChildAssoc getPrimaryParentAssoc(Node childNode)
     {
         // get the assocs pointing to the node
-        Collection<ChildAssoc> parentAssocs = node.getParentAssocs();
+        Collection<ChildAssoc> parentAssocs = getParentAssocs(childNode);
         ChildAssoc primaryAssoc = null;
         for (ChildAssoc assoc : parentAssocs)
         {
@@ -994,7 +1112,7 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
                 // We have found one already.
                 synchronized(warnedDuplicateParents)
                 {
-                    NodeRef childNodeRef = node.getNodeRef();
+                    NodeRef childNodeRef = childNode.getNodeRef();
                     boolean added = warnedDuplicateParents.add(childNodeRef);
                     if (added)
                     {
@@ -1009,37 +1127,6 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
             primaryAssoc = assoc;
             // we keep looping to hunt out data integrity issues
         }
-        // did we find a primary assoc?
-        if (primaryAssoc == null)
-        {
-            // the only condition where this is allowed is if the given node is a root node
-            Store store = node.getStore();
-            Node rootNode = store.getRootNode();
-            if (rootNode == null)
-            {
-                // a store without a root node - the entire store is hosed
-                throw new DataIntegrityViolationException("Store has no root node: \n" +
-                        "   store: " + store);
-            }
-            if (!rootNode.equals(node))
-            {
-                // Reload the node to ensure that it is properly initialized
-                getSession().refresh(node);
-                // Check if it has any parents yet.
-                if (node.getParentAssocs().size() == 0)
-                {
-                    // It wasn't the root node and definitely has no parent
-                    throw new DataIntegrityViolationException(
-                            "Non-root node has no primary parent: \n" +
-                            "   child: " + node);
-                }
-                else
-                {
-                    // Repeat this method with confidence
-                    primaryAssoc = getPrimaryParentAssoc(node);
-                }
-            }
-        }
         // done
         return primaryAssoc;
     }
@@ -1142,9 +1229,6 @@ public class HibernateNodeDaoServiceImpl extends HibernateDaoSupport implements
     {
         // Remove instance
         getHibernateTemplate().delete(assoc);
-//        // Flush to ensure that the database constraints aren't violated if the assoc
-//        // is recreated in the transaction
-//        getSession().flush();
     }
 
     public List<Serializable> getPropertyValuesByActualType(DataTypeDefinition actualDataTypeDefinition)

source/java/org/alfresco/repo/transaction/RetryingTransactionHelper.java

@@ -24,6 +24,7 @@
  */
 package org.alfresco.repo.transaction;
 
+import java.sql.BatchUpdateException;
 import java.util.Random;
 
 import javax.transaction.Status;
@@ -62,7 +63,8 @@ public class RetryingTransactionHelper
                 ConcurrencyFailureException.class,
                 DeadlockLoserDataAccessException.class,
                 StaleObjectStateException.class,
-                LockAcquisitionException.class
+                LockAcquisitionException.class,
+                BatchUpdateException.class
                 };
     }
     
@@ -274,7 +276,7 @@ public class RetryingTransactionHelper
                 lastException = (e instanceof RuntimeException) ? 
                         (RuntimeException)e : new AlfrescoRuntimeException("Unknown Exception in Transaction.", e);
                 // Check if there is a cause for retrying
-                Throwable retryCause = ExceptionStackUtil.getCause(e, RETRY_EXCEPTIONS);
+                Throwable retryCause = extractRetryCause(e);
                 if (retryCause != null)
                 {
                     // Sleep a random amount of time before retrying.
@@ -301,4 +303,36 @@ public class RetryingTransactionHelper
         // So, fail.
         throw lastException;
     }
+    
+    /**
+     * Sometimes, the exception means retry and sometimes not.
+     * 
+     * @param cause     the cause to examine
+     * @return          Returns the original cause if it is a valid retry cause, otherwise <tt>null</tt>
+     */
+    private Throwable extractRetryCause(Throwable cause)
+    {
+        Throwable retryCause = ExceptionStackUtil.getCause(cause, RETRY_EXCEPTIONS);
+        if (retryCause == null)
+        {
+            return null;
+        }
+        else if (retryCause instanceof BatchUpdateException)
+        {
+            if (retryCause.getMessage().contains("Lock wait"))
+            {
+                // It is valid
+                return retryCause;
+            }
+            else
+            {
+                // Not valid
+                return null;
+            }
+        }
+        else
+        {
+            return retryCause;
+        }
+    }
 }

source/java/org/alfresco/repo/transaction/TransactionUtil.java

@@ -203,7 +203,7 @@ public class TransactionUtil
         {
             // commit failed
             throw new AlfrescoRuntimeException(
-                    "Unexpected rollback of exception: \n" + exception.getMessage(),
+                    "Unexpected rollback exception: \n" + exception.getMessage(),
                     exception);
         }
         catch (Throwable exception)

source/java/org/alfresco/repo/version/BaseVersionStoreTest.java

@@ -36,6 +36,7 @@ import org.alfresco.repo.dictionary.DictionaryDAO;
 import org.alfresco.repo.dictionary.M2Model;
 import org.alfresco.repo.node.archive.NodeArchiveService;
 import org.alfresco.repo.security.authentication.MutableAuthenticationDao;
+import org.alfresco.repo.transaction.RetryingTransactionHelper;
 import org.alfresco.repo.version.common.counter.VersionCounterService;
 import org.alfresco.repo.version.common.versionlabel.SerialVersionLabelPolicy;
 import org.alfresco.service.cmr.repository.ContentData;
@@ -64,6 +65,7 @@ public abstract class BaseVersionStoreTest extends BaseSpringTest
 	protected DictionaryDAO dictionaryDAO;
     protected AuthenticationService authenticationService;
     protected TransactionService transactionService;
+    protected RetryingTransactionHelper txnHelper;
     protected MutableAuthenticationDao authenticationDAO;
     protected NodeArchiveService nodeArchiveService;
     protected NodeService nodeService;
@@ -146,6 +148,7 @@ public abstract class BaseVersionStoreTest extends BaseSpringTest
         this.contentService = (ContentService)applicationContext.getBean("contentService");
         this.authenticationService = (AuthenticationService)applicationContext.getBean("authenticationService");
         this.transactionService = (TransactionService)this.applicationContext.getBean("transactionComponent");
+        this.txnHelper = (RetryingTransactionHelper) applicationContext.getBean("retryingTransactionHelper");
         this.authenticationDAO = (MutableAuthenticationDao) applicationContext.getBean("alfDaoImpl");
         this.nodeArchiveService = (NodeArchiveService) applicationContext.getBean("nodeArchiveService");
         this.nodeService = (NodeService)applicationContext.getBean("nodeService");

source/java/org/alfresco/repo/version/VersionServiceImplTest.java

@@ -35,6 +35,7 @@ import org.alfresco.model.ApplicationModel;
 import org.alfresco.model.ContentModel;
 import org.alfresco.repo.security.authentication.AuthenticationComponent;
 import org.alfresco.repo.transaction.TransactionUtil;
+import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
 import org.alfresco.service.ServiceRegistry;
 import org.alfresco.service.cmr.model.FileFolderService;
 import org.alfresco.service.cmr.model.FileInfo;
@@ -256,7 +257,7 @@ public class VersionServiceImplTest extends BaseVersionStoreTest
      * Test revert
      */
     @SuppressWarnings("unused")
-    public void xtestRevert()
+    public void testRevert()
     {
     	// Create a versionable node
     	NodeRef versionableNode = createNewVersionableNode();
@@ -688,9 +689,9 @@ public class VersionServiceImplTest extends BaseVersionStoreTest
             }
         });
         
-        TransactionUtil.executeInUserTransaction(this.transactionService, new TransactionUtil.TransactionWork<Object>()
+        txnHelper.doInTransaction(new RetryingTransactionCallback<Object>()
         {
-            public Object doWork() throws Exception
+            public Object execute() throws Exception
             {
             	// Get the archived noderef
             	NodeRef archivedNodeRef = VersionServiceImplTest.this.nodeArchiveService.getArchivedNode(nodeRef);