Use atomic create for lock

Author: roulpriya

Sources/Swiftly/Install.swift

@@ -357,7 +357,7 @@ struct Install: SwiftlyCommand {
 
             let (pathChanged, newConfig) = try await withLock(lockFile) {
                 if verbose {
-                    await ctx.print("Acquired installation lock.")
+                    await ctx.print("Acquired installation lock")
                 }
 
                 var config = try await Config.load(ctx)

Sources/SwiftlyCore/FileLock.swift

@@ -1,60 +1,49 @@
 import Foundation
 import SystemPackage
 
-/**
- * A non-blocking file lock implementation using file creation as locking mechanism.
- * Use case: When installing multiple Swiftly instances on the same machine,
- * one should acquire the lock while others poll until it becomes available.
- */
+enum FileLockError: Error {
+    case cannotAcquireLock
+    case timeoutExceeded
+}
 
-public actor FileLock {
+/// A non-blocking file lock implementation using file creation as locking mechanism.
+/// Use case: When installing multiple Swiftly instances on the same machine,
+/// one should acquire the lock while others poll until it becomes available.
+public struct FileLock {
     let filePath: FilePath
-    private var isLocked = false
 
     public static let defaultPollingInterval: TimeInterval = 1
     public static let defaultTimeout: TimeInterval = 300.0
 
-    public init(at path: FilePath) {
+    public init(at path: FilePath) throws {
         self.filePath = path
-    }
-
-    public func tryLock() async -> Bool {
         do {
-            guard !self.isLocked else { return true }
-
-            guard !(try await FileSystem.exists(atPath: self.filePath)) else {
-                return false
-            }
-            // Create the lock file with exclusive permissions
-            try await FileSystem.create(.mode(0o600), file: self.filePath, contents: nil)
-            self.isLocked = true
-            return true
-        } catch {
-            return false
+            let fileURL = URL(fileURLWithPath: self.filePath.string)
+            let contents = getpid().description.data(using: .utf8) ?? Data()
+            try contents.write(to: fileURL, options: .withoutOverwriting)
+        } catch CocoaError.fileWriteFileExists {
+            throw FileLockError.cannotAcquireLock
         }
     }
 
-    public func waitForLock(
+    public static func waitForLock(
+        _ path: FilePath,
         timeout: TimeInterval = FileLock.defaultTimeout,
         pollingInterval: TimeInterval = FileLock.defaultPollingInterval
-    ) async -> Bool {
+    ) async throws -> FileLock {
         let start = Date()
-
         while Date().timeIntervalSince(start) < timeout {
-            if await self.tryLock() {
-                return true
+            if let fileLock = try? FileLock(at: path) {
+                return fileLock
             }
             try? await Task.sleep(for: .seconds(pollingInterval))
         }
 
-        return false
+        throw FileLockError.timeoutExceeded
     }
 
     public func unlock() async throws {
-        guard self.isLocked else { return }
-
         try await FileSystem.remove(atPath: self.filePath)
-        self.isLocked = false
     }
 }
 
@@ -64,20 +53,22 @@ public func withLock<T>(
     pollingInterval: TimeInterval = FileLock.defaultPollingInterval,
     action: @escaping () async throws -> T
 ) async throws -> T {
-    let lock = FileLock(at: lockFile)
-    guard await lock.waitForLock(timeout: timeout, pollingInterval: pollingInterval) else {
-        throw SwiftlyError(message: "Failed to acquire file lock at \(lock.filePath)")
+    guard
+        let lock = try? await FileLock.waitForLock(
+            lockFile,
+            timeout: timeout,
+            pollingInterval: pollingInterval
+        )
+    else {
+        throw SwiftlyError(message: "Failed to acquire file lock at \(lockFile)")
     }
 
-    defer {
-        Task {
-            do {
-                try await lock.unlock()
-            } catch {
-                print("WARNING: Failed to unlock file: \(error)")
-            }
-        }
+    do {
+        let result = try await action()
+        try await lock.unlock()
+        return result
+    } catch {
+        try await lock.unlock()
+        throw error
     }
-
-    return try await action()
 }