added different strategy

Author: swiftuiux

README.md

@@ -8,7 +8,7 @@ Network layer for running requests like GET, POST, PUT, DELETE etc customizable
 ## Features
 - [x] Multiplatform
 - [x] Stand alone package without any dependencies using just Apple's  facilities
-- [x] Set up amount of attempts(retry) with **"Exponential backoff"** strategy if request fails. Exponential backoff is a strategy in which you increase the delays between retries.
+- [x] Set up amount of attempts(retry) with **"Exponential backoff"** or **"Constant backoff"** strategy if request fails. Exponential backoff is a strategy in which you increase the delays between retries. Constant backoff is a strategy when delay between retries is a constant value
 - [x] Customizable for different requests schemes from classic **CRUD Rest** to what suits to you
 - [x] Customizable in term of URLSession
 - [x] Customizable in terms of URLSessionTaskDelegate, URLSessionDelegate
@@ -62,19 +62,29 @@ Network layer for running requests like GET, POST, PUT, DELETE etc customizable
 ### Custom request
 
 ```swift
-    /// - Parameters:
-    ///   - request: A URL load request that is independent of protocol or URL scheme
-    ///   - retry: Amount of attempts Default value is 1
-    ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
-    func send(
-        with request : URLRequest,
-        retry : UInt = 1,
-        _ taskDelegate: ITaskDelegate? = nil
+        /// Send custom request based on the specific request instance
+        /// - Parameters:
+        ///   - request: A URL load request that is independent of protocol or URL scheme
+        ///   - retry: ``RetryService.Strategy`` strategy Default value .exponential with 5 retry and duration 2.0
+        ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
+        public func send<T>(
+            with request : URLRequest,
+            retry strategy : RetryService.Strategy = .exponential(),
+            _ taskDelegate: ITaskDelegate? = nil
+        ) async throws -> Http.Response<T> where T : Decodable
 ```
 
+## Retry strategy
+
+| type | description |
+| --- | --- |
+| constant | The strategy implements constant backoff  |
+| exponential | The strategy implements exponential backoff  |
+
+
 # The concept
 
