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/RetryingTransactionHelper.java

@@ -54,8 +54,21 @@ import org.springframework.jdbc.UncategorizedSQLException;
  * A helper that runs a unit of work inside a UserTransaction,
  * transparently retrying the unit of work if the cause of
  * failure is an optimistic locking or deadlock condition.
+ * <p>
+ * Defaults:
+ * <ul>
+ *   <li><b>maxRetries: 20</b></li>
+ *   <li><b>minRetryWaitMs: 100</b></li>
+ *   <li><b>maxRetryWaitMs: 2000</b></li>
+ *   <li><b>retryWaitIncrementMs: 100</b></li>
+ * </ul>
+ * <p>
+ * To get details of 'why' transactions are retried use the following log level:<br>
+ * <b>Summary: log4j.logger.org.alfresco.repo.transaction.RetryingTransactionHelper=INFO</b><br>
+ * <b>Details: log4j.logger.org.alfresco.repo.transaction.RetryingTransactionHelper=DEBUG</b><br>
+ * 
  *
- * @author britt
+ * @author Derek Hulley
  */
 public class RetryingTransactionHelper
 {
@@ -90,16 +103,20 @@ public class RetryingTransactionHelper
      */
     private TransactionService txnService;
 
-    /**
-     * The maximum number of retries. -1 for infinity.
-     */
+    /** The maximum number of retries. -1 for infinity. */
     private int maxRetries;
-
+    /** The minimum time to wait between retries. */
+    private int minRetryWaitMs;
+    /** The maximum time to wait between retries. */
+    private int maxRetryWaitMs;
+    /** How much to increase the wait time with each retry. */
+    private int retryWaitIncrementMs;
+    
     /**
      * Whether the the transactions may only be reads
      */
     private boolean readOnly;
-
+    
     /**
      * Random number generator for retry delays.
      */
@@ -126,6 +143,10 @@ public class RetryingTransactionHelper
     public RetryingTransactionHelper()
     {
         this.random = new Random(System.currentTimeMillis());
+        this.maxRetries = 20;
+        this.minRetryWaitMs = 100;
+        this.maxRetryWaitMs = 2000;
+        this.retryWaitIncrementMs = 100;
     }
 
     // Setters.
@@ -145,6 +166,21 @@ public class RetryingTransactionHelper
         this.maxRetries = maxRetries;
     }
 
+    public void setMinRetryWaitMs(int minRetryWaitMs)
+    {
+        this.minRetryWaitMs = minRetryWaitMs;
+    }
+
+    public void setMaxRetryWaitMs(int maxRetryWaitMs)
+    {
+        this.maxRetryWaitMs = maxRetryWaitMs;
+    }
+
+    public void setRetryWaitIncrementMs(int retryWaitIncrementMs)
+    {
+        this.retryWaitIncrementMs = retryWaitIncrementMs;
+    }
+
     /**
      * Set whether this helper only supports read transactions.
      */
@@ -332,9 +368,22 @@ public class RetryingTransactionHelper
                 {
                     // Sleep a random amount of time before retrying.
                     // The sleep interval increases with the number of retries.
+                    int sleepIntervalRandom = count > 0 ? random.nextInt(count * retryWaitIncrementMs) : minRetryWaitMs;
+                    int sleepInterval = Math.min(maxRetryWaitMs, sleepIntervalRandom);
+                    sleepInterval = Math.max(sleepInterval, minRetryWaitMs);
+                    if (logger.isInfoEnabled() && !logger.isDebugEnabled())
+                    {
+                        String msg = String.format(
+                                "Retrying %s: count %2d; wait: %1.1fs; msg: \"%s\"; exception: (%s)",
+                                Thread.currentThread().getName(),
+                                count, (double)sleepInterval/1000D,
+                                retryCause.getMessage(),
+                                retryCause.getClass().getName());
+                        logger.info(msg);
+                    }
                     try
                     {
-                        Thread.sleep(random.nextInt(500 * count + 500));
+                        Thread.sleep(sleepInterval);
                     }
                     catch (InterruptedException ie)
                     {