fix: HostIterator crash (#708)

* fix: synchronise host iterator callback to avoid bad access crash
* test: add load test for retry strategy

Author: VladislavFitz

Sources/AlgoliaSearchClient/Transport/RetryStrategy/AlgoliaRetryStrategy.swift

@@ -37,7 +37,10 @@ class AlgoliaRetryStrategy: RetryStrategy {
       }
 
       return HostIterator { [weak self] in
-        self?.hosts.first { $0.supports(callType) && $0.isUp }
+        guard let retryStrategy = self else { return nil }
+        return retryStrategy.queue.sync {
+          return retryStrategy.hosts.first { $0.supports(callType) && $0.isUp }
+        }
       }
     }
   }

Tests/AlgoliaSearchClientTests/Unit/AlgoliaRetryStrategyTests.swift

@@ -132,5 +132,84 @@ class AlgoliaRetryStrategyTests: XCTestCase {
 
     XCTAssertEqual(newReadHosts.next()?.url.absoluteString, "algolia3.com")
   }
+  
+  /// Load test of hosts retry strategy
+  func testLoad() {
+    let expirationDelay: TimeInterval = 3
+    let strategy = AlgoliaRetryStrategy(hosts: [host3, host4, host5], hostsExpirationDelay: expirationDelay)
+
+    let queueCount = 100
+    // Generate `queueCount` queues with associated count of operation for each
+    let queuesWithOpCount = (1...queueCount)
+      .map { (queue: DispatchQueue(label: "queue\($0)"), operationCount: Int.random(in: 100...1000)) }
+    
+    let operationQueue = OperationQueue()
+    operationQueue.maxConcurrentOperationCount = 50
+    
+    // Expectation of completion of all the operations from all the queues
+    let allOperationsFinishedExpectation = expectation(description: "All operations finished")
+    allOperationsFinishedExpectation.expectedFulfillmentCount = queuesWithOpCount.map(\.operationCount).reduce(0, +)
+    
+    // Launch `operationCount` operation from each queue with randomized launch delay
+    for (queue, operationCount) in queuesWithOpCount {
+      for count in 1...operationCount {
+        queue.asyncAfter(deadline: .now() + .milliseconds(.random(in: 10...500))) {
+          let callType: CallType = [.read, .write].randomElement()!
+          let operation = RetryableOperation(retryStrategy: strategy, callType: callType)
+          operation.name = "\(queue.label) - \(count)"
+          operation.completionBlock = {
+            allOperationsFinishedExpectation.fulfill()
+          }
+          operationQueue.addOperation(operation)
+        }
+      }
+    }
+
+    waitForExpectations(timeout: 20, handler: nil)
+  }
 
 }
+
+/// Operation imitating server responses for the purpose of testing the retry strategy
+class RetryableOperation: Operation {
+  
+  let retryStrategy: RetryStrategy
+  let callType: CallType
+  let waitQueue = DispatchQueue(label: "internal")
+
+  init(retryStrategy: RetryStrategy, callType: CallType) {
+    self.retryStrategy = retryStrategy
+    self.callType = callType
+    super.init()
+  }
+  
+  override var debugDescription: String {
+    return "\(name ?? "")"
+  }
+  
+  override func main() {
+    let hostsIterator = retryStrategy.retryableHosts(for: callType)
+    
+    while let host = hostsIterator.next() {
+      let result = getResult()
+      switch retryStrategy.notify(host: host, result: result) {
+      case .failure, .success:
+        break
+      case .retry:
+        continue
+      }
+    }
+  }
+  
+  func getResult() -> Result<String, Error> {
+    return [
+      .failure(HTTPError(statusCode: .requestTimeout, message: nil)),
+      .failure(URLError(.badServerResponse)),
+      .failure(InternalError()),
+      .success("")
+    ].randomElement()!
+  }
+  
+  struct InternalError: Error {}
+  
+}