PR Feedback.

Author: kinyoklion

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/FDv2DataSource.java

@@ -25,7 +25,7 @@ class FDv2DataSource implements DataSource {
     /**
      * Default fallback timeout of 2 minutes. The timeout is only configurable for testing.
      */
-    private static final int defaultFallbackTimeout = 2 * 60;
+    private static final int defaultFallbackTimeoutSeconds = 2 * 60;
 
     /**
      * Default recovery timeout of 5 minutes. The timeout is only configurable for testing.
@@ -64,7 +64,7 @@ public FDv2DataSource(
             threadPriority,
             logger,
             sharedExecutor,
-            defaultFallbackTimeout,
+            defaultFallbackTimeoutSeconds,
             defaultRecoveryTimeout
         );
     }
@@ -217,6 +217,10 @@ private boolean runSynchronizers() {
                                 break;
                             }
 
+                            if(!(res instanceof FDv2SourceResult)) {
+                                logger.error("Unexpected result type from synchronizer: {}", res.getClass().getName());
+                                continue;
+                            }
 
                             FDv2SourceResult result = (FDv2SourceResult) res;
                             conditions.inform(result);

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/FDv2DataSourceConditions.java

@@ -120,9 +120,6 @@ public FallbackCondition(ScheduledExecutorService sharedExecutor, long timeoutSe
 
         @Override
         public void inform(FDv2SourceResult sourceResult) {
-            if (sourceResult == null) {
-                return;
-            }
             if (sourceResult.getResultType() == FDv2SourceResult.ResultType.CHANGE_SET) {
                 if (timerFuture != null) {
                     timerFuture.cancel(false);

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/SynchronizerStateManager.java

@@ -52,24 +52,24 @@ public SynchronizerFactoryWithState getNextAvailableSynchronizer() {
         synchronized (activeSourceLock) {
             SynchronizerFactoryWithState factory = null;
 
-            // There is at least one available factory.
-            if(synchronizers.stream().anyMatch(s -> s.getState() == SynchronizerFactoryWithState.State.Available)) {
+            int visited = 0;
+            while(visited < synchronizers.size()) {
                 // Look for the next synchronizer starting at the position after the current one. (avoiding just re-using the same synchronizer.)
-                while(factory == null) {
-                    sourceIndex++;
-                    // We aren't using module here because we want to keep the stored index within range instead
-                    // of increasing indefinitely.
-                    if(sourceIndex >= synchronizers.size()) {
-                        sourceIndex = 0;
-                    }
-                    SynchronizerFactoryWithState candidate = synchronizers.get(sourceIndex);
-                    if (candidate.getState() == SynchronizerFactoryWithState.State.Available) {
-                        factory = candidate;
-                    }
+                sourceIndex++;
 
+                // We aren't using module here because we want to keep the stored index within range instead
+                // of increasing indefinitely.
+                if(sourceIndex >= synchronizers.size()) {
+                    sourceIndex = 0;
                 }
-            }
 
+                SynchronizerFactoryWithState candidate = synchronizers.get(sourceIndex);
+                if (candidate.getState() == SynchronizerFactoryWithState.State.Available) {
+                    factory = candidate;
+                    break;
+                }
+                visited++;
+            }
             return factory;
         }
     }
@@ -80,15 +80,11 @@ public SynchronizerFactoryWithState getNextAvailableSynchronizer() {
      */
     public boolean isPrimeSynchronizer() {
         synchronized (activeSourceLock) {
-            boolean firstAvailableSynchronizer = true;
             for (int index = 0; index < synchronizers.size(); index++) {
                 if (synchronizers.get(index).getState() == SynchronizerFactoryWithState.State.Available) {
-                    if (firstAvailableSynchronizer && sourceIndex == index) {
-                        // This is the first synchronizer that is available, and it also is the current one.
+                    if (sourceIndex == index) {
                         return true;
                     }
-                    // Subsequently encountered synchronizers that are available are not the first one.
-                    firstAvailableSynchronizer = false;
                 }
             }
         }