Issue #142 Implement non-blocking file lock

Author: roulpriya

Sources/Swiftly/Install.swift

@@ -81,13 +81,61 @@ struct Install: SwiftlyCommand {
         try await self.run(Swiftly.createDefaultContext())
     }
 
+    private func swiftlyHomeDir(_ ctx: SwiftlyCoreContext) -> FilePath {
+        Swiftly.currentPlatform.swiftlyHomeDir(ctx)
+    }
+
     mutating func run(_ ctx: SwiftlyCoreContext) async throws {
         let versionUpdateReminder = try await validateSwiftly(ctx)
         defer {
             versionUpdateReminder()
         }
         try await validateLinked(ctx)
 
+        let lockFile = self.swiftlyHomeDir(ctx) / "swiftly.lock"
+        let fileLock: SwiftlyCore.FileLock
+
+        do {
+            fileLock = try SwiftlyCore.FileLock(at: lockFile.string)
+        } catch {
+            print("ERROR: Failed to create lock file: \(error)")
+            Foundation.exit(43)
+        }
+        if self.root.verbose {
+            await ctx.print("Process \(ProcessInfo.processInfo.processIdentifier): Attempting to acquire installation lock at \(lockFile.string)...")
+        } else {
+            await ctx.print("Attempting to acquire installation lock...")
+        }
+        if fileLock.tryLock() {
+            if self.root.verbose {
+                await ctx.print("Process \(ProcessInfo.processInfo.processIdentifier): Lock acquired immediately")
+            }
+        } else {
+            // If immediate acquisition fails, enter the waiting loop
+            await ctx.print("Lock is held by another process, waiting...")
+            guard fileLock.waitForLock(timeout: 300, pollingInterval: 2) else {
+                print("ERROR: Failed to acquire lock on file: \(lockFile.string) after 300 seconds")
+                Foundation.exit(42)
+            }
+            if self.root.verbose {
+                await ctx.print("Process \(ProcessInfo.processInfo.processIdentifier): Lock acquired after waiting")
+            }
+        }
+
+        defer {
+            do {
+                if self.root.verbose {
+                    print("Process \(ProcessInfo.processInfo.processIdentifier): Releasing installation lock...")
+                }
+                try fileLock.unlock()
+                if self.root.verbose {
+                    print("Process \(ProcessInfo.processInfo.processIdentifier): Installation lock released")
+                }
+            } catch {
+                print("WARNING: Failed to unlock file: \(error)")
+            }
+        }
+
         var config = try await Config.load(ctx)
         let toolchainVersion = try await Self.determineToolchainVersion(ctx, version: self.version, config: &config)
 

Sources/SwiftlyCore/FileLock.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+/**
+ * A non-blocking file lock implementation with polling capability.
+ * Use case: When installing multiple Swiftly instances on the same machine,
+ * one should acquire the lock while others poll until it becomes available.
+ */
+
+#if os(macOS)
+import Darwin.C
+#elseif os(Linux)
+import Glibc
+#endif
+
+public struct FileLock {
+    let filePath: String
+
+    let fileHandle: FileHandle
+
+    public static let defaultPollingInterval: TimeInterval = 1.0
+
+    public static let defaultTimeout: TimeInterval = 300.0
+
+    public init(at filePath: String) throws {
+        self.filePath = filePath
+
+        if !FileManager.default.fileExists(atPath: filePath) {
+            FileManager.default.createFile(atPath: filePath, contents: nil)
+        }
+
+        self.fileHandle = try FileHandle(forWritingTo: URL(fileURLWithPath: filePath))
+    }
+
+    public func tryLock() -> Bool {
+        self.fileHandle.tryLockFile()
+    }
+
+    public func waitForLock(
+        timeout: TimeInterval = FileLock.defaultTimeout,
+        pollingInterval: TimeInterval = FileLock.defaultPollingInterval
+    ) -> Bool {
+        let startTime = Date()
+
+        if self.tryLock() {
+            return true
+        }
+
+        while Date().timeIntervalSince(startTime) < timeout {
+            Thread.sleep(forTimeInterval: pollingInterval)
+
+            if self.tryLock() {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    public func unlock() throws {
+        try self.fileHandle.unlockFile()
+        try self.fileHandle.close()
+    }
+}
+
+extension FileHandle {
+    func tryLockFile() -> Bool {
+        let fd = self.fileDescriptor
+        var flock = flock()
+        flock.l_type = Int16(F_WRLCK)
+        flock.l_whence = Int16(SEEK_SET)
+        flock.l_start = 0
+        flock.l_len = 0
+
+        if fcntl(fd, F_SETLK, &flock) == -1 {
+            if errno == EACCES || errno == EAGAIN {
+                return false
+            } else {
+                fputs("Unexpected lock error: \(String(cString: strerror(errno)))\n", stderr)
+                return false
+            }
+        }
+        return true
+    }
+
+    func unlockFile() throws {
+        let fd = self.fileDescriptor
+        var flock = flock()
+        flock.l_type = Int16(F_UNLCK)
+        flock.l_whence = Int16(SEEK_SET)
+        flock.l_start = 0
+        flock.l_len = 0
+
+        if fcntl(fd, F_SETLK, &flock) == -1 {
+            throw SwiftlyError(
+                message: "Failed to unlock file: \(String(cString: strerror(errno)))")
+        }
+    }
+}