just using TimeoutExecutor

Author: abelonogov-ld

LaunchDarkly/LaunchDarkly/LDClient.swift

@@ -855,20 +855,36 @@ public class LDClient {
             start(serviceFactory: serviceFactory, config: config, context: context)
             completion?(true) // offline is considered a short circuited timed out case
         } else {
-            let startTime = Date().timeIntervalSince1970
+           // let startTime = Date().timeIntervalSince1970
 
             TimeoutExecutor.run(
                 timeout: startWaitSeconds,
                 queue: internalCompletedQueue,
                 operation: { done in
-                    Self.start(serviceFactory: serviceFactory, config: config, context: context) {
-                        let onTime = startWaitSeconds > Date().timeIntervalSince1970 - startTime
-                        done(!onTime)
+                    start(serviceFactory: serviceFactory, config: config, context: context) {
+//                        let onTime = startWaitSeconds > Date().timeIntervalSince1970 - startTime
+                        done(false)
                     }
                 },
                 timeoutValue: true,
                 completion: completion
             )
+            
+//            var completed = false
+//            start(serviceFactory: serviceFactory, config: config, context: context) {
+//                internalCompletedQueue.async {
+//                    if startTime + startWaitSeconds > Date().timeIntervalSince1970 && !completed {
+//                        completed = true
+//                        completion?(false) // false for not timedOut
+//                    }
+//                }
+//            }
+//            internalCompletedQueue.asyncAfter(deadline: .now() + startWaitSeconds) {
+//                if !completed {
+//                    completed = true
+//                    completion?(true) // true for timedOut
+//                }
+//            }
         }
     }
 

LaunchDarkly/LaunchDarkly/ServiceObjects/TimeoutExecutor.swift

@@ -43,7 +43,8 @@ final class TimeoutExecutor {
         let lockQueue = DispatchQueue(label: "launchdarkly.timeout.executor.lock")
         var finished = false
 
-        func finish(_ value: @autoclosure () -> T) {
+        // Start the user operation
+        operation { value in
             var shouldCall = false
             lockQueue.sync {
                 if !finished {
@@ -52,17 +53,20 @@ final class TimeoutExecutor {
                 }
             }
             guard shouldCall else { return }
-            queue.async { completion(timeoutValue()) }
-        }
-
-        // Start the user operation (they can call `done` from any queue)
-        operation { value in
-            finish(value)
+            queue.async { completion(value) }
         }
 
-        // Timeout fallback scheduled
+        // Timeout fallback
         queue.asyncAfter(deadline: .now() + timeout) {
-            finish(timeoutValue())
+            var shouldCall = false
+            lockQueue.sync {
+                if !finished {
+                    finished = true
+                    shouldCall = true
+                }
+            }
+            guard shouldCall else { return }
+            completion(timeoutValue())
         }
     }
 }

LaunchDarkly/LaunchDarklyTests/LDClientSpec.swift

@@ -326,12 +326,20 @@ final class LDClientSpec: QuickSpec {
                 }
             }
             context("after receiving flags") {
+                beforeEach {
+                    completed = false
+                    didTimeOut = nil
+                    startTime = nil
+                    completeTime = nil
+                }
                 it("does complete without timeout") {
+                    //expect(didTimeOut) == nil
                     testContext.start(completion: startCompletion)
                     testContext.onSyncComplete?(.flagCollection((FeatureFlagCollection([:]), nil)))
                     expect(completed).toEventually(beTrue(), timeout: DispatchTimeInterval.seconds(2))
                 }
                 it("does complete with timeout") {
+                    //expect(didTimeOut) == nil
                     waitUntil(timeout: .seconds(3)) { done in
                         testContext.start(timeOut: 5.0, timeOutCompletion: startTimeoutCompletion(done))
                         testContext.onSyncComplete?(.flagCollection((FeatureFlagCollection([:]), nil)))