Merge pull request #219 from cryptomator/feature/recoverable-uploads

Feature: recoverable uploads

Author: tobihagemann

Cryptomator.xcodeproj/project.pbxproj

@@ -0,0 +1,23 @@
+//
+//  UploadRetrying.swift
+//  CryptomatorCommonCore
+//
+//  Created by Philipp Schmid on 03.05.22.
+//  Copyright © 2021 Skymatic GmbH. All rights reserved.
+//
+
+import FileProvider
+import Foundation
+
+@objc public protocol UploadRetrying: NSFileProviderServiceSource {
+	/**
+	 Retries the upload for the given item identifiers.
+	  */
+	func retryUpload(for itemIdentifiers: [NSFileProviderItemIdentifier], reply: @escaping (Error?) -> Void)
+
+	func getCurrentFractionalUploadProgress(for itemIdentifier: NSFileProviderItemIdentifier, reply: @escaping (NSNumber?) -> Void)
+}
+
+public extension NSFileProviderServiceName {
+	static let uploadRetryingService = NSFileProviderServiceName("org.cryptomator.ios.upload-retrying")
+}

CryptomatorCommon/Sources/CryptomatorCommonCore/FileProviderXPC/UploadRetrying.swift

@@ -0,0 +1,14 @@
+//
+//  FileProviderAction.swift
+//  CryptomatorFileProvider
+//
+//  Created by Philipp Schmid on 03.05.22.
+//  Copyright © 2022 Skymatic GmbH. All rights reserved.
+//
+
+import Foundation
+
+public enum FileProviderAction: String {
+	case retryUpload = "org.cryptomator.ios.fileprovider.retryUpload"
+	case retryWaitingUpload = "org.cryptomator.ios.fileprovider.retryWaitingUpload"
+}

CryptomatorFileProvider/Actions/FileProviderAction.swift

@@ -44,6 +44,13 @@ extension UploadTaskManager {
 		}
 		try removeTaskRecord(for: id)
 	}
