added tests, naming consistency

Author: John Bute

Sources/Basics/Concurrency/PID.swift

@@ -7,7 +7,7 @@
 
 import Foundation
 
-public protocol pidFileManipulator {
+public protocol PIDFileHandler {
     var scratchDirectory: AbsolutePath {get set}
 
     init(scratchDirectory: AbsolutePath)
@@ -20,7 +20,7 @@ public protocol pidFileManipulator {
 
 
 
-public struct pidFile: pidFileManipulator {
+public struct PIDFile: PIDFileHandler {
 
     public var scratchDirectory: AbsolutePath
 
@@ -29,22 +29,22 @@ public struct pidFile: pidFileManipulator {
     }
 
     /// Return the path of the PackageManager.lock.pid file where the PID is located
-    private var pidFilePath: AbsolutePath {
+    private var lockFilePath: AbsolutePath {
         return self.scratchDirectory.appending(component: "PackageManager.lock.pid")
     }
 
     /// Read the pid file
     public func readPID() -> Int32? {
         // Check if the file exists
-        let filePath = pidFilePath.pathString
+        let filePath = lockFilePath.pathString
         guard FileManager.default.fileExists(atPath: filePath)  else {
             print("File does not exist at path: \(filePath)")
             return nil
         }
 
         do {
             // Read the contents of the file
-            let pidString = try String(contentsOf: pidFilePath.asURL, encoding: .utf8).trimmingCharacters(in: .whitespacesAndNewlines)
+            let pidString = try String(contentsOf: lockFilePath.asURL, encoding: .utf8).trimmingCharacters(in: .whitespacesAndNewlines)
 
             // Check if the PID string can be converted to an Int32
             if let pid = Int32(pidString) {
@@ -65,12 +65,12 @@ public struct pidFile: pidFileManipulator {
 
     /// Write .pid file containing PID of process currently using .build directory
     public func writePID(pid: pid_t) throws {
-        try "\(pid)".write(to: pidFilePath.asURL, atomically: true, encoding: .utf8)
+        try "\(pid)".write(to: lockFilePath.asURL, atomically: true, encoding: .utf8)
     }
 
     /// Delete PID file at URL
     public func deletePIDFile() throws {
-        try FileManager.default.removeItem(at: pidFilePath.asURL)
+        try FileManager.default.removeItem(at: lockFilePath.asURL)
     }
 
 }

Sources/CoreCommands/SwiftCommandState.swift

@@ -288,7 +288,7 @@ public final class SwiftCommandState {
 
     private let hostTriple: Basics.Triple?
 
-    private let pidManipulator: pidFileManipulator
+    private let pidManipulator: PIDFileHandler
     package var preferredBuildConfiguration = BuildConfiguration.debug
 
     /// Create an instance of this tool.
@@ -327,7 +327,7 @@ public final class SwiftCommandState {
         hostTriple: Basics.Triple? = nil,
         fileSystem: any FileSystem = localFileSystem,
         environment: Environment = .current,
-        pidManipulator: pidFileManipulator? = nil
+        pidManipulator: PIDFileHandler? = nil
     ) throws {
         self.hostTriple = hostTriple
         self.fileSystem = fileSystem
@@ -411,7 +411,7 @@ public final class SwiftCommandState {
             explicitDirectory: options.locations.swiftSDKsDirectory ?? options.locations.deprecatedSwiftSDKsDirectory
         )
 
-        self.pidManipulator = pidManipulator ?? pidFile(scratchDirectory: self.scratchDirectory)
+        self.pidManipulator = pidManipulator ?? PIDFile(scratchDirectory: self.scratchDirectory)
 
         // set global process logging handler
         AsyncProcess.loggingHandler = { self.observabilityScope.emit(debug: $0) }
@@ -1072,8 +1072,8 @@ public final class SwiftCommandState {
             lockAcquired = true
         } catch ProcessLockError.unableToAquireLock(let errno) {
             if errno == EWOULDBLOCK {
-                let existingPID = self.pidManipulator.readPID()
-                let pidInfo = existingPID.map { "(PID: \($0)) " } ?? ""
+                let existingProcessPID = self.pidManipulator.readPID()
+                let pidInfo = existingProcessPID.map { "(PID: \($0)) " } ?? ""
                 if self.options.locations.ignoreLock {
                     self.outputStream
                         .write(
@@ -1100,7 +1100,11 @@ public final class SwiftCommandState {
         self.workspaceLock = workspaceLock
 
         if lockAcquired || self.options.locations.ignoreLock {
-            try self.pidManipulator.writePID(pid: self.pidManipulator.getCurrentPID())
+            do {
+                try self.pidManipulator.writePID(pid: self.pidManipulator.getCurrentPID())
+            } catch {
+                self.observabilityScope.emit(warning: "Failed to write to PID file: \(error)")
+            }
         }
     }
 

Tests/CommandsTests/SwiftCommandStateTests.swift

@@ -533,6 +533,48 @@ final class SwiftCommandStateTests: CommandsTestCase {
             }
         }
     }
+    
+    func testPIDFileHandlerLifecycle() async throws {
+        try withTemporaryDirectory { tmpDir in
+            let scratchPath = tmpDir.appending(component: "scratch")
+            try localFileSystem.createDirectory(scratchPath)
+
+            var pidHandler: PIDFile = PIDFile(scratchDirectory: scratchPath)
+
+
+
+            // Ensure no PID file exists initially
+            XCTAssertNil(pidHandler.readPID(), "No PID should exist initially")
+
+            // Write current PID
+            let currentPID = pidHandler.getCurrentPID()
+            try pidHandler.writePID(pid: currentPID)
+
+
+            // Read PID back
+            let readPID = pidHandler.readPID()
+            XCTAssertEqual(readPID, currentPID, "PID read should match written PID")
+
+            // Delete the file
+            try pidHandler.deletePIDFile()
+
+            // Ensure file is gone
+            XCTAssertNil(pidHandler.readPID(), "PID should be nil after deletion")
+        }
+    }
+
+    func testMalformedPIDFile() async throws {
+        try withTemporaryDirectory { tmpDir in
+            let scratchPath = tmpDir.appending(component: "scratch")
+            try localFileSystem.createDirectory(scratchPath)
+
+            let pidPath = scratchPath.appending(component: "PackageManager.lock.pid")
+            try localFileSystem.writeFileContents(pidPath, bytes: "notanumber")
+
+            let pidHandler = PIDFile(scratchDirectory: scratchPath)
+            XCTAssertNil(pidHandler.readPID(), "Malformed PID file should result in nil")
+        }
+    }
 }
 
 extension SwiftCommandState {