Synchronize access to task data and completion handler.

Using regular completion handler on non-background uploads.
Properly capture response and response error in `SubmitChunkUploadOperation`.
Allow commit operation to be always executed after all chunk operations are finished.

Author: Ruben Nine

Sources/FilestackSDK/Internal/Operations/SubmitChunkUploadOperation.swift

@@ -109,12 +109,12 @@ private extension SubmitChunkUploadOperation {
         uploadTask = UploadService.shared.upload(data: data, to: url, method: "PUT", headers: headers, uploadProgress: { (progress) in
             self.progress.totalUnitCount = Int64(self.data.size ?? 0)
             self.progress.completedUnitCount = Int64(Double(self.progress.totalUnitCount) * progress.fractionCompleted)
-        }) { (request, data, error) in
+        }) { (_, response, error) in
             self.uploadTask = nil
 
-            if let error = response.error {
+            if let error = error {
                 self.finish(with: .failure(.wrapped(error)))
-            } else if let httpURLResponse = response.response, httpURLResponse.statusCode == 200 {
+            } else if let httpURLResponse = response as? HTTPURLResponse, httpURLResponse.statusCode == 200 {
                 self.progress.completedUnitCount = self.progress.totalUnitCount
                 self.finish(with: .success(httpURLResponse))
             } else {

Sources/FilestackSDK/Internal/Operations/SubmitPartIntelligentUploadOperation.swift

@@ -60,21 +60,22 @@ private extension SubmitPartIntelligentUploadOperation {
     func upload() {
         let chunkSize = Defaults.resumableMobileChunkSize
         var chunkOffset: UInt64 = 0
-        let finishOperation = BlockOperation { self.executeCommit() }
 
         while !isCancelled, chunkOffset < UInt64(size) {
             // Guard against EOF
             guard let chunkOperation = submitChunk(chunkOffset: chunkOffset, chunkSize: chunkSize) else { break }
 
-            finishOperation.addDependency(chunkOperation)
-
             let actualChunkSize = chunkOperation.progress.totalUnitCount
 
             progress.addChild(chunkOperation.progress, withPendingUnitCount: Int64(actualChunkSize))
             chunkOffset += UInt64(actualChunkSize)
         }
 
-        chunkUploadOperationQueue.addOperation(finishOperation)
+        chunkUploadOperationQueue.waitUntilAllOperationsAreFinished()
+
+        if !isCancelled {
+            executeCommit()
+        }
     }
 
     func submitChunk(chunkOffset: UInt64, chunkSize: Int, retries: Int = Defaults.maxRetries) -> SubmitChunkUploadOperation? {

Sources/FilestackSDK/Internal/Services/UploadService.swift

@@ -11,6 +11,39 @@ import os.log
 
 private let Shared = UploadService()
 
+// Provides synchronized access to task data and completion handlers.
+struct TaskState {
+    typealias CompletionHandler = (Data?, URLResponse?, Swift.Error?) -> Void
+
+    private var taskData: [URLSessionDataTask: Data] = [:]
+    private var taskCompletion: [URLSessionDataTask: CompletionHandler] = [:]
+    private let syncQueue = DispatchQueue(label: "io.filestack.TaskState-sync-queue")
+
+    func getData(for task: URLSessionDataTask) -> Data? {
+        syncQueue.sync { taskData[task] }
+    }
+
+    mutating func setData(for task: URLSessionDataTask, data: Data) {
+        syncQueue.sync { taskData[task] = data }
+    }
+
+    func getCompletion(for task: URLSessionDataTask) -> CompletionHandler? {
+        syncQueue.sync { taskCompletion[task] }
+    }
+
+    mutating func setCompletionHandler(for task: URLSessionDataTask, completionHandler: @escaping CompletionHandler) {
+        syncQueue.sync { taskCompletion[task] = completionHandler }
+    }
+
+    mutating func forget(task: URLSessionDataTask) {
+        syncQueue.sync {
+            taskData.removeValue(forKey: task)
+            taskCompletion.removeValue(forKey: task)
+        }
+    }
+}
+
+
 /// Service used for uploading files.
 @objc(FSUploadService)
 public final class UploadService: NSObject, NetworkingService {
@@ -20,8 +53,7 @@ public final class UploadService: NSObject, NetworkingService {
 
     // MARK: - Private Properties
 
-    private var taskData: [URLSessionDataTask: Data] = [:]
-    private var taskCompletion: [URLSessionDataTask: (Data?, URLResponse?, Swift.Error?) -> Void] = [:]
+    private var taskState = TaskState()
 
     // MARK: - Public Properties
 
@@ -52,10 +84,9 @@ extension UploadService: URLSessionDataDelegate {
         completionHandler(URLSession.ResponseDisposition .allow)
 
         if response.expectedContentLength == 0 || dataTask.error != nil {
-            let completionHandler = taskCompletion[dataTask]
+            let completionHandler = taskState.getCompletion(for: dataTask)
 
-            taskData.removeValue(forKey: dataTask)
-            taskCompletion.removeValue(forKey: dataTask)
+            taskState.forget(task: dataTask)
 
             DispatchQueue.main.async {
                 completionHandler?(nil, response, dataTask.error)
@@ -64,19 +95,18 @@ extension UploadService: URLSessionDataDelegate {
     }
 
     public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
-        if var existingData = taskData[dataTask] {
+        if var existingData = taskState.getData(for: dataTask) {
             existingData.append(data)
-            taskData[dataTask] = existingData
+            taskState.setData(for: dataTask, data: existingData)
         } else {
-            taskData[dataTask] = data
+            taskState.setData(for: dataTask, data: data)
         }
 
         if let response = dataTask.response {
-            let data = taskData[dataTask]
-            let completionHandler = taskCompletion[dataTask]
+            let data = taskState.getData(for: dataTask)
+            let completionHandler = taskState.getCompletion(for: dataTask)
 
-            taskData.removeValue(forKey: dataTask)
-            taskCompletion.removeValue(forKey: dataTask)
+            taskState.forget(task: dataTask)
 
             DispatchQueue.main.async {
                 completionHandler?(data, response, dataTask.error)
@@ -107,12 +137,16 @@ extension UploadService {
             defer { try? FileManager.default.removeItem(at: dataURL) }
 
             task = session.uploadTask(with: request, fromFile: dataURL)
+
+            taskState.setCompletionHandler(for: task, completionHandler: completionHandler)
         } else {
-            task = session.uploadTask(with: request, from: data)
+            task = session.uploadTask(with: request, from: data) { (data, response, error) in
+                DispatchQueue.main.async {
+                    completionHandler(data, response, error)
+                }
+            }
         }
 
-        taskCompletion[task] = completionHandler
-
         if let uploadProgress = uploadProgress {
             var progressObservers: [NSKeyValueObservation] = []