+
+	func updateTaskRecord(for itemMetadata: ItemMetadata, with error: NSError) throws {
+		guard let id = itemMetadata.id else {
+			throw DBManagerError.nonSavedItemMetadata
+		}
+		try updateTaskRecord(with: id, lastFailedUploadDate: Date(), uploadErrorCode: error.code, uploadErrorDomain: error.domain)
+	}
 }
 
 class UploadTaskDBManager: UploadTaskManager {

CryptomatorFileProvider/DB/UploadTaskDBManager.swift

@@ -22,8 +22,10 @@ class WorkingSetObserver: WorkingSetObserving {
 	private let cachedFileManager: CachedFileManager
 	private let notificator: FileProviderNotificatorType
 	private var currentWorkingSetItems = Set<FileProviderItem>()
+	private let domainIdentifier: NSFileProviderDomainIdentifier
 
-	init(database: DatabaseReader, notificator: FileProviderNotificatorType, uploadTaskManager: UploadTaskManager, cachedFileManager: CachedFileManager) {
+	init(domainIdentifier: NSFileProviderDomainIdentifier, database: DatabaseReader, notificator: FileProviderNotificatorType, uploadTaskManager: UploadTaskManager, cachedFileManager: CachedFileManager) {
+		self.domainIdentifier = domainIdentifier
 		self.database = database
 		self.notificator = notificator
 		self.uploadTaskManager = uploadTaskManager
@@ -72,7 +74,7 @@ class WorkingSetObserver: WorkingSetObserving {
 			let localCachedFileInfo = try cachedFileManager.getLocalCachedFileInfo(for: metadata)
 			let newestVersionLocallyCached = localCachedFileInfo?.isCurrentVersion(lastModifiedDateInCloud: metadata.lastModifiedDate) ?? false
 			let localURL = localCachedFileInfo?.localURL
-			return FileProviderItem(metadata: metadata, newestVersionLocallyCached: newestVersionLocallyCached, localURL: localURL, error: uploadTasks[index]?.failedWithError)
+			return FileProviderItem(metadata: metadata, domainIdentifier: domainIdentifier, newestVersionLocallyCached: newestVersionLocallyCached, localURL: localURL, error: uploadTasks[index]?.failedWithError)
 		}
 		return items
 	}

CryptomatorFileProvider/DB/WorkingSetObserver.swift

@@ -27,6 +27,7 @@ public protocol FileProviderAdapterType: AnyObject {
 	func startProvidingItem(at url: URL, completionHandler: @escaping ((_ error: Error?) -> Void))
 	func setFavoriteRank(_ favoriteRank: NSNumber?, forItemIdentifier itemIdentifier: NSFileProviderItemIdentifier, completionHandler: @escaping (NSFileProviderItem?, Error?) -> Void)
 	func setTagData(_ tagData: Data?, forItemIdentifier itemIdentifier: NSFileProviderItemIdentifier, completionHandler: @escaping (NSFileProviderItem?, Error?) -> Void)
+	func retryUpload(for itemIdentifier: NSFileProviderItemIdentifier)
 }
 
 public class FileProviderAdapter: FileProviderAdapterType {
@@ -44,9 +45,11 @@ public class FileProviderAdapter: FileProviderAdapterType {
 	private let notificator: FileProviderItemUpdateDelegate?
 	private let fullVersionChecker: FullVersionChecker
 	private let workflowFactory: WorkflowFactoryLocking
+	private let domainIdentifier: NSFileProviderDomainIdentifier
 
-	init(uploadTaskManager: UploadTaskManager, cachedFileManager: CachedFileManager, itemMetadataManager: ItemMetadataManager, reparentTaskManager: ReparentTaskManager, deletionTaskManager: DeletionTaskManager, itemEnumerationTaskManager: ItemEnumerationTaskManager, downloadTaskManager: DownloadTaskManager, scheduler: WorkflowScheduler, provider: CloudProvider, notificator: FileProviderItemUpdateDelegate? = nil, localURLProvider: LocalURLProviderType, fullVersionChecker: FullVersionChecker = UserDefaultsFullVersionChecker.shared) {
+	init(domainIdentifier: NSFileProviderDomainIdentifier, uploadTaskManager: UploadTaskManager, cachedFileManager: CachedFileManager, itemMetadataManager: ItemMetadataManager, reparentTaskManager: ReparentTaskManager, deletionTaskManager: DeletionTaskManager, itemEnumerationTaskManager: ItemEnumerationTaskManager, downloadTaskManager: DownloadTaskManager, scheduler: WorkflowScheduler, provider: CloudProvider, notificator: FileProviderItemUpdateDelegate? = nil, localURLProvider: LocalURLProviderType, fullVersionChecker: FullVersionChecker = UserDefaultsFullVersionChecker.shared) {
 		self.lastUnlockedDate = Date()
+		self.domainIdentifier = domainIdentifier
 		self.uploadTaskManager = uploadTaskManager
 		self.cachedFileManager = cachedFileManager
 		self.itemMetadataManager = itemMetadataManager
@@ -61,7 +64,8 @@ public class FileProviderAdapter: FileProviderAdapterType {
 		                              reparentTaskManager: reparentTaskManager,
 		                              deletionTaskManager: deletionTaskManager,
 		                              itemEnumerationTaskManager: itemEnumerationTaskManager,
-		                              downloadTaskManager: downloadTaskManager)
+		                              downloadTaskManager: downloadTaskManager,
+		                              domainIdentifier: domainIdentifier)
 		self.workflowFactory = WorkflowFactoryLocking(lockManager: LockManager(), workflowFactory: factory)
 		self.scheduler = scheduler
 		self.provider = provider
@@ -84,7 +88,7 @@ public class FileProviderAdapter: FileProviderAdapterType {
 		let localCachedFileInfo = try cachedFileManager.getLocalCachedFileInfo(for: itemMetadata)
 		let newestVersionLocallyCached = localCachedFileInfo?.isCurrentVersion(lastModifiedDateInCloud: itemMetadata.lastModifiedDate) ?? false
 		let localURL = localCachedFileInfo?.localURL
-		return FileProviderItem(metadata: itemMetadata, newestVersionLocallyCached: newestVersionLocallyCached, localURL: localURL, error: uploadTask?.failedWithError)
+		return FileProviderItem(metadata: itemMetadata, domainIdentifier: domainIdentifier, newestVersionLocallyCached: newestVersionLocallyCached, localURL: localURL, error: uploadTask?.failedWithError)
 	}
 
 	// MARK: Enumerate Item
@@ -140,7 +144,7 @@ public class FileProviderAdapter: FileProviderAdapterType {
 				let localCachedFileInfo = try self.cachedFileManager.getLocalCachedFileInfo(for: metadata)
 				let newestVersionLocallyCached = localCachedFileInfo?.isCurrentVersion(lastModifiedDateInCloud: metadata.lastModifiedDate) ?? false
 				let localURL = localCachedFileInfo?.localURL
-				return FileProviderItem(metadata: metadata, newestVersionLocallyCached: newestVersionLocallyCached, localURL: localURL, error: uploadTasks[index]?.failedWithError)
+				return FileProviderItem(metadata: metadata, domainIdentifier: domainIdentifier, newestVersionLocallyCached: newestVersionLocallyCached, localURL: localURL, error: uploadTasks[index]?.failedWithError)
 			}
 		} catch {
 			return Promise(error)
@@ -218,7 +222,7 @@ public class FileProviderAdapter: FileProviderAdapterType {
 
 		// Register LocalURL in the DB
 		try cachedFileManager.cacheLocalFileInfo(for: placeholderMetadata.id!, localURL: localURL, lastModifiedDate: nil)
-		let item = FileProviderItem(metadata: placeholderMetadata, newestVersionLocallyCached: true, localURL: localURL)
+		let item = FileProviderItem(metadata: placeholderMetadata, domainIdentifier: domainIdentifier, newestVersionLocallyCached: true, localURL: localURL)
 		let uploadTaskRecord = try registerFileInUploadQueue(with: localURL, itemMetadata: placeholderMetadata)
 		return LocalItemImportResult(item: item, uploadTaskRecord: uploadTaskRecord)
 	}
@@ -258,14 +262,39 @@ public class FileProviderAdapter: FileProviderAdapterType {
 			let itemMetadata = try getCachedMetadata(for: itemIdentifier)
 			uploadTaskRecord = try registerFileInUploadQueue(with: url, itemMetadata: itemMetadata)
 		} catch {
-			DDLogError("itemChanged - failed to register file in upload queue with url: \(url) and identifier: \(itemIdentifier)")
+			DDLogError("itemChanged - register file in upload queue with url: \(url) and identifier: \(itemIdentifier) failed with error: \(error)")
 			return
 		}
 		uploadFile(taskRecord: uploadTaskRecord).then { item in
 			self.notificator?.signalUpdate(for: item)
 		}
 	}
 
+	public func retryUpload(for itemIdentifier: NSFileProviderItemIdentifier) {
+		let uploadTaskRecord: UploadTaskRecord
+		let itemMetadata: ItemMetadata
+		let localCachedFileInfo: LocalCachedFileInfo
+		do {
+			itemMetadata = try getCachedMetadata(for: itemIdentifier)
+			guard let retrievedLocalCachedFileInfo = try cachedFileManager.getLocalCachedFileInfo(for: itemMetadata) else {
+				DDLogError("retryUpload - retrievedLocalCachedFileInfo is nil for identifier: \(itemIdentifier)")
+				return
+			}
+			localCachedFileInfo = retrievedLocalCachedFileInfo
+			uploadTaskRecord = try registerFileInUploadQueue(with: localCachedFileInfo.localURL, itemMetadata: itemMetadata)
+		} catch {
+			DDLogError("retryUpload - get existing uploadTaskRecord for identifier: \(itemIdentifier) failed with error: \(error)")
+			return
+		}
+		let newestVersionLocallyCached = localCachedFileInfo.isCurrentVersion(lastModifiedDateInCloud: itemMetadata.lastModifiedDate)
+		let localURL = localCachedFileInfo.localURL
+		let item = FileProviderItem(metadata: itemMetadata, domainIdentifier: domainIdentifier, newestVersionLocallyCached: newestVersionLocallyCached, localURL: localURL, error: nil)
+		notificator?.signalUpdate(for: item)
+		uploadFile(taskRecord: uploadTaskRecord).then { item in
+			self.notificator?.signalUpdate(for: item)
+		}
+	}
+
 	func uploadFile(taskRecord: UploadTaskRecord, completionHandler: ((Error?) -> Void)? = nil) -> Promise<FileProviderItem> {
 		let task: UploadTask
 		do {
@@ -412,7 +441,7 @@ public class FileProviderAdapter: FileProviderAdapterType {
 
 		let localCachedFileInfo = try cachedFileManager.getLocalCachedFileInfo(for: itemMetadata)
 		let newestVersionLocallyCached = localCachedFileInfo?.isCurrentVersion(lastModifiedDateInCloud: itemMetadata.lastModifiedDate) ?? false
-		let item = FileProviderItem(metadata: itemMetadata, newestVersionLocallyCached: newestVersionLocallyCached)
+		let item = FileProviderItem(metadata: itemMetadata, domainIdentifier: domainIdentifier, newestVersionLocallyCached: newestVersionLocallyCached)
 		return MoveItemLocallyResult(item: item, reparentTaskRecord: taskRecord)
 	}
 
@@ -590,7 +619,7 @@ public class FileProviderAdapter: FileProviderAdapterType {
 		} catch {
 			return Promise(error)
 		}
-		if itemMetadata.statusCode == .isUploading {
+		if itemMetadata.statusCode == .isUploading || itemMetadata.statusCode == .uploadError {
 			return Promise(true)
 		}
 		return enumerateItems(for: identifier, withPageToken: nil).then { itemList -> Bool in
@@ -685,7 +714,7 @@ public class FileProviderAdapter: FileProviderAdapterType {
 		try checkLocalItemCollision(for: cloudPath)
 		let placeholderMetadata = ItemMetadata(name: name, type: .folder, size: nil, parentID: parentID, lastModifiedDate: nil, statusCode: .isUploading, cloudPath: cloudPath, isPlaceholderItem: true)
 		try itemMetadataManager.cacheMetadata(placeholderMetadata)
-		return FileProviderItem(metadata: placeholderMetadata, newestVersionLocallyCached: true)
+		return FileProviderItem(metadata: placeholderMetadata, domainIdentifier: domainIdentifier, newestVersionLocallyCached: true)
 	}
 
 	/**
@@ -713,7 +742,7 @@ public class FileProviderAdapter: FileProviderAdapterType {
 			do {
 				_ = try deletionTaskManager.getTaskRecord(for: existingItemMetadata.id!)
 			} catch DBManagerError.taskNotFound {
-				throw NSError.fileProviderErrorForCollision(with: FileProviderItem(metadata: existingItemMetadata))
+				throw NSError.fileProviderErrorForCollision(with: FileProviderItem(metadata: existingItemMetadata, domainIdentifier: domainIdentifier))
 			}
 		}
 	}
@@ -774,22 +803,17 @@ public class FileProviderAdapter: FileProviderAdapterType {
 	}
 
 	func convertFileProviderItemIdentifierToInt64(_ identifier: NSFileProviderItemIdentifier) throws -> Int64 {
-		switch identifier {
-		case .rootContainer:
-			return itemMetadataManager.getRootContainerID()
-		default:
-			guard let id = Int64(identifier.rawValue) else {
-				throw FileProviderAdapterError.unsupportedItemIdentifier
-			}
-			return id
+		guard let id = identifier.databaseValue else {
+			throw FileProviderAdapterError.unsupportedItemIdentifier
 		}
+		return id
 	}
 
 	func convertIDToItemIdentifier(_ id: Int64) -> NSFileProviderItemIdentifier {
 		if id == itemMetadataManager.getRootContainerID() {
 			return .rootContainer
 		}
-		return NSFileProviderItemIdentifier("\(id)")
+		return NSFileProviderItemIdentifier(domainIdentifier: domainIdentifier, itemID: id)
 	}
 
 	struct LocalItemImportResult {

CryptomatorFileProvider/FileProviderAdapter.swift

@@ -64,7 +64,7 @@ public class FileProviderAdapterManager: FileProviderAdapterProviding {
 				adapter = cachedAdapter
 			} else {
 				DDLogDebug("Try to automatically unlock \(domain.displayName) - \(domain.identifier)")
-				let autoUnlockItem = try autoUnlockVault(withVaultUID: vaultUID, dbPath: dbPath, delegate: delegate, notificator: notificator)
+				let autoUnlockItem = try autoUnlockVault(withVaultUID: vaultUID, domainIdentifier: domain.identifier, dbPath: dbPath, delegate: delegate, notificator: notificator)
 				adapterCache.cacheItem(autoUnlockItem, identifier: domain.identifier)
 				adapter = autoUnlockItem.adapter
 			}
@@ -78,7 +78,7 @@ public class FileProviderAdapterManager: FileProviderAdapterProviding {
 			return
 		}
 		let provider = try vaultManager.manualUnlockVault(withUID: domainIdentifier.rawValue, kek: kek)
-		let item = try createAdapterCacheItem(cloudProvider: provider, dbPath: dbPath, delegate: delegate, notificator: notificator)
+		let item = try createAdapterCacheItem(domainIdentifier: domainIdentifier, cloudProvider: provider, dbPath: dbPath, delegate: delegate, notificator: notificator)
 		try vaultKeepUnlockedSettings.setLastUsedDate(Date(), forVaultUID: domainIdentifier.rawValue)
 		adapterCache.cacheItem(item, identifier: domainIdentifier)
 		let notificator = try notificatorManager.getFileProviderNotificator(for: NSFileProviderDomain(identifier: domainIdentifier, displayName: "", pathRelativeToDocumentStorage: ""))
@@ -119,7 +119,7 @@ public class FileProviderAdapterManager: FileProviderAdapterProviding {
 		try maintenanceManager.disableMaintenanceMode()
 	}
 
-	private func autoUnlockVault(withVaultUID vaultUID: String, dbPath: URL, delegate: FileProviderAdapterDelegate, notificator: FileProviderNotificatorType) throws -> AdapterCacheItem {
+	private func autoUnlockVault(withVaultUID vaultUID: String, domainIdentifier: NSFileProviderDomainIdentifier, dbPath: URL, delegate: FileProviderAdapterDelegate, notificator: FileProviderNotificatorType) throws -> AdapterCacheItem {
 		guard vaultKeepUnlockedHelper.shouldAutoUnlockVault(withVaultUID: vaultUID) else {
 			try masterkeyCacheManager.removeCachedMasterkey(forVaultUID: vaultUID)
 			throw unlockMonitor.getUnlockError(forVaultUID: vaultUID)
@@ -128,12 +128,12 @@ public class FileProviderAdapterManager: FileProviderAdapterProviding {
 			throw unlockMonitor.getUnlockError(forVaultUID: vaultUID)
 		}
 		let provider = try vaultManager.createVaultProvider(withUID: vaultUID, masterkey: cachedMasterkey)
-		let adapterCacheItem = try createAdapterCacheItem(cloudProvider: provider, dbPath: dbPath, delegate: delegate, notificator: notificator)
+		let adapterCacheItem = try createAdapterCacheItem(domainIdentifier: domainIdentifier, cloudProvider: provider, dbPath: dbPath, delegate: delegate, notificator: notificator)
 		notificator.refreshWorkingSet()
 		return adapterCacheItem
 	}
 
-	private func createAdapterCacheItem(cloudProvider: CloudProvider, dbPath: URL, delegate: FileProviderAdapterDelegate, notificator: FileProviderNotificatorType) throws -> AdapterCacheItem {
+	private func createAdapterCacheItem(domainIdentifier: NSFileProviderDomainIdentifier, cloudProvider: CloudProvider, dbPath: URL, delegate: FileProviderAdapterDelegate, notificator: FileProviderNotificatorType) throws -> AdapterCacheItem {
 		let database = try DatabaseHelper.getMigratedDB(at: dbPath)
 		let itemMetadataManager = ItemMetadataDBManager(database: database)
 		let cachedFileManager = CachedFileDBManager(database: database)
@@ -143,7 +143,8 @@ public class FileProviderAdapterManager: FileProviderAdapterProviding {
 		let itemEnumerationTaskManager = try ItemEnumerationTaskDBManager(database: database)
 		let downloadTaskManager = try DownloadTaskDBManager(database: database)
 		let maintenanceManager = MaintenanceDBManager(database: database)
-		let adapter = FileProviderAdapter(uploadTaskManager: uploadTaskManager,
+		let adapter = FileProviderAdapter(domainIdentifier: domainIdentifier,
+		                                  uploadTaskManager: uploadTaskManager,
 		                                  cachedFileManager: cachedFileManager,
 		                                  itemMetadataManager: itemMetadataManager,
 		                                  reparentTaskManager: reparentTaskManager,
@@ -154,7 +155,7 @@ public class FileProviderAdapterManager: FileProviderAdapterProviding {
 		                                  provider: cloudProvider,
 		                                  notificator: notificator,
 		                                  localURLProvider: delegate)
-		let workingSetObserver = WorkingSetObserver(database: database, notificator: notificator, uploadTaskManager: uploadTaskManager, cachedFileManager: cachedFileManager)
+		let workingSetObserver = WorkingSetObserver(domainIdentifier: domainIdentifier, database: database, notificator: notificator, uploadTaskManager: uploadTaskManager, cachedFileManager: cachedFileManager)
 		workingSetObserver.startObservation()
 		return AdapterCacheItem(adapter: adapter, maintenanceManager: maintenanceManager, workingSetObserver: workingSetObserver)
 	}