Merge pull request #66 from claucambra/bugfix/lock-files

Fix some bugs with file locking

Author: claucambra

Sources/NextcloudFileProviderKit/Database/FilesDatabaseManager.swift

@@ -322,9 +322,14 @@ public final class FilesDatabaseManager: Sendable {
         let database = ncDatabase()
 
         do {
+            // Find the metadatas that we previously knew to be on the server for this account
+            // (we need to check if they were uploaded to prevent deleting ignored/lock files)
+            //
+            // - the ones that do exist remotely still are either the same or have been updated
+            // - the ones that don't have been deleted
             let existingMetadatas = database
                 .objects(RealmItemMetadata.self)
-                .where { $0.account == account && $0.serverUrl == serverUrl }
+                .where { $0.account == account && $0.serverUrl == serverUrl && $0.uploaded }
 
             // NOTE: These metadatas are managed -- be careful!
             let metadatasToDelete = processItemMetadatasToDelete(

Sources/NextcloudFileProviderKit/Item/Item+CreateLockFile.swift

@@ -54,7 +54,7 @@ extension Item {
         Self.logger.info(
             """
             Item to create:
-                \(itemTemplate.filename)
+                \(itemTemplate.filename, privacy: .public)
                 is a lock file. Will handle by remotely locking the target file.
             """
         )
@@ -70,8 +70,9 @@ extension Item {
             )
             return (nil, nil)
         }
-        let (_, _, error) = await remoteInterface.setLockStateForFile(
-            remotePath: parentItemRemotePath + "/" + targetFileName,
+        let targetFileRemotePath = parentItemRemotePath + "/" + targetFileName
+        let (_, _, error) = await remoteInterface.setLockStateForFile( // TODO: NOT WORKING
+            remotePath: targetFileRemotePath,
             lock: true,
             account: account,
             options: .init(),
@@ -93,6 +94,8 @@ extension Item {
                     received error: \(error.errorDescription)
                 """
             )
+        } else {
+            Self.logger.info("Locked file at: \(targetFileRemotePath, privacy: .public)")
         }
 
         let metadata = SendableItemMetadata(
@@ -126,6 +129,10 @@ extension Item {
         dbManager.addItemMetadata(metadata)
 
         progress.completedUnitCount = 1
+        var returnError = error.fileProviderError
+        if #available(macOS 13.0, *), error == .success {
+            returnError = NSFileProviderError(.excludedFromSync)
+        }
 
         return (
             Item(
@@ -135,7 +142,7 @@ extension Item {
                 remoteInterface: remoteInterface,
                 dbManager: dbManager
             ),
-            error.fileProviderError
+            returnError
         )
     }
 }

Sources/NextcloudFileProviderKit/Item/Item+DeleteLockFile.swift

@@ -56,7 +56,7 @@ extension Item {
             return nil
         }
         let originalFileServerFileNameUrl = metadata.serverUrl + "/" + originalFileName
-        let (_, _, error) = await remoteInterface.setLockStateForFile(
+        let (_, _, error) = await remoteInterface.setLockStateForFile( // TODO: NOT WORKING
             remotePath: originalFileServerFileNameUrl,
             lock: false,
             account: account,

Sources/NextcloudFileProviderKit/Item/Item+Fetch.swift

@@ -131,12 +131,30 @@ public extension Item {
         dbManager: FilesDatabaseManager
     ) async -> (URL?, Item?, Error?) {
         let ocId = itemIdentifier.rawValue
+        guard metadata.classFile != "lock", !isLockFileName(filename) else {
+            Self.logger.info(
+                """
+                System requested fetch of lock file \(self.filename, privacy: .public)
+                    will just provide local contents URL if possible.
+                """
+            )
+            if let domain, let localUrl = await localUrlForContents(domain: domain) {
+                return (localUrl, self, nil)
+            } else if #available(macOS 13.0, *) {
+                Self.logger.error("Could not get local contents URL for lock file, erroring")
+                return (nil, self, NSFileProviderError(.excludedFromSync))
+            } else {
+                Self.logger.error("Could not get local contents URL for lock file, nilling")
+                return (nil, self, nil)
+            }
+        }
+
         let serverUrlFileName = metadata.serverUrl + "/" + metadata.fileName
 
         Self.logger.debug(
             """
             Fetching item with name \(self.metadata.fileName, privacy: .public)
-            at URL: \(serverUrlFileName, privacy: .public)
+                at URL: \(serverUrlFileName, privacy: .public)
             """
         )
 

Sources/NextcloudFileProviderKit/Item/Item+Modify.swift

@@ -827,6 +827,22 @@ public extension Item {
         // refactors later on. Just use modifiedItem
         var modifiedItem = self
 
+        guard metadata.classFile != "lock", !isLockFileName(metadata.fileName) else {
+            return await modifiedItem.modifyLockFile(
+                itemTarget: itemTarget,
+                baseVersion: baseVersion,
+                changedFields: changedFields,
+                contents: newContents,
+                options: options,
+                request: request,
+                ignoredFiles: ignoredFiles,
+                domain: domain,
+                forcedChunkSize: forcedChunkSize,
+                progress: progress,
+                dbManager: dbManager
+            )
+        }
+
         let relativePath = (
             metadata.serverUrl + "/" + metadata.fileName
         ).replacingOccurrences(of: account.davFilesUrl, with: "")
@@ -871,22 +887,6 @@ public extension Item {
             return (nil, NSFileProviderError(.noSuchItem))
         }
 
-        guard metadata.classFile != "lock", !isLockFileName(metadata.fileName) else {
-            return await modifiedItem.modifyLockFile(
-                itemTarget: itemTarget,
-                baseVersion: baseVersion,
-                changedFields: changedFields,
-                contents: newContents,
-                options: options,
-                request: request,
-                ignoredFiles: ignoredFiles,
-                domain: domain,
-                forcedChunkSize: forcedChunkSize,
-                progress: progress,
-                dbManager: dbManager
-            )
-        }
-
         let newParentItemIdentifier = itemTarget.parentItemIdentifier
         let isFolder = modifiedItem.contentType.conforms(to: .directory)
         let bundleOrPackage =

Sources/NextcloudFileProviderKit/Item/Item+ModifyLockFile.swift

@@ -103,6 +103,10 @@ extension Item {
             )
         }
 
-        return (modifiedItem, nil)
+        var returnError: Error? = nil
+        if #available(macOS 13.0, *) {
+            returnError = NSFileProviderError(.excludedFromSync)
+        }
+        return (modifiedItem, returnError)
     }
 }

Sources/NextcloudFileProviderKit/Item/Item+ModifyUnuploaded.swift

@@ -34,51 +34,18 @@ extension Item {
         let modifiedItem = self
         var contentsLocation = newContents
         if contentsLocation == nil {
-            assert(domain != nil, "The domain should not be nil!")
-            guard let manager = NSFileProviderManager(for: domain!),
-                  let fileUrl = try? await manager.getUserVisibleURL(
-                    for: modifiedItem.itemIdentifier
-                  )
-            else {
+            assert(domain != nil)
+            guard let domain, let localUrl = await localUrlForContents(domain: domain) else {
                 Self.logger.error(
                     """
                     Unable to upload modified item that was previously ignored.
                         filename: \(modifiedItem.filename, privacy: .public)
-                        Unable to get a file provider manager for the given domain, or item URL
+                        local url for contents could not be acquired.
                     """
                 )
                 return (nil, NSFileProviderError(.cannotSynchronize))
             }
-            let fm = FileManager.default
-            let tempLocation = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString)
-            let coordinator = NSFileCoordinator()
-            var readData: Data?
-            coordinator.coordinate(readingItemAt: fileUrl, options: [], error: nil) { readURL in
-                readData = try? Data(contentsOf: readURL)
-            }
-            guard let readData else {
-                Self.logger.error(
-                    """
-                    Unable to upload modified item that was previously ignored.
-                        filename: \(modifiedItem.filename, privacy: .public)
-                        Unable to get ignored file item data from URL
-                    """
-                )
-                return (nil, NSFileProviderError(.cannotSynchronize))
-            }
-            do {
-                try readData.write(to: tempLocation)
-            } catch let error {
-                Self.logger.error(
-                    """
-                    Unable to upload modified item that was previously ignored.
-                        filename: \(modifiedItem.filename, privacy: .public)
-                        Unable to write ignored file item contents to temp location.
-                        error: \(error.localizedDescription, privacy: .public)
-                    """
-                )
-            }
-            contentsLocation = tempLocation
+            contentsLocation = localUrl
         }
         return await Self.create(
             basedOn: itemTarget,

Sources/NextcloudFileProviderKit/Item/Item.swift

@@ -325,4 +325,51 @@ public class Item: NSObject, NSFileProviderItem {
             dbManager: dbManager
         )
     }
+
+    public func localUrlForContents(domain: NSFileProviderDomain) async -> URL? {
+        guard isDownloaded else {
+            Self.logger.error(
+                """
+                Unable to get local URL for item contents.
+                    filename: \(self.filename, privacy: .public)
+                    Item is not materialised.
+                """
+            )
+            return nil
+        }
+
+        guard let manager = NSFileProviderManager(for: domain),
+              let fileUrl = try? await manager.getUserVisibleURL(for: itemIdentifier)
+        else {
+            Self.logger.error(
+                """
+                Unable to get manager or user visible url for item.
+                    filename: \(self.filename, privacy: .public)
+                    Cannot provide local URL for contents.
+                """
+            )
+            return nil
+        }
+        
+        let fm = FileManager.default
+        let tempLocation = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+        let coordinator = NSFileCoordinator()
+        var readData: Data?
+        coordinator.coordinate(readingItemAt: fileUrl, options: [], error: nil) { readURL in
+            readData = try? Data(contentsOf: readURL)
+        }
+        guard let readData else { return nil }
+        do {
+            try readData.write(to: tempLocation)
+        } catch let error {
+            Self.logger.error(
+                """
+                Unable to write file item contents \(self.filename, privacy: .public) to temp url.
+                    error: \(error.localizedDescription, privacy: .public)
+                    Cannot provide local URL for contents.
+                """
+            )
+        }
+        return tempLocation
+    }
 }