added withLock to FileSystem

Author: tgymnich

Sources/TSCBasic/FileSystem.swift

@@ -200,6 +200,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 +243,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 +457,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 +514,8 @@ public class InMemoryFileSystem: FileSystem {
 
     /// The root filesytem.
     private var root: Node
+    /// 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 +774,22 @@ public class InMemoryFileSystem: FileSystem {
 
         contents.entries[sourcePath.basename] = nil
     }
+
+    public func withLock<T>(on path: AbsolutePath, type: LockType = .exclusive, _ body: () throws -> T) throws -> T {
+        let lock = Lock()
+        var fileLock: ReadWriteLock
+
+        lock.lock()
+        if let lock = lockMap.object(forKey: path.pathString as NSString) {
+            fileLock = lock
+        } else {
+            fileLock = ReadWriteLock()
+            lockMap.setObject(fileLock, forKey: path.pathString as NSString)
+        }
+        lock.unlock()
+
+        return try fileLock.withLock(type: type, body)
+    }
 }
 
 /// A rerooted view on an existing FileSystem.
@@ -864,6 +894,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.

Sources/TSCBasic/Lock.swift

@@ -24,10 +24,18 @@ public struct Lock {
     public init() {
     }
 
+    func lock() {
+        _lock.lock()
+    }
+
+    func unlock() {
+        _lock.unlock()
+    }
+
     /// Execute the given block while holding the lock.
     public func withLock<T> (_ body: () throws -> T) rethrows -> T {
-        _lock.lock()
-        defer { _lock.unlock() }
+        lock()
+        defer { unlock() }
         return try body()
     }
 }