-* Proxy is defining a communication layer and responsible for exchanging data with data source. There might be Http proxy, File proxy etc or some flavours REST proxy, LongFile proxy.
+* Proxy is defining a communication layer and responsible for exchanging data with data source. There might be Http proxy, File proxy etc or some flavors REST proxy, LongFile proxy.
 * Reader and Writer are used to interpret data.
 
  ![The concept](https://github.com/The-Igor/async-http-client/blob/main/img/concept.png) 

Sources/async-http-client/proxy/http/Proxy.swift

@@ -34,7 +34,7 @@ public extension Http{
         ///   - path: Path
         ///   - query: An array of name-value pairs
         ///   - headers: A dictionary containing all of the HTTP header fields for a request
-        ///   - retry: Amount of attempts Default value is 1
+        ///   - retry: Amount of attempts Default value .exponential with 5 retry and duration 2.0
         ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
         public func get<T>(
             path: String,
@@ -47,8 +47,9 @@ public extension Http{
         {
 
             let request = try buildURLRequest(for: path, query: query, headers: headers)
+            let strategy = RetryService.Strategy.exponential(retry: retry, duration: 2)
 
-            return try await send(with: request, retry: retry, taskDelegate)
+            return try await send(with: request, retry: strategy, taskDelegate)
         }
 
         /// POST request
@@ -57,7 +58,7 @@ public extension Http{
         ///   - body: The data sent as the message body of a request, such as for an HTTP POST or PUT requests
         ///   - query: An array of name-value pairs
         ///   - headers: A dictionary containing all of the HTTP header fields for a request
-        ///   - retry: Amount of attempts Default value is 1
+        ///   - retry: Amount of attempts Default value .exponential with 5 retry and duration 2.0
         ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
         public func post<T>(
             path: String,
@@ -70,8 +71,9 @@ public extension Http{
         -> Http.Response<T> where T: Decodable
         {
             let request = try buildURLRequest(for: path, method: .post, query: query, body: body, headers: headers)
+            let strategy = RetryService.Strategy.exponential(retry: retry)
 
-            return try await send(with: request, retry: retry, taskDelegate)
+            return try await send(with: request, retry: strategy, taskDelegate)
         }
 
 
@@ -81,7 +83,7 @@ public extension Http{
         ///   - body: The data sent as the message body of a request, such as for an HTTP POST or PUT requests
         ///   - query: An array of name-value pairs
         ///   - headers: A dictionary containing all of the HTTP header fields for a request
-        ///   - retry: Amount of attempts Default value is 1
+        ///   - retry: Amount of attempts Default value .exponential with 5 retry and duration 2.0
         ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
         public func put<T>(
             path: String,
@@ -94,16 +96,17 @@ public extension Http{
         -> Http.Response<T> where T: Decodable
         {
             let request = try buildURLRequest(for: path, method: .put, query: query, body: body, headers: headers)
+            let strategy = RetryService.Strategy.exponential(retry: retry)
 
-            return try await send(with: request, retry: retry, taskDelegate)
+            return try await send(with: request, retry: strategy, taskDelegate)
         }
 
         /// DELETE request
         /// - Parameters:
         ///   - path: Path
         ///   - query: An array of name-value pairs
         ///   - headers: A dictionary containing all of the HTTP header fields for a request
-        ///   - retry: Amount of attempts Default value is 1
+        ///   - retry: Amount of attempts Default value .exponential with 5 retry and duration 2.0
         ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
         public func delete<T>(
             path: String,
@@ -115,26 +118,30 @@ public extension Http{
         -> Http.Response<T> where T: Decodable
         {
             let request = try buildURLRequest(for: path, method: .delete, query: query, headers: headers)
-            
-            return try await send(with: request, retry: retry, taskDelegate)
+            let strategy = RetryService.Strategy.exponential(retry: retry)
+            return try await send(with: request, retry: strategy, taskDelegate)
         }
 
 
         /// Send custom request based on the specific request instance
         /// - Parameters:
         ///   - request: A URL load request that is independent of protocol or URL scheme
-        ///   - retry: Amount of attempts Default value is 1
+        ///   - retry: ``RetryService.Strategy`` strategy Default value .exponential with 5 retry and duration 2.0
         ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
         public func send<T>(
             with request : URLRequest,
-            retry : UInt = 1,
+            retry strategy : RetryService.Strategy = .exponential(),
             _ taskDelegate: ITaskDelegate? = nil
         ) async throws -> Http.Response<T> where T : Decodable
         {
 
             let reader = config.reader
 
-            let (data,response) = try await sendRetry(with: request, retry: retry, taskDelegate)
+            let (data,response) = try await sendRetry(
+                with: request,
+                retry: strategy,
+                taskDelegate
+            )
 
             let value: T = try reader.read(data: data)
 
@@ -150,35 +157,35 @@ private extension Http.Proxy{
 
     /// - Parameters:
     ///   - request: A URL load request that is independent of protocol or URL scheme
-    ///   - retry: Amount of attempts Default value is 1
+    ///   - retry: ``RetryService`` strategy
     ///   - taskDelegate: A protocol that defines methods that URL session instances call on their delegates to handle task-level events
     func sendRetry(
         with request : URLRequest,
-        retry : UInt = 1,
+        retry strategy : RetryService.Strategy,
         _ taskDelegate: ITaskDelegate? = nil
     ) async throws -> (Data, URLResponse)
     {
 
         let session = config.getSession
-        var nextDelay: UInt64 = 1       
+        let service = RetryService(strategy: strategy)
 
-        if retry > 1{
-            let up = retry - 1
-            for i in 1...up{
-                do{
-                    return try await session.data(for: request, delegate: taskDelegate)
-                }catch{
-                    #if DEBUG
-                    print("retry \(i)")
-                    #endif
-                }
-                // nanoseconds the only choice for iOS15
-                try? await Task.sleep(nanoseconds: 1_000_000_000 * nextDelay)
-                
-                nextDelay *= 2
+        for delay in service{
+            do{
+                print(delay)
+                return try await session.data(for: request, delegate: taskDelegate)
+            }catch{
+                #if DEBUG
+                print("retry send \(delay)")
+                #endif
             }
+            
+            try? await Task.sleep(nanoseconds: 1_000_000_000 * UInt64(delay))
         }
-                
+
+        #if DEBUG
+        print("retry send last")
+        #endif
+        
         /// one more time to let the error to propagate if it fails the last time
         return try await session.data(for: request, delegate: taskDelegate)
     }

Sources/async-http-client/proxy/http/retry/RetryIterator.swift

@@ -0,0 +1,52 @@
+//
+//  RetryIterator.swift
+//  
+//
+//  Created by Igor on 06.03.2023.
+//
+
+import Foundation
+
+
+public extension RetryService{
+    
+    /// Retry iterator
+     @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+     struct RetryIterator: IteratorProtocol {
+         
+         /// Current amount of retries
+        public private(set) var retries: UInt = 1
+         
+         /// Retry service
+        public let service: RetryService
+         
+         /// - Parameter service: Retry service ``RetryService``
+        init(service: RetryService){
+            self.service = service
+        }
+
+        /// Returns the next delay amount, or `nil`.
+        public mutating func next() -> TimeInterval? {
+
+            let max = service.maximumRetries
+            let time = service.duration
+            
+            guard time > 0 else{ return nil }
+            
+            guard max > retries && max != 0 else { return nil }
+            
+            defer { retries += 1 }
+            
+            let delay: TimeInterval
+            
+            switch service.strategy {
+                case .constant(_, let duration):
+                    delay = duration
+                case .exponential(_, let duration):
+                    delay = duration * Double(retries)
+            }
+
+            return delay
+        }
+    }
+}

Sources/async-http-client/proxy/http/retry/RetryService.swift

@@ -0,0 +1,46 @@
+//
+//  RetryService.swift
+//  
+//
+//  Created by Igor on 06.03.2023.
+//
+
+import Foundation
+
+
+/// Generate sequence of time delays between retries depending on retry strategy
+@available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+public struct RetryService: Equatable, Sequence{
+        
+    /// Retry strategy
+    public let strategy: Strategy
+       
+    
+    /// Default service
+    static let `default` = RetryService(strategy: .exponential())
+    
+    
+    /// - Parameter strategy: Retry strategy ``RetryService.Strategy``
+    public init(strategy: Strategy){
+        self.strategy = strategy
+    }
+        
+    /// Max amount of retires
+    var maximumRetries: UInt{
+        strategy.maximumRetries
+    }
+    
+    /// Duration between retries For .exponential multiply on the amount of the current retries
+    var duration: TimeInterval{
+        strategy.duration
+    }
+       
+    /// - Returns: Retry delays iterator
+    public func makeIterator() -> RetryIterator {
+        return RetryIterator(service: self)
+    }
+}
+
+
+
+

Sources/async-http-client/proxy/http/retry/Strategy.swift

@@ -0,0 +1,45 @@
+//
+//  Strategy.swift
+//  
+//
+//  Created by Igor on 06.03.2023.
+//
+
+import Foundation
+
+public extension RetryService{
+    
+    /// Retry strategy
+    @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+    enum Strategy: Hashable {
+        
+        /// constant delay between reties
+        case constant(
+            retry : UInt = 5,
+            duration: TimeInterval = 2.0
+        )
+        
+        /// Exponential backoff is a strategy in which you increase the delays between retries.
+        case exponential(
+            retry : UInt = 5,
+            duration: TimeInterval = 2.0
+        )
+        
+        
+        /// Max amount of retries
+        var maximumRetries: UInt{
+            switch self{
+                case .constant(let retry, _) : return retry
+                case .exponential(let retry, _) : return retry
+            }
+        }
+        
+        /// Duration between retries For .exponential multiply on the amount of the current retries
+        var duration: TimeInterval{
+            switch self{
+                case .constant(_, let duration) : return duration
+                case .exponential(_, let duration) : return duration
+            }
+        }
+    }
+}