added withLock to FileSystem

Author: tgymnich

Sources/TSCBasic/FileSystem.swift

@@ -10,6 +10,7 @@
 
 import TSCLibc
 import Foundation
+import Dispatch
 
 public enum FileSystemError: Swift.Error {
     /// Access to the path is denied.
@@ -200,6 +201,9 @@ public protocol FileSystem: class {
 
     /// Move a file or directory.
     func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws
+
+    /// Execute the given block while holding the lock.
+    func withLock<T>(on path: AbsolutePath, type: LockType, _ body: () throws -> T) throws -> T
 }
 
 /// Convenience implementations (default arguments aren't permitted in protocol
@@ -240,6 +244,10 @@ public extension FileSystem {
     func getFileInfo(_ path: AbsolutePath) throws -> FileInfo {
         throw FileSystemError.unsupported
     }
+
+    func withLock<T>(on path: AbsolutePath, type: LockType, _ body: () throws -> T) throws -> T {
+        throw FileSystemError.unsupported
+    }
 }
 
 /// Concrete FileSystem implementation which communicates with the local file system.
@@ -450,6 +458,11 @@ private class LocalFileSystem: FileSystem {
         guard !exists(destinationPath) else { throw FileSystemError.alreadyExistsAtDestination }
         try FileManager.default.moveItem(at: sourcePath.asURL, to: destinationPath.asURL)
     }
+
+    func withLock<T>(on path: AbsolutePath, type: LockType = .exclusive, _ body: () throws -> T) throws -> T {
+        let lock = FileLock(name: path.basename, cachePath: path.parentDirectory)
+        return try lock.withLock(type: type, body)
+    }
 }
 
 // FIXME: This class does not yet support concurrent mutation safely.
@@ -502,6 +515,10 @@ public class InMemoryFileSystem: FileSystem {
 
     /// The root filesytem.
     private var root: Node
+    /// A dispatch queue for accessing the lock map in a thread safe manner.
+    private let lockMapQueue = DispatchQueue(label: "org.swift.swiftpm.\(InMemoryFileSystem.self).lockQueue")
+    /// A map that keeps weak references to all locked files.
+    private let lockMap = NSMapTable<NSString, ReadWriteLock>(keyOptions: .copyIn, valueOptions: .weakMemory)
 
     public init() {
         root = Node(.directory(DirectoryContents()))
@@ -760,6 +777,20 @@ public class InMemoryFileSystem: FileSystem {
 
         contents.entries[sourcePath.basename] = nil
     }
+
+    public func withLock<T>(on path: AbsolutePath, type: LockType = .exclusive, _ body: () throws -> T) throws -> T {
+        var fileLock: ReadWriteLock?
+        
+        lockMapQueue.sync {
+            if let lock = lockMap.object(forKey: path.pathString as NSString) {
+                fileLock = lock
+            } else {
+                fileLock = ReadWriteLock()
+                lockMap.setObject(fileLock, forKey: path.pathString as NSString)
+            }
+        }
+        return try fileLock!.withLock(type: type, body)
+    }
 }
 
 /// A rerooted view on an existing FileSystem.
@@ -864,6 +895,10 @@ public class RerootedFileSystemView: FileSystem {
     public func move(from sourcePath: AbsolutePath, to destinationPath: AbsolutePath) throws {
         try underlyingFileSystem.move(from: formUnderlyingPath(sourcePath), to: formUnderlyingPath(sourcePath))
     }
+
+    public func withLock<T>(on path: AbsolutePath, type: LockType = .exclusive, _ body: () throws -> T) throws -> T {
+        return try underlyingFileSystem.withLock(on: formUnderlyingPath(path), type: type, body)
+    }
 }
 
 /// Public access to the local FS proxy.