Cross-platform Xcode replacement. Build and deploy iOS apps with SwiftPM on Linux, Windows, macOS.
Fix tmpdir reentrancy (#234)
Kabir Oberai7f151a9c66c9
diff --git a/Package.swift b/Package.swiftindex 01fe34f..9446d21 100644--- a/Package.swift+++ b/Package.swift@@ -92,7 +92,12 @@ let package = Package(exclude: ["openapi-generator-config.yaml", "patch.js"]),// common utilities shared across xtool targets- .target(name: "XUtils"),+ .target(+ name: "XUtils",+ dependencies: [+ .product(name: "SystemPackage", package: "swift-system"),+ ]+ ),.target(name: "XKit",dependencies: [diff --git a/Sources/XUtils/System+Utils.swift b/Sources/XUtils/System+Utils.swiftnew file mode 100644index 0000000..df47da9--- /dev/null+++ b/Sources/XUtils/System+Utils.swift@@ -0,0 +1,53 @@+import Foundation++#if canImport(System)+import System++public typealias FilePath = System.FilePath+public typealias FileDescriptor = System.FileDescriptor+public typealias Errno = System.Errno+#else+import SystemPackage++public typealias FilePath = SystemPackage.FilePath+public typealias FileDescriptor = SystemPackage.FileDescriptor+public typealias Errno = SystemPackage.Errno++extension URL {+ public init?(filePath: FilePath) {+ self.init(filePath: filePath.string)+ }+}++extension FilePath {+ public init?(_ url: URL) {+ guard url.isFileURL else { return nil }+ self.init(url.path)+ }+}+#endif++extension FileDescriptor {+ enum LockMode {+ case shared+ case exclusive++ fileprivate var raw: CInt {+ switch self {+ case .shared: LOCK_SH+ case .exclusive: LOCK_EX+ }+ }+ }++ func tryLock(mode: LockMode) throws -> Bool {+ if flock(rawValue, mode.raw | LOCK_NB) == 0 {+ return true+ }+ let err = errno+ if err == EWOULDBLOCK {+ return false+ }+ throw Errno(rawValue: err)+ }+}diff --git a/Sources/XUtils/TemporaryDirectory.swift b/Sources/XUtils/TemporaryDirectory.swiftindex d3206c8..fdd3295 100644--- a/Sources/XUtils/TemporaryDirectory.swift+++ b/Sources/XUtils/TemporaryDirectory.swift@@ -4,6 +4,7 @@ package struct TemporaryDirectory: ~Copyable {private static let debugTmp = ProcessInfo.processInfo.environment["XTL_DEBUG_TMP"] != nilprivate var shouldDelete: Bool+ private let base: URLpackage let url: URL/// Prepares a fresh tmpdir root.@@ -19,15 +20,19 @@ package struct TemporaryDirectory: ~Copyable {/// To save the contents, move them elsewhere with ``persist(at:)``.package init(name: String) throws {do {- let basename = name.replacingOccurrences(of: ".", with: "_")- self.url = try TemporaryDirectoryRoot.shared.url+ let basename = name+ .replacingOccurrences(of: ".", with: "_")+ .replacingOccurrences(of: "/", with: "_")+ .prefix(32)+ self.base = try TemporaryDirectoryRoot.shared.url// ensures uniqueness- .appendingPathComponent("tmp-\(basename)-\(UUID().uuidString)")- .appendingPathComponent(name, isDirectory: true)+ .appendingPathComponent("dir-\(basename)-\(UUID().uuidString)")+ self.url = base.appendingPathComponent(name, isDirectory: true)self.shouldDelete = true} catch {// non-copyable types can't be partially initialized so we need a stub value- self.url = URL(fileURLWithPath: "")+ self.base = URL(fileURLWithPath: "")+ self.url = baseself.shouldDelete = falsethrow error}@@ -40,11 +45,12 @@ package struct TemporaryDirectory: ~Copyable {private func _delete() {guard !Self.debugTmp else { return }- try? FileManager.default.removeItem(at: url)+ try? FileManager.default.removeItem(at: base)}package consuming func persist(at location: URL) throws {try FileManager.default.moveItem(at: url, to: location)+ _delete()// we do this after moving, so that if the move fails we clean upshouldDelete = false}@@ -83,23 +89,95 @@ private struct TemporaryDirectoryRoot {url = FileManager.default.temporaryDirectory.appendingPathComponent("sh.xtool")#endif}- try? FileManager.default.removeItem(at: url)- do {- try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)- } catch {- self._url = .failure(Errors.tmpdirCreationFailed(url, error))- return++ Self.pruneOrphans(in: url)++ self._url = Result {+ let childDir = try Self.claimDirectory(in: url)+ try FileManager.default.createDirectory(at: childDir, withIntermediateDirectories: true)+ return childDir+ }+ .mapError { $0 as? Errors ?? .tmpdirCreationFailed(url, $0) }+ }++ private static func claimDirectory(in url: URL) throws -> URL {+ // create a lockfile + tmpdir. while we hold the lock, other instaces of+ // xtool will not delete the directory during their prune step.++ try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)++ let pid = ProcessInfo.processInfo.processIdentifier++ for i in 0..<10 {+ let random = "pid-\(pid)-\(i == 0 ? "0" : UUID().uuidString)"+ let lockFile = url.appending(path: "\(random).lock")+ #if os(macOS)+ let fd = try FileDescriptor.open(+ FilePath(lockFile.path),+ .writeOnly,+ options: [.create, .exclusiveLock],+ permissions: [.ownerReadWrite, .groupRead, .otherRead],+ )+ #else+ let fd = try FileDescriptor.open(+ FilePath(lockFile.path),+ .writeOnly,+ options: [.create],+ permissions: [.ownerReadWrite, .groupRead, .otherRead],+ )+ guard try fd.tryLock(mode: .exclusive) else {+ // someone else raced us and claimed the right to prune between when we created the file and+ // when we tried to lock it+ continue+ }+ #endif+ // leak the file descriptor so that the lock is held until the process exits+ return url.appending(path: random)+ }+ throw Errors.tmpdirClaimFailed(url)+ }++ private static func pruneOrphans(in url: URL) {+ guard let children = try? FileManager.default.contentsOfDirectory(at: url, includingPropertiesForKeys: nil)+ else { return }+ for lock in children {+ do {+ let basename = lock.lastPathComponent+ if basename.hasPrefix("tmp-") {+ // legacy tmpdir, remove it+ try? FileManager.default.removeItem(at: lock)+ continue+ }+ guard basename.hasPrefix("pid-") && basename.hasSuffix(".lock") else { continue }+ let lockFD = try FileDescriptor.open(FilePath(lock.path), .readWrite)+ defer { try? lockFD.close() }+ if try lockFD.tryLock(mode: .exclusive) {+ // we must remove the directory first. if we instead removed the lock first,+ // we could be killed after the lock was removed but before the dir was+ // removed and therefore leave it hanging around.+ do {+ try FileManager.default.removeItem(at: lock.deletingPathExtension())+ } catch CocoaError.fileNoSuchFile {+ // pass+ }+ try FileManager.default.removeItem(at: lock)+ }+ } catch {+ // continue+ }}- self._url = .success(url)}enum Errors: Error, CustomStringConvertible {case tmpdirCreationFailed(URL, Error)+ case tmpdirClaimFailed(URL)var description: String {switch self {case let .tmpdirCreationFailed(url, error):- "Could not create temporary directory at '\(url.path)': \(error)"+ "Could not create temporary directory in '\(url.path)': \(error)"+ case let .tmpdirClaimFailed(url):+ "Could not claim temporary directory in '\(url.path)'"}}}