Merged V2.9 to HEAD

9845: Merged V2.2 to V2.9
      9733: Merged V2.1 to V2.2
         9281: Improvements to index AUTO recovery
         9316: Fixed ETWOONE-193: Transactional caches not being cleaned up after rollback (2.1.4 regression)
         9317: Fixed ETWOONE-194: Faster void handling during index tracking
         9365: Improved performance for finding which snapshots have been indexed
         9413: Support to retrieve read/write state of the transaction and ensure Lucene commits are handled last
         9414: ACT-3245: Updating node properties and aspects don't bump the alf_node.version value
         9415: Code cleanup: Removed unnecessary empty methods
         9416: Fixed creation of multiple thread pools
         9417: Full index recovery absorbs indexing exceptions by default
         9418: Added AUTO index recovery option to sample in line with Wiki docs
         9419: ETWOONE-194: Index tracking is too slow
         9420: Fixed ETWOONE-201: Better logging and configurability for RetryingTransactionHelper
         9421: Fixed ETWOONE-202: SPlit person cleanup doesn't break read-only transactions
         9422: Follow up on CHK-3317: Removed use of JDK 1.6 NavigableMap interface
         9423: Fixed unit test after CHK-3317
         9424: More test fixes after CHK-3317
         9425: Ensure that index tracking tests don't run too long.
         9426: Made concurrent reindexing optional.  It is on by default.
         9509: ACT-3539: Mid-transaction locking on Lucene resources
         9547: Multithreaded index tracking startup: Handle previously lagging single-threaded rebuilds


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

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

@@ -33,14 +33,19 @@ import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.transaction.TransactionDefinition;
 
 /**
- * Default implementation of Transaction Service
+ * Default implementation of Transaction Service.
+ * <p>
+ * Default retry behaviour: see {@link RetryingTransactionHelper#RetryingTransactionHelper()}
  * 
  * @author David Caruana
  */
 public class TransactionServiceImpl implements TransactionService
 {
     private PlatformTransactionManager transactionManager;
-    private int maxRetries = 20;
+    private int maxRetries = -1;
+    private int minRetryWaitMs = -1;
+    private int maxRetryWaitMs = -1;
+    private int retryWaitIncrementMs = -1;
     
     // SysAdmin cache - used to cluster certain JMX operations
     private SimpleCache<String, Object> sysAdminCache;
@@ -79,16 +84,37 @@ public class TransactionServiceImpl implements TransactionService
     }
     
     /**
-     * Set the maximum number of retries that will be done by the
-     * {@link RetryingTransactionHelper transaction helper}.
-     * 
-     * @param maxRetries    the maximum transaction retries
+     * @see RetryingTransactionHelper#setMaxRetries(int)
      */
     public void setMaxRetries(int maxRetries)
     {
         this.maxRetries = maxRetries;
     }
 
+    /**
+     * @see RetryingTransactionHelper#setMinRetryWaitMs(int)
+     */
+    public void setMinRetryWaitMs(int minRetryWaitMs)
+    {
+        this.minRetryWaitMs = minRetryWaitMs;
+    }
+
+    /**
+     * @see RetryingTransactionHelper#setMaxRetryWaitMs(int)
+     */
+    public void setMaxRetryWaitMs(int maxRetryWaitMs)
+    {
+        this.maxRetryWaitMs = maxRetryWaitMs;
+    }
+
+    /**
+     * @see RetryingTransactionHelper#setRetryWaitIncrementMs(int)
+     */
+    public void setRetryWaitIncrementMs(int retryWaitIncrementMs)
+    {
+        this.retryWaitIncrementMs = retryWaitIncrementMs;
+    }
+
     /**
      * @see org.springframework.transaction.TransactionDefinition#PROPAGATION_REQUIRED
      */
@@ -146,14 +172,30 @@ public class TransactionServiceImpl implements TransactionService
     }
 
     /**
-     * Creates a new helper instance.  It can be reused.
+     * Creates a new helper instance.  It can be reused or customized by the client code:
+     * each instance is new and initialized afresh.
      */
     public RetryingTransactionHelper getRetryingTransactionHelper()
     {
         RetryingTransactionHelper helper = new RetryingTransactionHelper();
-        helper.setMaxRetries(maxRetries);
         helper.setTransactionService(this);
         helper.setReadOnly(isReadOnly());
+        if (maxRetries >= 0)
+        {
+            helper.setMaxRetries(maxRetries);
+        }
+        if (minRetryWaitMs > 0)
+        {
+            helper.setMinRetryWaitMs(minRetryWaitMs);
+        }
+        if (maxRetryWaitMs > 0)
+        {
+            helper.setMaxRetryWaitMs(maxRetryWaitMs);
+        }
+        if (retryWaitIncrementMs > 0)
+        {
+            helper.setRetryWaitIncrementMs(retryWaitIncrementMs);
+        }
         return helper;
     }
 }