Merge pull request #69 from pace/Implement-exponential-backoff-ios

Martin · web-flow · commit 2e12ddf16f01 · 2022-11-21T13:00:30.000+01:00
Implement exponential backoff
diff --git a/Templates/Swift/Common/APIClient.swift b/Templates/Swift/Common/APIClient.swift
@@ -25,8 +25,12 @@ public class {{ options.name }}Client {
 
     public var decodingQueue = DispatchQueue(label: "{{ options.name }}Client", qos: .utility, attributes: .concurrent)
 
+    /// The maximum number a request will be retried due to `401` responses
     public var maxUnauthorizedRetryCount = 1
 
+    /// The maximum number a request will be retried due to network connection errors and timeouts
+    public var maxRetryCount = 8
+
     public init(baseURL: String, configuration: URLSessionConfiguration = .default, defaultHeaders: [String: String] = [:], behaviours: [{{ options.name }}RequestBehaviour] = []) {
         self.baseURL = baseURL
         self.behaviours = self.behaviours + behaviours
@@ -41,11 +45,18 @@ public class {{ options.name }}Client {
     /// - Parameters:
     ///   - request: The API request to make
     ///   - behaviours: A list of behaviours that will be run for this request. Merged with APIClient.behaviours
+    ///   - currentUnauthorizedRetryCount: The current number of retries for this request due to `401` responses
+    ///   - currentRetryCount: The current number of retries for this request due to network connection errors and timeouts
     ///   - completionQueue: The queue that complete will be called on
     ///   - complete: A closure that gets passed the {{ options.name }}Response
     /// - Returns: A cancellable request. Not that cancellation will only work after any validation RequestBehaviours have run
     @discardableResult
-    public func makeRequest<T>(_ request: {{ options.name }}Request<T>, behaviours: [{{ options.name }}RequestBehaviour] = [], currentNumberOfRetries: Int = 0, completionQueue: DispatchQueue = DispatchQueue.main, complete: @escaping ({{ options.name }}Response<T>) -> Void) -> Cancellable{{ options.name }}Request? {
+    public func makeRequest<T>(_ request: {{ options.name }}Request<T>,
+                               behaviours: [{{ options.name }}RequestBehaviour] = [],
+                               currentUnauthorizedRetryCount: Int = 0,
+                               currentRetryCount: Int = 0,
+                               completionQueue: DispatchQueue = DispatchQueue.main,
+                               complete: @escaping ({{ options.name }}Response<T>) -> Void) -> Cancellable{{ options.name }}Request? {
         // create composite behaviour to make it easy to call functions on array of behaviours
         let requestBehaviour = {{ options.name }}RequestBehaviourGroup(request: request, behaviours: self.behaviours + behaviours)
 
@@ -76,7 +87,13 @@ public class {{ options.name }}Client {
         requestBehaviour.validate(urlRequest) { result in
             switch result {
             case .success(let urlRequest):
-                self.makeNetworkRequest(request: request, urlRequest: urlRequest, cancellableRequest: cancellableRequest, requestBehaviour: requestBehaviour, currentNumberOfRetries: currentNumberOfRetries, completionQueue: completionQueue, complete: complete)
+                self.makeNetworkRequest(request: request,
+                                        urlRequest: urlRequest,
+                                        cancellableRequest: cancellableRequest,
+                                        requestBehaviour: requestBehaviour,
+                                        currentUnauthorizedRetryCount: currentUnauthorizedRetryCount,
+                                        currentRetryCount: currentRetryCount,
+                                        completionQueue: completionQueue, complete: complete)
             case .failure(let error):
                 let error = APIClientError.validationError(error)
                 let response = {{ options.name }}Response<T>(request: request, result: .failure(error), urlRequest: urlRequest)
@@ -87,7 +104,14 @@ public class {{ options.name }}Client {
         return cancellableRequest
     }
 
-    private func makeNetworkRequest<T>(request: {{ options.name }}Request<T>, urlRequest: URLRequest, cancellableRequest: Cancellable{{ options.name }}Request, requestBehaviour: {{ options.name }}RequestBehaviourGroup, currentNumberOfRetries: Int, completionQueue: DispatchQueue, complete: @escaping ({{ options.name }}Response<T>) -> Void) {
+    private func makeNetworkRequest<T>(request: {{ options.name }}Request<T>,
+                                       urlRequest: URLRequest,
+                                       cancellableRequest: Cancellable{{ options.name }}Request,
+                                       requestBehaviour: {{ options.name }}RequestBehaviourGroup,
+                                       currentUnauthorizedRetryCount: Int,
+                                       currentRetryCount: Int,
+                                       completionQueue: DispatchQueue,
+                                       complete: @escaping ({{ options.name }}Response<T>) -> Void) {
         requestBehaviour.beforeSend()
         if request.service.isUpload {
             let body = NSMutableData()
@@ -141,47 +165,80 @@ public class {{ options.name }}Client {
             }
             body.appendString("--\(boundary)--\r\n")
         } else {
-            let task = self.session.dataTask(with: urlRequest, completionHandler: { [weak self] data, response, error -> Void in
-                // Handle response
-                self?.decodingQueue.async {
-                    guard let response = response as? HTTPURLResponse else {
-                        var apiError: APIClientError
-                        if let error = error {
-                            apiError = APIClientError.networkError(error)
-                        } else {
-                            apiError = APIClientError.networkError(URLRequestError.responseInvalid)
-                        }
-                        let result: APIResult<T> = .failure(apiError)
-                        requestBehaviour.onFailure(urlRequest: urlRequest, response: HTTPURLResponse(), error: apiError)
+            let task = performRequest(request: request,
+                                      urlRequest: urlRequest,
+                                      cancellableRequest: cancellableRequest,
+                                      requestBehaviour: requestBehaviour,
+                                      currentUnauthorizedRetryCount: currentUnauthorizedRetryCount,
+                                      currentRetryCount: currentRetryCount,
+                                      completionQueue: completionQueue,
+                                      complete: complete)
 
-                        let response = {{ options.name }}Response<T>(request: request, result: result, urlRequest: urlRequest)
-                        requestBehaviour.onResponse(response: response.asAny())
+            self.decodingQueue.async {
+                task.resume()
+            }
 
-                        completionQueue.async {
-                            complete(response)
-                        }
+            cancellableRequest.sessionTask = task
+        }
+    }
 
-                        return
+    private func performRequest<T>(request: {{ options.name }}Request<T>,
+                                   urlRequest: URLRequest,
+                                   cancellableRequest: Cancellable{{ options.name }}Request,
+                                   requestBehaviour: {{ options.name }}RequestBehaviourGroup,
+                                   currentUnauthorizedRetryCount: Int,
+                                   currentRetryCount: Int,
+                                   completionQueue: DispatchQueue,
+                                   complete: @escaping ({{ options.name }}Response<T>) -> Void) -> URLSessionDataTask {
+        let maxRetryCount = maxRetryCount
+        return session.dataTask(with: urlRequest, completionHandler: { [weak self] data, response, error -> Void in
+            // Handle response
+            self?.decodingQueue.async {
+                let newRetryCount = currentRetryCount + 1
+                if API.shouldRetryRequest(currentRetryCount: newRetryCount,
+                                          maxRetryCount: maxRetryCount,
+                                          response: response) {
+                    let requestDelay = API.nextExponentialBackoffRequestDelay(currentRetryCount: newRetryCount)
+                    self?.decodingQueue.asyncAfter(deadline: .now() + .seconds(requestDelay)) { [weak self] in
+                        self?.makeNetworkRequest(request: request,
+                                                 urlRequest: urlRequest,
+                                                 cancellableRequest: cancellableRequest,
+                                                 requestBehaviour: requestBehaviour,
+                                                 currentUnauthorizedRetryCount: currentUnauthorizedRetryCount,
+                                                 currentRetryCount: newRetryCount,
+                                                 completionQueue: completionQueue,
+                                                 complete: complete)
                     }
-
+                } else if let response = response as? HTTPURLResponse {
                     self?.handleResponse(request: request,
                                          requestBehaviour: requestBehaviour,
                                          data: data,
                                          response: response,
                                          error: error,
                                          urlRequest: urlRequest,
-                                         currentNumberOfRetries: currentNumberOfRetries,
+                                         currentUnauthorizedRetryCount: currentUnauthorizedRetryCount,
+                                         currentRetryCount: currentRetryCount,
                                          completionQueue: completionQueue,
                                          complete: complete)
-                }
-            })
+                } else {
+                    var apiError: APIClientError
+                    if let error = error {
+                        apiError = APIClientError.networkError(error)
+                    } else {
+                        apiError = APIClientError.networkError(URLRequestError.responseInvalid)
+                    }
+                    let result: APIResult<T> = .failure(apiError)
+                    requestBehaviour.onFailure(urlRequest: urlRequest, response: HTTPURLResponse(), error: apiError)
 
-            self.decodingQueue.async {
-                task.resume()
-            }
+                    let response = {{ options.name }}Response<T>(request: request, result: result, urlRequest: urlRequest)
+                    requestBehaviour.onResponse(response: response.asAny())
 
-            cancellableRequest.sessionTask = task
-        }
+                    completionQueue.async {
+                        complete(response)
+                    }
+                }
+            }
+        })
     }
 
     private func handleResponse<T>(request: {{ options.name }}Request<T>,
@@ -190,7 +247,8 @@ public class {{ options.name }}Client {
                                    response: HTTPURLResponse,
                                    error: Error?,
                                    urlRequest: URLRequest,
-                                   currentNumberOfRetries: Int,
+                                   currentUnauthorizedRetryCount: Int,
+                                   currentRetryCount: Int,
                                    completionQueue: DispatchQueue,
                                    complete: @escaping ({{ options.name }}Response<T>) -> Void) {
         let result: APIResult<T>
@@ -209,11 +267,16 @@ public class {{ options.name }}Client {
         }
 
         if response.statusCode == HttpStatusCode.unauthorized.rawValue
-            && currentNumberOfRetries < maxUnauthorizedRetryCount
+            && currentUnauthorizedRetryCount < maxUnauthorizedRetryCount
             && IDKit.isSessionAvailable {
             IDKit.apiInducedRefresh { [weak self] error in
                 guard let error = error else {
-                    self?.makeRequest(request, behaviours: requestBehaviour.behaviours, currentNumberOfRetries: currentNumberOfRetries + 1, completionQueue: completionQueue, complete: complete)
+                    self?.makeRequest(request,
+                                      behaviours: requestBehaviour.behaviours,
+                                      currentUnauthorizedRetryCount: currentUnauthorizedRetryCount + 1,
+                                      currentRetryCount: currentRetryCount,
+                                      completionQueue: completionQueue,
+                                      complete: complete)
                     return
                 }
 
