Use fallback API hosts when receiving server down response

Sources/Diagnostics/Networking/DiagnosticsHTTPRequestPath.swift

@@ -46,10 +46,10 @@ extension HTTPRequest.DiagnosticsPath: HTTPRequestPath {
         }
     }
 
-    var pathComponent: String {
+    var relativePath: String {
         switch self {
         case .postDiagnostics:
-            return "diagnostics"
+            return "/v1/diagnostics"
         }
     }
 

Sources/Logging/Strings/NetworkStrings.swift

@@ -43,6 +43,7 @@ enum NetworkStrings {
     case starting_next_request(request: String)
     case starting_request(httpMethod: String, path: String)
     case retrying_request(httpMethod: String, path: String)
+    case retrying_request_with_fallback_path(httpMethod: String, path: String)
     case failing_url_resolved_to_host(url: URL, resolvedHost: String)
     case blocked_network(url: URL, newHost: String?)
     case api_request_redirect(from: URL, to: URL)
@@ -119,6 +120,9 @@ extension NetworkStrings: LogMessage {
         case let .retrying_request(httpMethod, path):
             return "Retrying request \(httpMethod) \(path)"
 
+        case let .retrying_request_with_fallback_path(httpMethod, path):
+            return "Retrying request using fallback host: \(httpMethod) \(path)"
+
         case let .failing_url_resolved_to_host(url, resolvedHost):
             return "Failing url '\(url)' resolved to host '\(resolvedHost)'"
 

Sources/Networking/HTTPClient/HTTPClient.swift

@@ -245,6 +245,7 @@ internal extension HTTPClient {
         var headers: HTTPClient.RequestHeaders
         var verificationMode: Signing.ResponseVerificationMode
         var completionHandler: HTTPClient.Completion<Data>?
+        private(set) var fallbackPathIndex: Int?
 
         /// Whether the request has been retried.
         var retried: Bool {
@@ -279,25 +280,46 @@ internal extension HTTPClient {
         }
 
         var method: HTTPRequest.Method { self.httpRequest.method }
-        var path: String { self.httpRequest.path.relativePath }
+        var path: String { (self.getCurrentPath() ?? self.httpRequest.path).relativePath }
+
+        func getCurrentRequestURL(proxyURL: URL?) -> URL? {
+            return self.getCurrentPath()?.url(proxyURL: proxyURL)
+        }
 
         func retriedRequest() -> Self {
             var copy = self
             copy.retryCount += 1
             copy.headers[RequestHeader.retryCount.rawValue] = "\(copy.retryCount)"
+            return copy
+        }
 
+        func requestWithNextFallbackPath() -> Self? {
+            var copy = self
+            copy.fallbackPathIndex = self.fallbackPathIndex?.advanced(by: 1) ?? 0
+            guard copy.getCurrentPath() != nil else {
+                // No more fallback paths available
+                return nil
+            }
             return copy
         }
 
         var description: String {
             """
             <\(type(of: self)): httpMethod=\(self.method.httpMethod)
             path=\(self.path)
-            headers=\(self.headers.description )
+            headers=\(self.headers.description)
             retried=\(self.retried)
             >
             """
         }
+
+        private func getCurrentPath() -> HTTPRequestPath? {
+            if let fallbackPathIndex = self.fallbackPathIndex {
+                return self.httpRequest.path.fallbackPaths[safe: fallbackPathIndex]
+            } else {
+                return self.httpRequest.path
+            }
+        }
     }
 }
 
@@ -433,18 +455,16 @@ private extension HTTPClient {
                 requestStartTime: Date) {
         RCTestAssertNotMainThread()
 
-        let response = self.parse(
-            urlResponse: urlResponse,
-            request: request,
-            urlRequest: urlRequest,
-            data: data,
-            error: networkError,
-            requestStartTime: requestStartTime
-        )
+        let response = self.parse(urlResponse: urlResponse,
+                                  request: request,
+                                  urlRequest: urlRequest,
+                                  data: data,
+                                  error: networkError,
+                                  requestStartTime: requestStartTime)
 
         if let response = response {
             let httpURLResponse = urlResponse as? HTTPURLResponse
-            var requestRetryScheduled = false
+            var retryScheduled = false
 
             switch response {
             case let .success(response):
@@ -463,26 +483,28 @@ private extension HTTPClient {
             case let .failure(error):
                 let httpURLResponse = urlResponse as? HTTPURLResponse
 
-                Logger.debug(Strings.network.api_request_failed(
-                    request.httpRequest,
-                    httpCode: httpURLResponse?.httpStatusCode,
-                    error: error,
-                    metadata: httpURLResponse?.metadata)
-                )
+                Logger.debug(Strings.network.api_request_failed(request.httpRequest,
+                                                                httpCode: httpURLResponse?.httpStatusCode,
+                                                                error: error,
+                                                                metadata: httpURLResponse?.metadata))
 
                 if httpURLResponse?.isLoadShedder == true {
                     Logger.debug(Strings.network.request_handled_by_load_shedder(request.httpRequest.path))
                 }
 
-                requestRetryScheduled = self.retryRequestIfNeeded(request: request, httpURLResponse: httpURLResponse)
+                retryScheduled = self.retryRequestWithNextFallbackPathIfNeeded(request: request,
+                                                                               httpURLResponse: httpURLResponse)
+                if !retryScheduled {
+                    retryScheduled = self.retryRequestIfNeeded(request: request,
+                                                               httpURLResponse: httpURLResponse)
+                }
             }
 
-            if !requestRetryScheduled {
+            if !retryScheduled {
                 request.completionHandler?(response)
             }
         } else {
-            Logger.debug(Strings.network.retrying_request(httpMethod: request.method.httpMethod,
-                                                          path: request.path))
+            Logger.debug(Strings.network.retrying_request(httpMethod: request.method.httpMethod, path: request.path))
 
             self.state.modify {
                 $0.queuedRequests.insert(request.retriedRequest(), at: 0)
@@ -540,7 +562,7 @@ private extension HTTPClient {
     }
 
     func convert(request: Request) -> URLRequest? {
-        guard let requestURL = request.httpRequest.path.url(proxyURL: SystemInfo.proxyURL) else {
+        guard let requestURL = request.getCurrentRequestURL(proxyURL: SystemInfo.proxyURL) else {
             return nil
         }
         var urlRequest = URLRequest(url: requestURL)
@@ -623,6 +645,36 @@ private extension HTTPClient {
 // MARK: - Request Retry Logic
 extension HTTPClient {
 
+    /// Evaluates whether a request should be retried with the next path in the list of fallback paths.
+    ///
+    /// This function checks the HTTP response status code to determine if the request should be retried
+    /// with the next fallback path. If the retry conditions are met, it schedules the request immediately and
+    /// returns `true` to indicate that the request was retried.
+    ///
+    /// - Parameters:
+    ///   - request: The original `HTTPClient.Request` that may need to be retried.
+    ///   - httpURLResponse: An optional `HTTPURLResponse` that contains the status code of the response.
+    /// - Returns: A Boolean value indicating whether the request was retried.
+    internal func retryRequestWithNextFallbackPathIfNeeded(
+        request: HTTPClient.Request,
+        httpURLResponse: HTTPURLResponse?
+    ) -> Bool {
+
+        guard let statusCode = httpURLResponse?.statusCode, HTTPStatusCode(rawValue: statusCode).isServerError,
+              let nextRequest = request.requestWithNextFallbackPath() else {
+            return false
+        }
+
+        Logger.debug(Strings.network.retrying_request_with_fallback_path(
+            httpMethod: nextRequest.method.httpMethod,
+            path: nextRequest.path
+        ))
+        self.state.modify {
+            $0.queuedRequests.insert(nextRequest, at: 0)
+        }
+        return true
+    }
+
     /// Evaluates whether a request should be retried and schedules a retry if necessary.
     ///
     /// This function checks the HTTP response status code to determine if the request should be retried.

Sources/Networking/HTTPClient/HTTPRequestPath.swift

@@ -18,6 +18,11 @@ protocol HTTPRequestPath {
     /// The base URL for requests to this path.
     static var serverHostURL: URL { get }
 
+    /// The fallback paths to use when the main server is down.
+    ///
+    /// The structure of the response must be the same as that of the main path.
+    var fallbackPaths: [HTTPRequestPath] { get }
+
     /// Whether requests to this path are authenticated.
     var authenticated: Bool { get }
 
@@ -30,27 +35,24 @@ protocol HTTPRequestPath {
     /// Whether endpoint requires a nonce for signature verification.
     var needsNonceForSigning: Bool { get }
 
-    /// The path component for this endpoint.
-    var pathComponent: String { get }
-
     /// The name of the endpoint.
     var name: String { get }
 
+    /// The full relative path for this endpoint.
+    var relativePath: String { get }
 }
 
 extension HTTPRequestPath {
 
-    /// The full relative path for this endpoint.
-    var relativePath: String {
-        return "/v1/\(self.pathComponent)"
+    var fallbackPaths: [HTTPRequestPath] {
+        return []
     }
 
     var url: URL? { return self.url(proxyURL: nil) }
 
     func url(proxyURL: URL? = nil) -> URL? {
         return URL(string: self.relativePath, relativeTo: proxyURL ?? Self.serverHostURL)
     }
-
 }
 
 // MARK: - Main paths
@@ -94,6 +96,17 @@ extension HTTPRequest.Path: HTTPRequestPath {
     // swiftlint:disable:next force_unwrapping
     static let serverHostURL = URL(string: "https://api.revenuecat.com")!
 
+    var fallbackPaths: [HTTPRequestPath] {
+        switch self {
+        case .getOfferings:
+            return [HTTPRequest.FallbackPath.getOfferings]
+        case .getProductEntitlementMapping:
+            return [HTTPRequest.FallbackPath.getProductEntitlementMapping]
+        default:
+            return []
+        }
+    }
+
     var authenticated: Bool {
         switch self {
         case .getCustomerInfo,
@@ -175,6 +188,10 @@ extension HTTPRequest.Path: HTTPRequestPath {
         }
     }
 
+    var relativePath: String {
+        return "/v1/\(self.pathComponent)"
+    }
+
     var pathComponent: String {
         switch self {
         case let .getCustomerInfo(appUserID):
@@ -267,3 +284,49 @@ extension HTTPRequest.Path: HTTPRequestPath {
         return appUserID.trimmedAndEscaped
     }
 }
+
+extension HTTPRequest {
+
+    enum FallbackPath: HTTPRequestPath {
+
+        case getOfferings
+        case getProductEntitlementMapping
+
+        // swiftlint:disable:next force_unwrapping
+        static let serverHostURL = URL(string: "https://api-production.8-lives-cat.io")!
+
+        var authenticated: Bool {
+            return true
+        }
+
+        var shouldSendEtag: Bool {
+            return true
+        }
+
+        var supportsSignatureVerification: Bool {
+            return false
+        }
+
+        var needsNonceForSigning: Bool {
+            return false
+        }
+
+        var relativePath: String {
+            switch self {
+            case .getOfferings:
+                return "/offerings"
+            case .getProductEntitlementMapping:
+                return "/product_entitlement_mapping"
+            }
+        }
+
+        var name: String {
+            switch self {
+            case .getOfferings:
+                return "fallback_get_offerings"
+            case .getProductEntitlementMapping:
+                return "fallback_get_product_entitlement_mapping"
+            }
+        }
+    }
+}

Sources/Paywalls/Events/Networking/PaywallHTTPRequestPath.swift

@@ -46,10 +46,10 @@ extension HTTPRequest.PaywallPath: HTTPRequestPath {
         }
     }
 
-    var pathComponent: String {
+    var relativePath: String {
         switch self {
         case .postEvents:
-            return "events"
+            return "/v1/events"
         }
     }