Remove stored file size property from ChunkedFile

Store fileURL inside ChunkedFile when an active handle is available

Simplify state checking inside ChunkedFile

Prevent potential crash due to overflow

Remove SIZE_UNKNOWN

Keep a reference to FileManager for eventual dependency injection when
initializing ChunkedFile

# Conflicts:
#	Sources/MuxUploadSDK/InternalUtilities/ChunkedFile.swift

Author: andrewjl-mux

Sources/MuxUploadSDK/InternalUtilities/ChunkedFile.swift

@@ -13,18 +13,28 @@ import Foundation
 /// Buffers are allocated for each new chunk so they can safely escape to other threads
 /// Call  ``close`` when you're done with this object
 class ChunkedFile {
-    
-    static let SIZE_UNKNOWN: UInt64 = 0
-    /// The size of the file. Call ``open`` to populate this with a real value, otherwise it will be ``SIZE_UNKNOWN``
-    var fileSize: UInt64 {
-        return _fileSize
+
+    private struct State {
+        var fileHandle: FileHandle
+        var fileURL: URL
+        var filePosition: UInt64 = 0
     }
-    
+
     private let chunkSize: Int
-    
-    private var fileHandle: FileHandle?
-    private var filePos: UInt64 = 0
-    private var _fileSize: UInt64 = SIZE_UNKNOWN
+
+    var fileManager = FileManager.default
+
+    private var state: State?
+
+    private var fileHandle: FileHandle? {
+        state?.fileHandle
+    }
+    private var fileURL: URL? {
+        state?.fileURL
+    }
+    private var filePos: UInt64 {
+        state?.filePosition ?? 0
+    }
 
     /// Reads the next chunk from the file, advancing the file for the next read
     ///  This method does synchronous I/O, so call it in the background
@@ -39,20 +49,21 @@ class ChunkedFile {
             return Result.failure(ChunkedFileError.fileHandle(error))
         }
     }
-    
+
     /// Opens the internal file ahead of time. Calling this is optional, but it's available
     /// Calling this multiple times (on the same thread) will have no effect unless you also ``close`` it
     /// Throws if the file couldn't be opened
-    public func openFile(fileURL: URL) throws {
-        if fileHandle == nil {
+    func openFile(fileURL: URL) throws {
+        if state == nil {
             do {
-                guard let fileSize = try FileManager.default.attributesOfItem(atPath: fileURL.path)[FileAttributeKey.size] as? UInt64 else {
+                guard let fileSize = try fileManager.attributesOfItem(atPath: fileURL.path)[FileAttributeKey.size] as? UInt64 else {
                     throw ChunkedFileError.invalidState("Cannot retrieve file size")
                 }
-                self._fileSize = fileSize
-                
-                let handle = try FileHandle(forReadingFrom: fileURL)
-                fileHandle = handle
+                let fileHandle = try FileHandle(forReadingFrom: fileURL)
+                state = State(
+                    fileHandle: fileHandle,
+                    fileURL: fileURL
+                )
                 MuxUploadSDK.logger?.info("Opened file with len \(String(describing: fileSize)) at path \(fileURL.path)")
             } catch {
                 throw ChunkedFileError.fileHandle(error)
@@ -68,23 +79,31 @@ class ChunkedFile {
         } catch {
             MuxUploadSDK.logger?.warning("Swallowed error closing file: \(error.localizedDescription)")
         }
-        fileHandle = nil
-        filePos = 0
-        _fileSize = ChunkedFile.SIZE_UNKNOWN
+        state = nil
     }
 
     public func seekTo(byte: UInt64) throws {
         // Worst case: we start from the begining and there's a few very quick chunk successes
         try fileHandle?.seek(toOffset: byte)
-        filePos = byte
+        state?.filePosition = byte
     }
 
     private func doReadNextChunk() throws -> FileChunk {
         MuxUploadSDK.logger?.info("--doReadNextChunk")
-        guard let fileHandle = fileHandle else {
+        guard let fileHandle = fileHandle, let fileURL = fileURL else {
             throw ChunkedFileError.invalidState("doReadNextChunk called without file handle. Did you call open()?")
         }
         let data = try fileHandle.read(upToCount: chunkSize)
+
+        let fileAttributes = try fileManager.attributesOfItem(
+            atPath: fileURL.path
+        )
+        guard let fileSize = fileAttributes[
+            FileAttributeKey.size
+        ] as? UInt64 else {
+            throw ChunkedFileError.invalidState("Cannot retrieve file size")
+        }
+
         guard let data = data else {
             // Called while already at the end of the file. We read zero bytes, "ending" at the end of the file
             return FileChunk(startByte: fileSize, endByte: fileSize, totalFileSize: fileSize, chunkData: Data(capacity: 0))
@@ -100,7 +119,7 @@ class ChunkedFile {
             chunkData: data
         )
 
-        self.filePos = newFilePos
+        state?.filePosition = newFilePos
 
         return chunk
     }

Sources/MuxUploadSDK/Upload/ChunkedFileUploader.swift

@@ -24,7 +24,7 @@ class ChunkedFileUploader {
     private var delegates: [String : ChunkedFileUploaderDelegate] = [:]
 
     private let file: ChunkedFile
-    private var currentWorkTask: Task<(), Never>? = nil
+    private var currentWorkTask: Task<(), Error>? = nil
     private var _currentState: InternalUploadState = .ready
     private var overallProgress: Progress = Progress()
     private var lastReadCount: UInt64 = 0
@@ -93,7 +93,10 @@ class ChunkedFileUploader {
         let task = Task.detached { [self] in
             do {
                 // It's fine if it's already open, that's handled by ignoring the call
-                let fileSize = file.fileSize
+                let fileSize = (try? FileManager.default.attributesOfItem(
+                    atPath: inputFileURL.path
+                )[FileAttributeKey.size] as? UInt64) ?? 0
+
                 let result = try await makeWorker().performUpload()
                 file.close()
 
@@ -135,23 +138,31 @@ class ChunkedFileUploader {
                 } else {
                     MuxUploadSDK.logger?.debug("Task finished due to error in state \(String(describing: self.currentState))")
                     let uploadError = InternalUploaderError(reason: error, lastByte: lastReadCount)
+                    notifyStateFromWorker(.failure(uploadError))
 
                     if shouldReport {
-                        let fileSize = try file.fetchFileSize(fileURL: inputFileURL)
+                        let fileAttributes = try FileManager.default.attributesOfItem(
+                            atPath: inputFileURL.path
+                        )
+                        guard let fileSize = fileAttributes[
+                            FileAttributeKey.size
+                        ] as? UInt64 else {
+                            return
+                        }
 
                         #warning("Start and end time need to be fixed")
                         reporter.reportUploadFailure(
                             transportStartTime: 0,
                             transportEndTime: 0,
                             errorDescription: uploadError.localizedDescription,
-                            inputSize: file.fileSize,
+                            inputSize: fileSize,
                             inputStandardizationEnabled: uploadInfo.options.inputStandardization.isEnabled,
                             inputDuration: 0.0,
                             uploadURL: uploadInfo.uploadURL
                         )
                     }
 
-                    notifyStateFromWorker(.failure(uploadError))
+
                 }
             }
         }
@@ -288,9 +299,26 @@ fileprivate actor Worker {
         try chunkedFile.seekTo(byte: startingReadCount)
 
         let startTime = Date().timeIntervalSince1970
-        
-        let fileSize = chunkedFile.fileSize
-        let wideFileSize = Int64(fileSize)
+
+        let fileAttributes = try FileManager.default.attributesOfItem(
+            atPath: inputFileURL.path
+        )
+        guard let fileSize = fileAttributes[
+            FileAttributeKey.size
+        ] as? UInt64 else {
+            // TODO: Does the worker need its own error defintion?
+            throw ChunkedFileError.invalidState("Cannot retrieve file size")
+        }
+
+        let wideFileSize: Int64
+
+        // Prevent overflow if UInt64 exceeds Int64.max
+        if fileSize >= Int64.max {
+            wideFileSize = Int64.max
+        } else {
+            wideFileSize = Int64(fileSize)
+        }
+
         overallProgress.totalUnitCount = wideFileSize
         overallProgress.isCancellable = false
         overallProgress.completedUnitCount = Int64(startingReadCount)

Tests/MuxUploadSDKTests/Internal Utilities Tests/ChunkedFileTests.swift

@@ -77,14 +77,7 @@ final class ChunkedFileTests: XCTestCase {
 
     func testMisuseBeforeOpen() throws {
         let file = ChunkedFile(chunkSize: 10 * 1000 * 1000)
-        
-        let fileSizeBeforeOpen = file.fileSize
-        XCTAssertEqual(
-            fileSizeBeforeOpen,
-            ChunkedFile.SIZE_UNKNOWN,
-            "File size should not be known before open"
-        )
-        
+
         let readResult = file.readNextChunk()
         switch readResult {
         case .success(_): return XCTFail("readNextChunk should fail before open")
@@ -104,13 +97,6 @@ final class ChunkedFileTests: XCTestCase {
         try file.openFile(fileURL: testFileURL)
         file.close()
 
-        let fileSizeAfterClose = file.fileSize
-        XCTAssertEqual(
-            fileSizeAfterClose,
-            ChunkedFile.SIZE_UNKNOWN,
-            "File size should not be known after close"
-        )
-        
         let chunkResult = file.readNextChunk()
         switch chunkResult {
         case .success(_): return XCTFail("read after close should not succeed")