Add resumable downloads across app sessions

Author: DePasqualeOrg

Sources/Hub/Downloader.swift

@@ -11,6 +11,7 @@ import Combine
 
 class Downloader: NSObject, ObservableObject {
     private(set) var destination: URL
+    private(set) var sourceURL: URL
 
     private let chunkSize = 10 * 1024 * 1024  // 10MB
 
@@ -24,10 +25,15 @@ class Downloader: NSObject, ObservableObject {
     enum DownloadError: Error {
         case invalidDownloadLocation
         case unexpectedError
+        case tempFileNotFound
     }
 
     private(set) lazy var downloadState: CurrentValueSubject<DownloadState, Never> = CurrentValueSubject(.notStarted)
     private var stateSubscriber: Cancellable?
+    
+    private(set) var tempFilePath: URL?
+    private(set) var expectedSize: Int?
+    private(set) var downloadedSize: Int = 0
 
     private var urlSession: URLSession? = nil
 
@@ -40,9 +46,15 @@ class Downloader: NSObject, ObservableObject {
         headers: [String: String]? = nil,
         expectedSize: Int? = nil,
         timeout: TimeInterval = 10,
-        numRetries: Int = 5
+        numRetries: Int = 5,
+        existingTempFile: URL? = nil
     ) {
         self.destination = destination
+        self.sourceURL = url
+        self.expectedSize = expectedSize
+        self.downloadedSize = resumeSize
+        self.tempFilePath = existingTempFile
+        
         super.init()
         let sessionIdentifier = "swift-transformers.hub.downloader"
 
@@ -77,7 +89,14 @@ class Downloader: NSObject, ObservableObject {
         timeout: TimeInterval,
         numRetries: Int
     ) {
-        downloadState.value = .downloading(0)
+        // If we have an expected size and resumeSize, calculate initial progress
+        if let expectedSize = expectedSize, expectedSize > 0 && resumeSize > 0 {
+            let initialProgress = Double(resumeSize) / Double(expectedSize)
+            downloadState.value = .downloading(initialProgress)
+        } else {
+            downloadState.value = .downloading(0)
+        }
+        
         urlSession?.getAllTasks { tasks in
             // If there's an existing pending background task with the same URL, let it proceed.
             if let existing = tasks.filter({ $0.originalRequest?.url == url }).first {
@@ -113,24 +132,54 @@ class Downloader: NSObject, ObservableObject {
                 requestHeaders["Range"] = "bytes=\(resumeSize)-"
             }
 
-            
             request.timeoutInterval = timeout
             request.allHTTPHeaderFields = requestHeaders
 
             Task {
                 do {
-                    // Create a temp file to write
-                    let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
-                    FileManager.default.createFile(atPath: tempURL.path, contents: nil)
+                    // Create or use existing temp file
+                    let tempURL: URL
+                    var existingSize = 0
+                    
+                    if let existingTempFile = self.tempFilePath, FileManager.default.fileExists(atPath: existingTempFile.path) {
+                        tempURL = existingTempFile
+                        let attributes = try FileManager.default.attributesOfItem(atPath: tempURL.path)
+                        existingSize = attributes[.size] as? Int ?? 0
+                        // If the reported resumeSize doesn't match the file size, trust the file size
+                        if existingSize != resumeSize {
+                            self.downloadedSize = existingSize
+                        }
+                    } else {
+                        // Create new temp file with predictable path for future resume
+                        let filename = url.lastPathComponent
+                        // Create a stable hash by extracting just the path component
+                        let urlPath = url.absoluteString
+                        // Use a deterministic hash that doesn't change between app launches
+                        let stableHash = abs(urlPath.data(using: .utf8)!.reduce(5381) {
+                            ($0 << 5) &+ $0 &+ Int32($1)
+                        })
+                        let hashedName = "\(filename)-\(stableHash)"
+                        tempURL = FileManager.default.temporaryDirectory.appendingPathComponent(hashedName)
+                        FileManager.default.createFile(atPath: tempURL.path, contents: nil)
+                    }
+                    
+                    self.tempFilePath = tempURL
                     let tempFile = try FileHandle(forWritingTo: tempURL)
 
+                    // If we're resuming, seek to end of file first
+                    if existingSize > 0 {
+                        try tempFile.seekToEnd()
+                    }
+                    
                     defer { tempFile.closeFile() }
-                    try await self.httpGet(request: request, tempFile: tempFile, resumeSize: resumeSize, numRetries: numRetries, expectedSize: expectedSize)
+                    try await self.httpGet(request: request, tempFile: tempFile, resumeSize: self.downloadedSize, numRetries: numRetries, expectedSize: expectedSize)
 
                     // Clean up and move the completed download to its final destination
                     tempFile.closeFile()
                     try FileManager.default.moveDownloadedFile(from: tempURL, to: self.destination)
 
+                    // Clear temp file reference since it's been moved
+                    self.tempFilePath = nil
                     self.downloadState.value = .completed(self.destination)
                 } catch {
                     self.downloadState.value = .failed(error)
@@ -178,7 +227,7 @@ class Downloader: NSObject, ObservableObject {
             throw DownloadError.unexpectedError
         }
 
-        var downloadedSize = resumeSize
+        self.downloadedSize = resumeSize
 
         // Create a buffer to collect bytes before writing to disk
         var buffer = Data(capacity: chunkSize)
@@ -192,18 +241,18 @@ class Downloader: NSObject, ObservableObject {
                     if !buffer.isEmpty { // Filter out keep-alive chunks
                         try tempFile.write(contentsOf: buffer)
                         buffer.removeAll(keepingCapacity: true)
-                        downloadedSize += chunkSize
+                        self.downloadedSize += chunkSize
                         newNumRetries = 5
                         guard let expectedSize = expectedSize else { continue }
-                        let progress = expectedSize != 0 ? Double(downloadedSize) / Double(expectedSize) : 0
+                        let progress = expectedSize != 0 ? Double(self.downloadedSize) / Double(expectedSize) : 0
                         downloadState.value = .downloading(progress)
                     }
                 }
             }
 
             if !buffer.isEmpty {
                 try tempFile.write(contentsOf: buffer)
-                downloadedSize += buffer.count
+                self.downloadedSize += buffer.count
                 buffer.removeAll(keepingCapacity: true)
                 newNumRetries = 5
             }
@@ -219,7 +268,7 @@ class Downloader: NSObject, ObservableObject {
             try await httpGet(
                 request: request,
                 tempFile: tempFile,
-                resumeSize: downloadedSize,
+                resumeSize: self.downloadedSize,
                 numRetries: newNumRetries - 1,
                 expectedSize: expectedSize
             )
@@ -291,3 +340,92 @@ extension FileManager {
         try moveItem(at: srcURL, to: dstURL)
     }
 }
+
+/// Structs for persisting download state
+public struct PersistableDownloadState: Codable {
+    let sourceURL: URL
+    let destinationURL: URL
+    let tempFilePath: URL
+    let downloadedSize: Int
+    let expectedSize: Int?
+    
+    init(downloader: Downloader) {
+        self.sourceURL = downloader.sourceURL
+        self.destinationURL = downloader.destination
+        self.tempFilePath = downloader.tempFilePath ?? FileManager.default.temporaryDirectory.appendingPathComponent("unknown")
+        self.downloadedSize = downloader.downloadedSize
+        self.expectedSize = downloader.expectedSize
+    }
+}
+
+/// Extension for managing persisted download states
+extension Downloader {
+    /// Persists the current download state to UserDefaults
+    func persistState() {
+        guard let tempFilePath = self.tempFilePath else {
+            return // Nothing to persist if no temp file
+        }
+        
+        let state = PersistableDownloadState(downloader: self)
+        
+        do {
+            let encoder = JSONEncoder()
+            let data = try encoder.encode(state)
+            
+            // Store in UserDefaults
+            var states = Downloader.getPersistedStates()
+            states[sourceURL.absoluteString] = data
+            UserDefaults.standard.set(states, forKey: "SwiftTransformers.ActiveDownloads")
+        } catch {
+            print("Error persisting download state: \(error)")
+        }
+    }
+    
+    /// Removes this download from persisted states
+    func removePersistedState() {
+        var states = Downloader.getPersistedStates()
+        states.removeValue(forKey: sourceURL.absoluteString)
+        UserDefaults.standard.set(states, forKey: "SwiftTransformers.ActiveDownloads")
+    }
+    
+    /// Get all persisted download states
+    static func getPersistedStates() -> [String: Data] {
+        return UserDefaults.standard.dictionary(forKey: "SwiftTransformers.ActiveDownloads") as? [String: Data] ?? [:]
+    }
+    
+    /// Resume all persisted downloads
+    static func resumeAllPersistedDownloads(authToken: String? = nil) -> [Downloader] {
+        let states = getPersistedStates()
+        let decoder = JSONDecoder()
+        
+        var resumedDownloaders: [Downloader] = []
+        
+        for (_, stateData) in states {
+            do {
+                let state = try decoder.decode(PersistableDownloadState.self, from: stateData)
+                
+                // Check if temp file still exists
+                if FileManager.default.fileExists(atPath: state.tempFilePath.path) {
+                    let attributes = try FileManager.default.attributesOfItem(atPath: state.tempFilePath.path)
+                    let fileSize = attributes[.size] as? Int ?? 0
+                    
+                    // Create a new downloader that resumes from the temp file
+                    let downloader = Downloader(
+                        from: state.sourceURL,
+                        to: state.destinationURL,
+                        using: authToken,
+                        resumeSize: fileSize,
+                        expectedSize: state.expectedSize,
+                        existingTempFile: state.tempFilePath
+                    )
+                    
+                    resumedDownloaders.append(downloader)
+                }
+            } catch {
+                print("Error restoring download: \(error)")
+            }
+        }
+        
+        return resumedDownloaders
+    }
+}

Sources/Hub/Hub.swift

@@ -7,23 +7,37 @@
 
 import Foundation
 
-public struct Hub {}
+public struct Hub {
+    /// Resume all downloads that were in progress when the app was previously closed
+    ///
+    /// - Parameters:
+    ///   - authToken: Optional authentication token for accessing private repositories
+    /// - Returns: Array of Downloader objects for the resumed downloads
+    static func resumeAllDownloads(authToken: String? = nil) -> [Downloader] {
+        print("[Hub] Resuming all persisted downloads...")
+        let downloaders = Downloader.resumeAllPersistedDownloads(authToken: authToken)
+        print("[Hub] Resumed \(downloaders.count) downloads from previous session")
+        return downloaders
+    }
+}
 
 public extension Hub {
     enum HubClientError: Error {
         case parse
         case authorizationRequired
         case unexpectedError
         case httpStatusCode(Int)
+        case missingFile
+        case noNetworkConnection
     }
 
-    enum RepoType: String {
+    enum RepoType: String, Codable {
         case models
         case datasets
         case spaces
     }
 
-    struct Repo {
+    struct Repo: Codable {
         public let id: String
         public let type: RepoType
 
@@ -34,6 +48,23 @@ public extension Hub {
     }
 }
 
+/// Network monitoring utility to track connectivity status
+internal class NetworkMonitor {
+    static let shared = NetworkMonitor()
+    
+    private(set) var isConnected: Bool = true
+    
+    static var isOffline: Bool {
+        return !NetworkMonitor.shared.isConnected
+    }
+    
+    func startMonitoring() {
+        // Simplified implementation - in a real app, use NWPathMonitor
+        // to actually track network status
+        self.isConnected = true
+    }
+}
+
 // MARK: - Configuration files with dynamic lookup
 
 @dynamicMemberLookup

Sources/Hub/HubApi.swift

@@ -401,10 +401,54 @@ public extension HubApi {
             try prepareDestination()
             try prepareMetadataDestination()
 
-            let downloader = Downloader(from: source, to: destination, using: hfToken, inBackground: backgroundSession, expectedSize: remoteSize)
+            // Check for an existing partial download for this file
+            let filename = source.lastPathComponent
+            // Create a stable hash by extracting just the path component
+            let urlPath = source.absoluteString
+            // Use a deterministic hash that doesn't change between app launches
+            let stableHash = abs(urlPath.data(using: .utf8)!.reduce(5381) {
+                ($0 << 5) &+ $0 &+ Int32($1)
+            })
+            let hashedName = "\(filename)-\(stableHash)"
+            let possibleTempFile = FileManager.default.temporaryDirectory.appendingPathComponent(hashedName)
+            var resumeSize = 0
+            
+            if FileManager.default.fileExists(atPath: possibleTempFile.path) {
+                if let fileAttributes = try? FileManager.default.attributesOfItem(atPath: possibleTempFile.path) {
+                    resumeSize = (fileAttributes[FileAttributeKey.size] as? Int) ?? 0
+                    print("[HubApi] Found existing partial download for \(filename): \(resumeSize) bytes at \(possibleTempFile.path)")
+                }
+            } else {
+                print("[HubApi] No existing partial download found for \(filename)")
+            }
+            
+            let downloader = Downloader(
+                from: source,
+                to: destination,
+                using: hfToken,
+                inBackground: backgroundSession,
+                resumeSize: resumeSize,
+                expectedSize: remoteSize,
+                existingTempFile: FileManager.default.fileExists(atPath: possibleTempFile.path) ? possibleTempFile : nil
+            )
+            
             let downloadSubscriber = downloader.downloadState.sink { state in
-                if case .downloading(let progress) = state {
+                switch state {
+                case .downloading(let progress):
+                    // After we have a few bytes downloaded, we know the temp file exists
+                    // This is a good time to persist state
+                    if progress > 0.01 { // After we have 1% downloaded
+                        downloader.persistState()
+                    }
                     progressHandler(progress)
+                case .completed:
+                    // Remove from persisted downloads when complete
+                    downloader.removePersistedState()
+                case .failed:
+                    // Keep in persisted downloads when failed so it can be resumed
+                    downloader.persistState()
+                case .notStarted:
+                    break
                 }
             }
             _ = try withExtendedLifetime(downloadSubscriber) {

Tests/HubTests/DownloaderTests.swift

@@ -22,10 +22,14 @@ final class DownloaderTests: XCTestCase {
         super.setUp()
         tempDir = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         try? FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)
+        
+        // Clear any persisted downloads from previous tests
+        UserDefaults.standard.removeObject(forKey: "SwiftTransformers.ActiveDownloads")
     }
 
     override func tearDown() {
         try? FileManager.default.removeItem(at: tempDir)
+        UserDefaults.standard.removeObject(forKey: "SwiftTransformers.ActiveDownloads")
         super.tearDown()
     }
 
@@ -159,4 +163,45 @@ final class DownloaderTests: XCTestCase {
             throw error
         }
     }
+    
+    func testPersistedDownloads() throws {
+        // Create a test downloader
+        let url = URL(string: "https://huggingface.co/coreml-projects/sam-2-studio/resolve/main/SAM%202%20Studio%201.1.zip")!
+        let destination = tempDir.appendingPathComponent("SAM%202%20Studio%201.1.zip")
+
+        // First create a temp file so we can persist the state
+        let urlPath = url.absoluteString
+        let stableHash = abs(urlPath.data(using: .utf8)!.reduce(5381) {
+            ($0 << 5) &+ $0 &+ Int32($1)
+        })
+        let hashedName = "\(url.lastPathComponent)-\(stableHash)"
+        let tempFilePath = FileManager.default.temporaryDirectory.appendingPathComponent(hashedName)
+        
+        // Create a sample file
+        FileManager.default.createFile(atPath: tempFilePath.path, contents: "test content".data(using: .utf8))
+        
+        let downloader = Downloader(
+            from: url,
+            to: destination,
+            expectedSize: 73194001,
+            existingTempFile: tempFilePath
+        )
+        
+        // Persist the download state
+        downloader.persistState()
+        
+        // Check if we get a non-empty array when resuming
+        let resumedDownloaders = Downloader.resumeAllPersistedDownloads()
+        XCTAssertFalse(resumedDownloaders.isEmpty, "Should have resumed downloads")
+        
+        // Clean up persisted state
+        downloader.removePersistedState()
+        
+        // Check that the list is now empty
+        let emptyDownloaders = Downloader.resumeAllPersistedDownloads()
+        XCTAssertTrue(emptyDownloaders.isEmpty, "Should have no downloads after removal")
+        
+        // Clean up temp file
+        try? FileManager.default.removeItem(at: tempFilePath)
+    }
 }