Use recursion guard

Author: jjezra

fdb-record-layer-lucene/src/main/java/com/apple/foundationdb/record/lucene/directory/FDBDirectoryLockFactory.java

@@ -92,6 +92,7 @@ protected static class FDBDirectoryLock extends Lock {
          */
         private FDBRecordContext closingContext = null;
         private final Object fileLockSetLock = new Object();
+        private boolean clearingLockNow = false;
 
         private FDBDirectoryLock(final AgilityContext agilityContext, final String lockName, byte[] fileLockKey, int timeWindowMilliseconds) {
             this.agilityContext = agilityContext;
@@ -209,45 +210,54 @@ private void fileLockCheckNewLock(byte[] val, long nowMillis) {
             }
         }
 
+        private synchronized boolean inRecursiveClearLock() {
+            if (clearingLockNow) {
+                return true;
+            }
+            clearingLockNow = true;
+            return false;
+        }
+
         private void fileLockClearFlushAndClose(boolean isRecovery) {
-            synchronized (fileLockSetLock) {
-                // If called by multiple threads, it seems to be a good idea to block all and allow one of them to do the actual closing.
-                if (closed) {
-                    return;
-                }
-                Function<FDBRecordContext, CompletableFuture<Void>> fileLockFunc = aContext ->
-                        aContext.ensureActive().get(fileLockKey)
-                                .thenAccept(val -> {
+            if (inRecursiveClearLock()) {
+                // Here: this function is being called from too many paths. Until cleanup, this guard is here to avoid recursions
+                return;
+            }
+            Function<FDBRecordContext, CompletableFuture<Void>> fileLockFunc = aContext ->
+                    aContext.ensureActive().get(fileLockKey)
+                            .thenAccept(val -> {
+                                synchronized (fileLockSetLock) {
                                     UUID existingUuid = fileLockValueToUuid(val);
                                     if (existingUuid != null && existingUuid.compareTo(selfStampUuid) == 0) {
                                         // clear the lock if locked and matches uuid
                                         aContext.ensureActive().clear(fileLockKey);
                                         closingContext = aContext;
                                         logSelf(isRecovery ? "FileLock: Cleared in Recovery path" : "FileLock: Cleared");
-                                    } else if (!isRecovery) {
+                                    } else if (! isRecovery) {
                                         throw new AlreadyClosedException("FileLock: Expected to be locked during close.This=" + this + " existingUuid=" + existingUuid); // The string append methods should handle null arguments.
                                     }
-                                });
+                                }
+                            });
 
-                if (agilityContext.isClosed()) {
-                    // Here: this is considered to be a recovery path, may bypass closed context.
-                    agilityContext.asyncToSync(LuceneEvents.Waits.WAIT_LUCENE_FILE_LOCK_CLEAR,
-                            agilityContext.applyInRecoveryPath(fileLockFunc));
-                } else {
-                    // Here: this called during directory close to ensure cleared lock -
-                    agilityContext.asyncToSync(LuceneEvents.Waits.WAIT_LUCENE_FILE_LOCK_CLEAR,
-                            agilityContext.apply(fileLockFunc));
-                }
-                agilityContext.recordEvent(LuceneEvents.Events.LUCENE_FILE_LOCK_DURATION, System.nanoTime() - lockStartTime);
-                boolean flushed = false;
-                try {
-                    closed = true; // prevent lock stamp update
-                    agilityContext.flush();
-                    flushed = true;
-                } finally {
-                    closed = flushed; // allow close retry
-                    closingContext = null;
-                }
+            if (agilityContext.isClosed()) {
+                // Here: this is considered to be a recovery path, may bypass closed context.
+                agilityContext.asyncToSync(LuceneEvents.Waits.WAIT_LUCENE_FILE_LOCK_CLEAR,
+                        agilityContext.applyInRecoveryPath(fileLockFunc));
+            } else {
+                // Here: this called during directory close to ensure cleared lock -
+                agilityContext.asyncToSync(LuceneEvents.Waits.WAIT_LUCENE_FILE_LOCK_CLEAR,
+                        agilityContext.apply(fileLockFunc));
+            }
+            agilityContext.recordEvent(LuceneEvents.Events.LUCENE_FILE_LOCK_DURATION, System.nanoTime() - lockStartTime);
+            boolean flushed = false;
+            try {
+                closed = true; // prevent lock stamp update
+                agilityContext.flush();
+                flushed = true;
+            } finally {
+                closed = flushed; // allow close retry
+                closingContext = null;
+                clearingLockNow = false;
             }
         }