Fix race condition when searching while activating mirrored mode

Although instantiation of `MirroredIndex.localIndex` was conditioned to setting `MirroredIndex.mirrored` to true, and although `mirrored`’s accessors were synchronized, the instantiation itself was not part of the critical section. This led to a race condition when `search(…)` is called from another thread after `mirrored` has been set but before `localIndex` has been instantiated.

NOTE: I had to give up deallocating the local index when setting `mirrored` back to false, because mixed operations or a sync may still be ongoing. Keeping it alive until all operations have completed would be extremely complicated and not worth it, because there is anyway little point in disabling mirrored mode once it has been activated. This flag is merely so that purely online indices can still be used with an `OfflineClient`.

Fixes #285.

Author: Clément Le Provost

Source/Helpers.swift

@@ -128,12 +128,12 @@ extension NSObject {
     ///
     /// - paremeter block: Block to be executed serially on the object.
     ///
-    func synchronized(_ block: () -> ()) {
+    func synchronized<T>(_ block: () -> T) -> T {
         objc_sync_enter(self)
         defer {
             objc_sync_exit(self)
         }
-        block()
+        return block()
     }
 }
 

Source/Offline/MirroredIndex.swift

@@ -196,30 +196,41 @@ import Foundation
     let mirrorSettings = MirrorSettings()
 
     /// Whether the index is mirrored locally. Default = false.
-    @objc public var mirrored: Bool = false {
+    ///
+    /// + Note: Setting this property to `true` create the resources required to access the local mirror.
+    ///   Setting it to `false` does *not* deallocate those resources.
+    ///
+    @objc public var mirrored: Bool {
+        get {
+            return self.synchronized { self._mirrored }
+        }
+        set {
+            self.synchronized { self._mirrored = newValue }
+        }
+    }
+    
+    /// Storage for the `mirrored` property.
+    ///
+    /// + Warning: **DO NOT** ACCESS THIS VARIABLE DIRECTLY.
+    ///
+    private var _mirrored: Bool = false {
+        // NOTE: Synchronization performed by the `mirrored` property.
         didSet {
-            if (mirrored) {
+            if (_mirrored) {
                 do {
                     try FileManager.default.createDirectory(atPath: self.indexDataDir, withIntermediateDirectories: true, attributes: nil)
                     // Lazy instantiate the local index.
-                    self.synchronized {
-                        if (self.localIndex == nil) {
-                            self.localIndex = LocalIndex(dataDir: self.offlineClient.rootDataDir, appID: self.client.appID, indexName: self.name)
-                        }
+                    if (self.localIndex == nil) {
+                        self.localIndex = LocalIndex(dataDir: self.offlineClient.rootDataDir, appID: self.client.appID, indexName: self.name)
                     }
                 } catch _ {
                     // Ignore
                 }
                 mirrorSettings.load(self.mirrorSettingsFilePath)
-            } else {
-                // Release the local index.
-                self.synchronized {
-                    self.localIndex = nil
-                }
             }
         }
     }
-    
+
     /// Data selection queries.
     @objc public var dataSelectionQueries: [DataSelectionQuery] {
         get {
@@ -646,7 +657,6 @@ import Foundation
         private var mayRunOfflineRequest: Bool = true
 
         init(index: MirroredIndex, completionHandler: @escaping CompletionHandler) {
-            assert(index.mirrored)
             self.index = index
             super.init(completionHandler: completionHandler)
             self.completionQueue = index.client.completionQueue

Tests/Offline/MirroredIndexTests.swift

@@ -586,4 +586,43 @@ class MirroredIndexTests: OfflineTestCase {
 
         waitForExpectations(timeout: onlineExpectationTimeout, handler: nil)
     }
+    
+    /// Test that we can switch an index from not mirrored to mirrored and back without causing any harm.
+    ///
+    /// + Bug: [#285](https://github.com/algolia/algoliasearch-client-swift/issues/285).
+    ///
+    func testMirroredSetUnset() {
+        let expectation_property = self.expectation(description: #function + " (property)")
+        let expectation_search = self.expectation(description: #function + " (search)")
+
+        let index: MirroredIndex = client.index(withName: safeIndexName(#function))
+
+        // NOTE: We don't care about the search results here. We are just interested in not crashing.
+        //
+        let propertyQueue = DispatchQueue(label: "Property queue")
+        let OUTER_ITERATIONS = 100
+        let INNER_ITERATIONS = 100
+        var completedProperties = 0
+        var completedSearches = 0
+        for _ in 1...OUTER_ITERATIONS {
+            propertyQueue.async {
+                for i in 1...INNER_ITERATIONS {
+                    index.mirrored = i % 2 == 1
+                }
+                completedProperties += 1
+                if completedProperties == OUTER_ITERATIONS {
+                    expectation_property.fulfill()
+                }
+            }
+            for _ in 1...1 {
+                index.search(Query()) { (content, error) in
+                    completedSearches += 1
+                    if completedSearches == OUTER_ITERATIONS {
+                        expectation_search.fulfill()
+                    }
+                }
+            }
+        }
+        waitForExpectations(timeout: onlineExpectationTimeout, handler: nil)
+    }
 }