Resilient Networking in Swift: Building a Retry Mechanism

import Foundation

enum NetworkError: Error {
    case maxRetriesReached
    case invalidResponse
    case clientError(statusCode: Int)
}

class NetworkManager {
    
    /// Uploads a file with an automatic retry mechanism.
    /// - Parameters:
    ///   - data: The file data to upload.
    ///   - url: The destination URL.
    ///   - maxRetries: Maximum number of times to retry before failing.
    func uploadFile(data: Data, to url: URL, maxRetries: Int = 3) async throws {
        var retries = 0
        var currentDelay = 1.0 // Start with a 1-second delay
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
        
        while retries <= maxRetries {
            do {
                print("Attempt \(retries + 1): Uploading file...")
                
                // 1. Attempt the network request
                let (_, response) = try await URLSession.shared.upload(for: request, from: data)
                
                guard let httpResponse = response as? HTTPURLResponse else {
                    throw NetworkError.invalidResponse
                }
                
                // 2. Check the status code
                switch httpResponse.statusCode {
                case 200...299:
                    print("✅ Upload successful!")
                    return // Exit the function, we are done!
                    
                case 400...499:
                    // Client error (e.g., 401 Unauthorized). Do NOT retry.
                    print("❌ Client error \(httpResponse.statusCode). Aborting.")
                    throw NetworkError.clientError(statusCode: httpResponse.statusCode)
                    
                case 500...599:
                    // Server error. Throw so the catch block can retry it.
                    print("⚠️ Server error \(httpResponse.statusCode).")
                    throw URLError(.badServerResponse)
                    
                default:
                    throw NetworkError.invalidResponse
                }
                
            } catch {
                // 3. Evaluate the error to see if we should retry
                if shouldRetry(error: error), retries < maxRetries {
                    print("⚠️ Upload failed: \(error.localizedDescription).")
                    print("⏳ Retrying in \(currentDelay) seconds...")
                    
                    // Sleep for the delay (without blocking the thread!)
                    try await Task.sleep(nanoseconds: UInt64(currentDelay * 1_000_000_000))
                    
                    // Increase retries and double the delay (Exponential Backoff)
                    retries += 1
                    currentDelay *= 2.0 
                } else {
                    // If it's not a transient error, or we ran out of retries, throw it to the UI.
                    print("❌ Upload failed permanently.")
                    throw error
                }
            }
        }
        
        throw NetworkError.maxRetriesReached
    }
    
    /// Determines if an error is transient and worth retrying.
    private func shouldRetry(error: Error) -> Bool {
        // Do not retry if the Task was explicitly cancelled by the user
        if error is CancellationError {
            return false
        }
        
        let nsError = error as NSError
        if nsError.domain == NSURLErrorDomain {
            // Only retry specific transient network errors
            let retriableCodes = [
                NSURLErrorTimedOut,
                NSURLErrorCannotFindHost,
                NSURLErrorCannotConnectToHost,
                NSURLErrorNetworkConnectionLost, // E.g., driving through a tunnel
                NSURLErrorDNSLookupFailed,
                NSURLErrorNotConnectedToInternet
            ]
            return retriableCodes.contains(nsError.code)
        }
        
        return false
    }
}

@MainActor
class ProfileViewModel: ObservableObject {
    @Published var uploadState: String = "Idle"
    let networkManager = NetworkManager()
    
    func saveProfilePicture(imageData: Data) async {
        uploadState = "Uploading..."
        
        do {
            let url = URL(string: "[https://api.example.com/upload](https://api.example.com/upload)")!
            try await networkManager.uploadFile(data: imageData, to: url)
            uploadState = "Upload Complete!"
        } catch {
            uploadState = "Failed to upload: \(error.localizedDescription)"
        }
    }
}