added withLock to FileSystem

Author: tgymnich

Sources/TSCBasic/CMakeLists.txt

@@ -48,7 +48,9 @@ add_library(TSCBasic
   TerminalController.swift
   Thread.swift
   Tuple.swift
-  misc.swift)
+  misc.swift
+  WeakDictionary.swift)
+  
 target_compile_options(TSCBasic PUBLIC
   # Don't use GNU strerror_r on Android.
   "$<$<PLATFORM_ID:Android>:SHELL:-Xcc -U_GNU_SOURCE>"

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 map that keeps weak references to all locked files.
+    private var lockFiles = WeakDictionary<AbsolutePath, DispatchQueue>()
+    /// Used to access lockFiles in a thread safe manner.
+    private let lockFilesLock = Lock()
 
     public init() {
         root = Node(.directory(DirectoryContents()))
@@ -760,6 +777,21 @@ 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 fileQueue: DispatchQueue
+
+        lockFilesLock.lock()
+        if let queue = lockFiles[path] {
+            fileQueue = queue
+        } else {
+            fileQueue = DispatchQueue(label: "foo", attributes: .concurrent)
+            lockFiles[path] = fileQueue
+        }
+        lockFilesLock.unlock()
+
+        return try fileQueue.sync(flags: type == .exclusive ? .barrier : .init() , execute: body)
+    }
 }
 
 /// A rerooted view on an existing FileSystem.
@@ -864,6 +896,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,50 +24,20 @@ public struct Lock {
     public init() {
     }
 
-    /// Execute the given block while holding the lock.
-    public func withLock<T> (_ body: () throws -> T) rethrows -> T {
+    func lock() {
         _lock.lock()
-        defer { _lock.unlock() }
-        return try body()
-    }
-}
-
-/// A lock that allows multiple readers but only one write at the same time.
-public class ReadWriteLock {
-    private var lock = pthread_rwlock_t()
-
-    /// Create a new lock.
-    public init() {
-        pthread_rwlock_init(&lock, nil)
-    }
-
-    func readLock() {
-        pthread_rwlock_rdlock(&lock)
-    }
-
-    func writeLock() {
-        pthread_rwlock_wrlock(&lock)
     }
 
     func unlock() {
-        pthread_rwlock_unlock(&lock)
+        _lock.unlock()
     }
 
     /// Execute the given block while holding the lock.
-    public func withLock<T>(type lockType: LockType = .exclusive, _ body: () throws -> T) rethrows -> T {
-        switch lockType {
-        case .shared:
-            readLock()
-        case .exclusive:
-            writeLock()
-        }
+    public func withLock<T> (_ body: () throws -> T) rethrows -> T {
+        lock()
         defer { unlock() }
         return try body()
     }
-
-    deinit {
-        pthread_rwlock_destroy(&lock)
-    }
 }
 
 enum ProcessLockError: Swift.Error {
@@ -102,29 +72,16 @@ public final class FileLock {
     public func lock(type: LockType = .exclusive) throws {
       #if os(Windows)
         if handle == nil {
-            let h = lockFile.pathString.withCString(encodedAs: UTF16.self, {
-                switch mode {
-                case .exclusive:
-                    CreateFileW(
-                        $0,
-                        UInt32(GENERIC_READ) | UInt32(GENERIC_WRITE),
-                        0,
-                        nil,
-                        DWORD(OPEN_ALWAYS),
-                        DWORD(FILE_ATTRIBUTE_NORMAL),
-                        nil
-                    )
-                case .shared:
-                    CreateFileW(
-                        $0,
-                        UInt32(GENERIC_READ) | UInt32(GENERIC_WRITE),
-                        DWORD(FILE_SHARE_READ),
-                        nil,
-                        DWORD(OPEN_ALWAYS),
-                        DWORD(FILE_ATTRIBUTE_NORMAL),
-                        nil
-                    )
-                }
+            let h: HANDLE = lockFile.pathString.withCString(encodedAs: UTF16.self, {
+                CreateFileW(
+                    $0,
+                    UInt32(GENERIC_READ) | UInt32(GENERIC_WRITE),
+                    UInt32(FILE_SHARE_READ) | UInt32(FILE_SHARE_WRITE),
+                    nil,
+                    DWORD(OPEN_ALWAYS),
+                    DWORD(FILE_ATTRIBUTE_NORMAL),
+                    nil
+                )
             })
             if h == INVALID_HANDLE_VALUE {
                 throw FileSystemError(errno: Int32(GetLastError()))
@@ -135,7 +92,7 @@ public final class FileLock {
         overlapped.Offset = 0
         overlapped.OffsetHigh = 0
         overlapped.hEvent = nil
-        switch mode {
+        switch type {
         case .exclusive:
             if !LockFileEx(handle, DWORD(LOCKFILE_EXCLUSIVE_LOCK), 0,
                            DWORD(INT_MAX), DWORD(INT_MAX), &overlapped) {

Sources/TSCBasic/WeakDictionary.swift

@@ -0,0 +1,28 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+/// A dictionary that only keeps weak references to its values.
+struct WeakDictionary<Key: Hashable, Value: AnyObject> {
+
+    private struct WeakReference<Value: AnyObject> {
+        weak var reference: Value?
+
+        init(_ value: Value?) {
+            self.reference = value
+        }
+    }
+
+    private var storage = Dictionary<Key, WeakReference<Value>>()
+
+    subscript(key: Key) -> Value? {
+        get { storage[key]?.reference }
+        set(newValue) { storage[key] = WeakReference(newValue) }
+    }
+}

Tests/TSCBasicTests/LockTests.swift

@@ -49,38 +49,6 @@ class LockTests: XCTestCase {
         }
     }
 
-    func testReadWriteLock() throws {
-        var a = 0
-        var b = 0
-
-        let lock = ReadWriteLock()
-
-        let writerThreads = (0..<100).map { _ in
-           return Thread {
-                lock.withLock(type: .exclusive) {
-                    a+=1
-                    sched_yield()
-                    b+=1
-                }
-            }
-        }
-
-        let readerThreads = (0..<20).map { _ in
-            return Thread {
-                lock.withLock(type: .shared) {
-                    XCTAssertEqual(a,b)
-                    sched_yield()
-                    XCTAssertEqual(a,b)
-                }
-            }
-        }
-
-        writerThreads.forEach { $0.start() }
-        readerThreads.forEach { $0.start() }
-        writerThreads.forEach { $0.join() }
-        readerThreads.forEach { $0.join() }
-    }
-
     func testReadWriteFileLock() throws {
         try withTemporaryDirectory { tempDir in
             let fileA = tempDir.appending(component: "fileA")