Skip to content

armgit / xtool

Public Imported from GitHub
0

Cross-platform Xcode replacement. Build and deploy iOS apps with SwiftPM on Linux, Windows, macOS.

sdk: self-updating darwin tools (#110)

Kabir Oberai6efd77fc0e71
diff --git a/Package.resolved b/Package.resolved
index f6984ae..86385fa 100644
--- a/Package.resolved
+++ b/Package.resolved
@@ -1,5 +1,5 @@
{
- "originHash" : "90ad8f84cef9a5c63d7cc80c20c4a7e332fd63bead7d72ee1d94da8b1a0a2186",
+ "originHash" : "699acd851f15c2680059dd4a90ef6f0aca240fda0f5bdda5ec4156ff0df44adf",
"pins" : [
{
"identity" : "aexml",
diff --git a/Package.swift b/Package.swift
index e1a050b..58c308f 100644
--- a/Package.swift
+++ b/Package.swift
@@ -181,6 +181,7 @@ let package = Package(
name: "PackLib",
dependencies: [
"XUtils",
+ .product(name: "Superutils", package: "xtool-core"),
.product(name: "Yams", package: "Yams"),
.product(name: "XcodeGenKit", package: "XcodeGen", condition: .when(platforms: [.macOS])),
],
diff --git a/Sources/PackLib/DarwinSDK.swift b/Sources/PackLib/DarwinSDK.swift
index 2386e8b..9d59675 100644
--- a/Sources/PackLib/DarwinSDK.swift
+++ b/Sources/PackLib/DarwinSDK.swift
@@ -1,40 +1,100 @@
import Foundation
import XUtils
import Subprocess
+import Superutils
public struct DarwinSDK {
+ package struct TemporaryBundle: ~Copyable {
+ package let url: URL
+
+ fileprivate init(url: URL) {
+ self.url = url
+ }
+
+ package consuming func install() async throws {
+ guard DarwinSDK(bundle: url) != nil else {
+ throw StringError("Invalid Darwin SDK at '\(url.path)'")
+ }
+
+ try await DarwinSDK.addHostClangResourceDir(to: url)
+
+ let destination = url.deletingLastPathComponent()
+ .appendingPathComponent("darwin.artifactbundle", isDirectory: true)
+ try FileManager.default.moveItem(at: url, to: destination)
+ }
+
+ deinit {
+ try? FileManager.default.removeItem(at: url)
+ }
+ }
+
+ public enum Flavor {
+ // can't be updated in place
+ case slim
+ // can be updated in place, includes a whole copy of Xcode.app
+ case normal
+ // from before the slim/normal split existed (version "develop")
+ case legacy
+ }
+
public let bundle: URL
public let version: String
+ public let flavor: Flavor
+
+ static func swiftPMDirectory(
+ environment: [String: String] = ProcessInfo.processInfo.environment,
+ homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser
+ ) throws -> URL {
+ if let configurationDirectory = environment["XDG_CONFIG_HOME"] {
+ guard (configurationDirectory as NSString).isAbsolutePath else {
+ throw StringError("XDG_CONFIG_HOME must be an absolute path: '\(configurationDirectory)'")
+ }
+ return URL(fileURLWithPath: configurationDirectory, isDirectory: true)
+ .appendingPathComponent("swiftpm", isDirectory: true)
+ } else {
+ return homeDirectory.appendingPathComponent(".swiftpm", isDirectory: true)
+ }
+ }
+
+ private static func swiftSDKsDirectory(
+ environment: [String: String] = ProcessInfo.processInfo.environment,
+ homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser
+ ) throws -> URL {
+ try swiftPMDirectory(environment: environment, homeDirectory: homeDirectory)
+ .appendingPathComponent("swift-sdks", isDirectory: true)
+ }
public init?(bundle: URL) {
self.bundle = bundle
if let version = try? Data(contentsOf: bundle.appendingPathComponent("darwin-sdk-version.txt")) {
self.version = String(decoding: version, as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
- } else if ["darwin.xtoolsdk", "darwin.artifactbundle"].contains(bundle.lastPathComponent) {
- self.version = "unknown"
+ } else if ["darwin.xtoolsdk", "darwin.artifactbundle", "darwin.artifactbundle.tmp"].contains(bundle.lastPathComponent) {
+ self.version = "develop"
} else {
return nil
}
- }
-
- public static func install(from path: String) async throws {
- // we can't just move into ~/.swiftpm/swift-sdks because the swiftpm directory
- // location depends on factors like $XDG_CONFIG_HOME. Rather than replicating
- // SwiftPM's logic, which may change, it's more reliable to directly invoke
- // `swift sdk install`. See: https://github.com/xtool-org/xtool/pull/40
- let url = URL(fileURLWithPath: path)
- guard DarwinSDK(bundle: url) != nil else { throw StringError("Invalid Darwin SDK at '\(path)'")}
-
- try await addHostClangResourceDir(to: url)
+ if version == "develop" {
+ self.flavor = .legacy
+ } else if bundle.appendingPathComponent("Xcode.app").dirExists {
+ self.flavor = .normal
+ } else {
+ self.flavor = .slim
+ }
+ }
- try await Subprocess.run(
- .name("swift"),
- arguments: ["sdk", "install", url.path],
- output: .discarded
- )
- .checkSuccess()
+ package static func prepareTemporaryBundle(
+ environment: [String: String] = ProcessInfo.processInfo.environment,
+ homeDirectory: URL = FileManager.default.homeDirectoryForCurrentUser
+ ) throws -> TemporaryBundle {
+ let sdksDirectory = try swiftSDKsDirectory(environment: environment, homeDirectory: homeDirectory)
+ try FileManager.default.createDirectory(at: sdksDirectory, withIntermediateDirectories: true)
+ let bundle = sdksDirectory.appendingPathComponent("darwin.artifactbundle.tmp", isDirectory: true)
+ if FileManager.default.fileExists(atPath: bundle.path) {
+ try FileManager.default.removeItem(at: bundle)
+ }
+ return TemporaryBundle(url: bundle)
}
private static func addHostClangResourceDir(to sdk: URL) async throws {
@@ -51,38 +111,10 @@ public struct DarwinSDK {
try await FileManager.default.copyItem(at: hostInclude, to: sdkInclude, preserveOwner: false)
}
- public static func current() async throws -> DarwinSDK? {
- let outputString: String
- do {
- outputString = try await Subprocess.run(
- .name("swift"),
- arguments: ["sdk", "configure", "darwin", "arm64-apple-ios", "--show-configuration"],
- output: .string(limit: .max)
- )
- .checkSuccess()
- .standardOutput
- ?? ""
- } catch SubprocessFailure.exited {
- return nil
- }
-
- // should be something like
- // swiftResourcesPath: /home/user/.swiftpm/swift-sdks/darwin.artifactbundle/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift
- // swiftlint:disable:previous line_length
- let resourcesPathPrefix = "swiftResourcesPath: "
-
- guard let resourcesPath = outputString
- .split(separator: "\n")
- .first(where: { $0.hasPrefix(resourcesPathPrefix) })?
- .dropFirst(resourcesPathPrefix.count)
- else { return nil }
-
- var resourcesURL = URL(fileURLWithPath: String(resourcesPath))
- for _ in 0..<6 {
- resourcesURL = resourcesURL.deletingLastPathComponent()
- }
-
- return DarwinSDK(bundle: resourcesURL)
+ public static func current() throws -> DarwinSDK? {
+ let bundle = try swiftSDKsDirectory().appendingPathComponent("darwin.artifactbundle", isDirectory: true)
+ guard bundle.dirExists else { return nil }
+ return DarwinSDK(bundle: bundle)
}
public func remove() throws {
diff --git a/Sources/XToolSupport/DevCommand.swift b/Sources/XToolSupport/DevCommand.swift
index a827354..f9a43e0 100644
--- a/Sources/XToolSupport/DevCommand.swift
+++ b/Sources/XToolSupport/DevCommand.swift
@@ -27,6 +27,8 @@ struct PackOperation {
@discardableResult
func run() async throws -> URL {
+ try await EnsureSDKOperation(quiet: true).run()
+
print("Planning...")
let schema: PackSchema
diff --git a/Sources/XToolSupport/SDKBuilder.swift b/Sources/XToolSupport/SDKBuilder.swift
index 96e7f6f..8f2deed 100644
--- a/Sources/XToolSupport/SDKBuilder.swift
+++ b/Sources/XToolSupport/SDKBuilder.swift
@@ -52,13 +52,42 @@ struct SDKBuilder {
}
}
+ enum Mode {
+ /// Create a slim SDK with just the files that this version of xtool uses
+ case buildSlim
+ /// Create an SDK that retains a full copy of Xcode.app/Contents/Developer.
+ /// Larger but allows in-place updates.
+ case buildNormal
+ /// Update a normal SDK in-place.
+ case update
+
+ var usesHardLinks: Bool {
+ switch self {
+ case .buildSlim: false
+ case .buildNormal, .update: true
+ }
+ }
+ }
+
let input: Input
let output: URL
let arch: Arch
+ let mode: Mode
+
+ // bump this when the sdk builder logic changes
+ static let sdkEpoch = 1
+
+ // tag from https://github.com/xtool-org/darwin-tools-linux-llvm
+ static let darwinToolsVersion = "1.0.1"
+
+ static var currentSDKVersion: String {
+ """
+ epoch=\(sdkEpoch),darwinTools=\(darwinToolsVersion)
+ """
+ }
func buildSDK() async throws {
- // TODO: store relevant info for staleness check
- let sdkVersion = "develop"
+ let sdkVersion = Self.currentSDKVersion
try? FileManager.default.removeItem(at: output)
try FileManager.default.createDirectory(
@@ -170,9 +199,6 @@ struct SDKBuilder {
}
private func installToolset(in output: URL) async throws {
- // tag from https://github.com/xtool-org/darwin-tools-linux-llvm
- let darwinToolsVersion = "1.0.1"
-
let toolsetDir = output.appendingPathComponent("toolset")
try FileManager.default.createDirectory(
@@ -183,7 +209,7 @@ struct SDKBuilder {
@Dependency(\.httpClient) var httpClient
let url = URL(string: """
https://github.com/xtool-org/darwin-tools-linux-llvm/releases/download/\
- v\(darwinToolsVersion)/toolset-\(arch.rawValue).tar.gz
+ v\(Self.darwinToolsVersion)/toolset-\(arch.rawValue).tar.gz
""")!
let (response, body) = try await httpClient.send(HTTPRequest(url: url))
guard response.status == 200, let body else { throw Console.Error("Could not fetch toolset") }
@@ -224,23 +250,19 @@ struct SDKBuilder {
private func installDeveloper(in output: URL) async throws -> URL {
let dev = output.appendingPathComponent("Developer")
+ let expectedAppDir = output.appendingPathComponent("Xcode.app")
let appDir: URL
let cleanupStageDir: URL?
let wanted: Int?
- switch input {
- case .xip(let inputPath):
- let devStage = output.appendingPathComponent("DeveloperStage")
- try FileManager.default.createDirectory(at: devStage, withIntermediateDirectories: false)
- // unxip doesn't like cooperative cancellation atm so shield it.
- // if the user does a ^C during unxip, we'll just wait until extraction
- // is over before bailing
- wanted = try await Task {
- try await extractXIP(inputPath: inputPath, outDir: devStage.path)
- }.value
+ switch (input, mode) {
+ case (.xip(let inputPath), .buildSlim):
+ let stage = output.appendingPathComponent("DeveloperStage")
+ try FileManager.default.createDirectory(at: stage, withIntermediateDirectories: false)
+ wanted = try await extractXIP(inputPath: inputPath, outDir: stage.path)
try Task.checkCancellation()
let contents = try FileManager.default.contentsOfDirectory(
- at: devStage,
+ at: stage,
includingPropertiesForKeys: nil
)
let apps = contents.filter { $0.pathExtension == "app" }
@@ -252,12 +274,39 @@ struct SDKBuilder {
default:
throw Console.Error("Unrecognized xip layout (multiple apps found)")
}
- cleanupStageDir = devStage
- case .app(let appPath):
- wanted = nil
+ cleanupStageDir = stage
+ case (.xip(let inputPath), .buildNormal):
+ wanted = try await extractXIP(inputPath: inputPath, outDir: output.path)
+ appDir = expectedAppDir
+ cleanupStageDir = nil
+ case (.xip, .update):
+ throw Console.Error("Can't update with xip input")
+ case (.app(let appPath), .buildSlim), (.app(let appPath), .update):
appDir = URL(fileURLWithPath: appPath)
+ wanted = nil
+ cleanupStageDir = nil
+ case (.app(let appPath), .buildNormal):
+ let source = URL(fileURLWithPath: appPath)
+ let sourceContentsDir = source.appendingPathComponent("Contents")
+ let expectedContentsDir = expectedAppDir.appendingPathComponent("Contents")
+ try FileManager.default.createDirectory(at: expectedContentsDir, withIntermediateDirectories: true)
+ print("[Copying Xcode.app] This might take a minute...")
+ for child in ["Info.plist", "version.plist", "Developer"] {
+ let expectedFile = expectedContentsDir.appendingPathComponent(child)
+ let sourceFile = sourceContentsDir.appendingPathComponent(child)
+ guard FileManager.default.fileExists(atPath: sourceFile.path) else {
+ throw Console.Error("""
+ The provided directory at '\(appPath)' does not appear to be a known version of Xcode: \
+ could not read '\(sourceFile.path)'
+ """)
+ }
+ try await FileManager.default.copyItem(at: sourceFile, to: expectedFile, preserveOwner: false)
+ }
+ appDir = expectedAppDir
+ wanted = nil
cleanupStageDir = nil
}
+ try Task.checkCancellation()
try FileManager.default.createDirectory(at: dev, withIntermediateDirectories: false)
@@ -280,7 +329,7 @@ struct SDKBuilder {
}
if count % 100 == 0 {
if wanted == nil {
- print("\r[Installing SDKs] Copied \(count) files", terminator: "")
+ print("\r[Installing SDKs] Installed \(count) files", terminator: "")
fflush(stdoutSafe)
}
await Task.yield()
@@ -293,7 +342,11 @@ struct SDKBuilder {
if try child.resourceValues(forKeys: [.isDirectoryKey]).isDirectory == true {
toDoDirs.append(path)
try FileManager.default.createDirectory(at: dest, withIntermediateDirectories: false)
+ } else if mode.usesHardLinks {
+ // Installed SDKs retain Xcode.app developer dir, so avoid storing their developer files twice.
+ try FileManager.default.linkItem(at: child, to: dest)
} else {
+ // Slim SDKs omit Xcode.app and contain independent copies.
try FileManager.default.copyItem(at: child, to: dest)
}
}
@@ -305,9 +358,9 @@ struct SDKBuilder {
}
print()
- print("[Cleaning up]")
if let cleanupStageDir {
- try? FileManager.default.removeItem(at: cleanupStageDir)
+ print("[Cleaning up]")
+ try FileManager.default.removeItem(at: cleanupStageDir)
}
print("[Finalizing SDKs]")
@@ -350,6 +403,8 @@ struct SDKBuilder {
)
}
+ // we copy over the host's clang resorurce dir during install, because intrinsics can differ
+ // by LLVM version
try FileManager.default.removeItem(
at: dev.appending(path: "Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/clang/include")
)
@@ -357,9 +412,18 @@ struct SDKBuilder {
return dev
}
+ private func extractXIP(inputPath: String, outDir: String) async throws -> Int {
+ // unxip doesn't like cooperative cancellation atm so shield it.
+ // if the user does a ^C during unxip, we'll just wait until extraction
+ // is over before bailing
+ try await Task {
+ try await _extractXIP(inputPath: inputPath, outDir: outDir)
+ }.value
+ }
+
// returns the number of files we actually want to keep,
// useful for computing progress % during fs traversal
- private func extractXIP(inputPath: String, outDir: String) async throws -> Int {
+ private func _extractXIP(inputPath: String, outDir: String) async throws -> Int {
let fd = try FileDescriptor.open(inputPath, .readOnly)
defer { try? fd.close() }
diff --git a/Sources/XToolSupport/SDKCommand.swift b/Sources/XToolSupport/SDKCommand.swift
index 3b0b720..30ebad2 100644
--- a/Sources/XToolSupport/SDKCommand.swift
+++ b/Sources/XToolSupport/SDKCommand.swift
@@ -13,6 +13,7 @@ struct SDKCommand: AsyncParsableCommand {
abstract: "Manage the Darwin Swift SDK",
subcommands: [
DevSDKInstallCommand.self,
+ DevSDKUpdateCommand.self,
DevSDKRemoveCommand.self,
DevSDKBuildCommand.self,
DevSDKStatusCommand.self,
@@ -49,7 +50,7 @@ struct DevSDKBuildCommand: AsyncParsableCommand {
let builderArch = try arch.sdkBuilderArch
let input = try SDKBuilder.Input(path: path)
let output = URL(fileURLWithPath: outputDir, isDirectory: true).appending(path: "darwin.xtoolsdk")
- let builder = SDKBuilder(input: input, output: output, arch: builderArch)
+ let builder = SDKBuilder(input: input, output: output, arch: builderArch, mode: .buildSlim)
try await builder.buildSDK()
print("Built SDK at \(output.path). You can install it with `xtool sdk install`.")
}
@@ -90,8 +91,24 @@ struct DevSDKInstallCommand: AsyncParsableCommand {
)
var path: String
+ @Flag(
+ help: "Install a slim SDK (uses less disk space). Slim SDKs cannot be updated in place."
+ )
+ var slim = false
+
+ func run() async throws {
+ try await InstallSDKOperation(path: path, slim: slim).run()
+ }
+}
+
+struct DevSDKUpdateCommand: AsyncParsableCommand {
+ static let configuration = CommandConfiguration(
+ commandName: "update",
+ abstract: "Update the installed Darwin Swift SDK"
+ )
+
func run() async throws {
- try await InstallSDKOperation(path: path).run()
+ try await UpdateSDKOperation().run()
}
}
@@ -102,7 +119,7 @@ struct DevSDKRemoveCommand: AsyncParsableCommand {
)
func run() async throws {
- guard let sdk = try await DarwinSDK.current() else {
+ guard let sdk = try DarwinSDK.current() else {
throw Console.Error("Cannot remove SDK: no Darwin SDK installed")
}
try sdk.remove()
@@ -117,8 +134,11 @@ struct DevSDKStatusCommand: AsyncParsableCommand {
)
func run() async throws {
- if let sdk = try await DarwinSDK.current() {
- print("Installed at \(sdk.bundle.path)")
+ if let sdk = try DarwinSDK.current() {
+ print("Darwin SDK is installed")
+ print(" Path: \(sdk.bundle.path)")
+ print(" Flavor: \(sdk.flavor)")
+ print(" Version: \(sdk.version)")
} else {
print("Not installed")
}
@@ -127,7 +147,7 @@ struct DevSDKStatusCommand: AsyncParsableCommand {
extension DarwinSDK {
func isUpToDate() -> Bool {
- true
+ version == SDKBuilder.currentSDKVersion
}
}
@@ -165,38 +185,137 @@ extension SwiftVersion {
}
}
+struct EnsureSDKOperation {
+ let quiet: Bool
+
+ func run() async throws {
+ #if os(macOS)
+ if !quiet {
+ print("Skipping Darwin SDK setup since we're on macOS.")
+ }
+ #else
+ let sdk = try DarwinSDK.current()
+ switch sdk.map({ ($0.isUpToDate(), $0.flavor) }) {
+ case (true, _)?: // swiftlint:disable:this optional_enum_case_matching
+ if !quiet {
+ print("Darwin SDK is up to date.")
+ }
+ case (false, .slim)?: // swiftlint:disable:this optional_enum_case_matching
+ throw Console.Error("""
+ Darwin SDK is out of date, and was installed in 'slim' mode.
+
+ Slim SDKs take less disk space, but can't be auto-updated.
+ Please install a new SDK with
+ xtool sdk install [--slim]
+ """)
+ case (false, .normal)?: // swiftlint:disable:this optional_enum_case_matching
+ print("Darwin SDK is out of date. Rebuilding...")
+ try await UpdateSDKOperation().run()
+ case (false, .legacy)?: // swiftlint:disable:this optional_enum_case_matching
+ print("""
+ Darwin SDK is incompatible: built with an older version of xtool.
+
+ Requesting re-install. This is a one-time rebuild; after this,
+ xtool will be able to resolve incompatibilities automatically.
+
+ """)
+ try await generateSDK()
+ case nil:
+ print("Now generating the Darwin SDK.\n")
+ try await generateSDK()
+ }
+
+ func generateSDK() async throws {
+ let path = try await Console.prompt("""
+ Please download Xcode from http://developer.apple.com/download/all/?q=Xcode
+ and enter the path to the downloaded Xcode.xip.
+
+ Path to Xcode.xip: \("" /* pacify swiftlint trailing_whitespace */)
+ """)
+
+ let expanded = (path as NSString).expandingTildeInPath
+
+ try await InstallSDKOperation(path: expanded).run()
+ }
+ #endif
+ }
+}
+
struct InstallSDKOperation {
let path: String
+ let slim: Bool
+
+ init(path: String, slim: Bool = false) {
+ self.path = path
+ self.slim = slim
+ }
func run() async throws {
#if os(macOS)
print("Skipping SDK install; the iOS SDK ships with Xcode on macOS")
#else
- let tempDir = try TemporaryDirectory(name: "DarwinSDKBuild")
- let sdkPath = tempDir.url.appending(path: "darwin.artifactbundle")
+ let temporaryBundle = try DarwinSDK.prepareTemporaryBundle()
if path.hasSuffix(".xtoolsdk") {
print("Installing prebuilt SDK...")
- try await FileManager.default.copyItem(at: URL(filePath: path), to: sdkPath, preserveOwner: false)
+ try await FileManager.default.copyItem(at: URL(filePath: path), to: temporaryBundle.url, preserveOwner: false)
} else {
// validate input before removing existing SDK
let input = try SDKBuilder.Input(path: path)
let arch = try ArchSelection.auto.sdkBuilderArch
- let builder = SDKBuilder(input: input, output: sdkPath, arch: arch)
+ let mode: SDKBuilder.Mode = slim ? .buildSlim : .buildNormal
+ let builder = SDKBuilder(input: input, output: temporaryBundle.url, arch: arch, mode: mode)
try await builder.buildSDK()
}
- if let sdk = try await DarwinSDK.current() {
+ if let sdk = try DarwinSDK.current() {
print("Removing existing SDK...")
try sdk.remove()
}
- try await DarwinSDK.install(from: sdkPath.path)
+ try await temporaryBundle.install()
+ #endif
+ }
+}
+
+struct UpdateSDKOperation {
+ func run() async throws {
+ #if os(macOS)
+ print("Skipping SDK install; the iOS SDK ships with Xcode on macOS")
+ #else
+ guard let existing = try DarwinSDK.current() else {
+ throw Console.Error("Could not locate existing SDK; cannot perform update.")
+ }
+ let xcode = existing.bundle.appendingPathComponent("Xcode.app")
+ guard xcode.dirExists else {
+ // This includes prebuilt .xtoolsdk installs and installs created with --slim.
+ throw Console.Error("""
+ The installed SDK was built in 'slim' mode and cannot be updated in place. \
+ Please install a new copy with `xtool sdk install`.
+ """)
+ }
+
+ let input = try SDKBuilder.Input(path: xcode.path)
+ let arch = try ArchSelection.auto.sdkBuilderArch
+
+ let temporaryBundle = try DarwinSDK.prepareTemporaryBundle()
+ let builder = SDKBuilder(input: input, output: temporaryBundle.url, arch: arch, mode: .update)
+ try await builder.buildSDK()
+
+ guard DarwinSDK(bundle: temporaryBundle.url) != nil else {
+ throw Console.Error("Invalid Darwin SDK at '\(temporaryBundle.url.path)'")
+ }
+
+ try FileManager.default.moveItem(
+ at: xcode,
+ to: temporaryBundle.url.appendingPathComponent("Xcode.app")
+ )
+ try existing.remove()
+ try await temporaryBundle.install()
- // don't destroy tempDir before this point
- withExtendedLifetime(tempDir) {}
+ print("Updated SDK")
#endif
}
}
diff --git a/Sources/XToolSupport/SetupCommand.swift b/Sources/XToolSupport/SetupCommand.swift
index cff7c77..65749f3 100644
--- a/Sources/XToolSupport/SetupCommand.swift
+++ b/Sources/XToolSupport/SetupCommand.swift
@@ -24,36 +24,6 @@ struct SetupOperation {
func run() async throws {
try await AuthOperation(logoutFromExisting: false, quiet: quiet).run()
-
- #if os(macOS)
- if !quiet {
- print("Skipping Darwin SDK setup since we're on macOS.")
- }
- #else
- switch try await DarwinSDK.current()?.isUpToDate() {
- case true?:
- if !quiet {
- print("Darwin SDK is up to date.")
- }
- case false?:
- if !quiet {
- print("Darwin SDK is outdated.")
- }
- fallthrough
- case nil:
- let path = try await Console.prompt("""
- Now generating the Darwin SDK.
-
- Please download Xcode from http://developer.apple.com/download/all/?q=Xcode
- and enter the path to the downloaded Xcode.xip.
-
- Path to Xcode.xip: \("" /* pacify swiftlint trailing_whitespace */)
- """)
-
- let expanded = (path as NSString).expandingTildeInPath
-
- try await InstallSDKOperation(path: expanded).run()
- }
- #endif
+ try await EnsureSDKOperation(quiet: quiet).run()
}
}
diff --git a/Sources/XUtils/Foundation+Utils.swift b/Sources/XUtils/Foundation+Utils.swift
index 3067a86..d35ba25 100644
--- a/Sources/XUtils/Foundation+Utils.swift
+++ b/Sources/XUtils/Foundation+Utils.swift
@@ -34,11 +34,18 @@ extension FileManager {
#if canImport(Subprocess)
if !preserveOwner {
- try await Subprocess.run(
+ let result = try await Subprocess.run(
.name("cp"),
arguments: ["-R", srcURL.path, dstURL.path],
output: .discarded,
- ).checkSuccess()
+ error: .string(limit: .max, encoding: UTF8.self),
+ )
+ do {
+ try result.checkSuccess()
+ } catch {
+ print("Error copying \(srcURL.path) to \(dstURL.path): \(result.standardError ?? "unknown")")
+ throw error
+ }
return
}
#endif
diff --git a/Tests/XToolTests/DarwinSDKTests.swift b/Tests/XToolTests/DarwinSDKTests.swift
new file mode 100644
index 0000000..ed5ecb5
--- /dev/null
+++ b/Tests/XToolTests/DarwinSDKTests.swift
@@ -0,0 +1,55 @@
+import Foundation
+import Testing
+@testable import PackLib
+
+@Test func swiftPMDirectoryUsesXDGConfigHome() throws {
+ let directory = try DarwinSDK.swiftPMDirectory(
+ environment: ["XDG_CONFIG_HOME": "/xdg/config"],
+ homeDirectory: URL(fileURLWithPath: "/home/test")
+ )
+
+ #expect(directory.path == "/xdg/config/swiftpm")
+}
+
+@Test func swiftPMDirectoryFallsBackToHomeDirectory() throws {
+ let directory = try DarwinSDK.swiftPMDirectory(
+ environment: [:],
+ homeDirectory: URL(fileURLWithPath: "/home/test")
+ )
+
+ #expect(directory.path == "/home/test/.swiftpm")
+}
+
+@Test func swiftPMDirectoryRejectsRelativeXDGConfigHome() {
+ #expect(throws: StringError.self) {
+ try DarwinSDK.swiftPMDirectory(
+ environment: ["XDG_CONFIG_HOME": "relative/config"],
+ homeDirectory: URL(fileURLWithPath: "/home/test")
+ )
+ }
+}
+
+@Test func temporaryDarwinSDKBundleUsesSwiftSDKsDirectory() throws {
+ let configDirectory = FileManager.default.temporaryDirectory
+ .appendingPathComponent("DarwinSDKTests-\(UUID().uuidString)", isDirectory: true)
+ defer { try? FileManager.default.removeItem(at: configDirectory) }
+
+ let environment = ["XDG_CONFIG_HOME": configDirectory.path]
+ let sdksDirectory = configDirectory.appending(path: "swiftpm/swift-sdks")
+ let temporaryURL = sdksDirectory.appendingPathComponent("darwin.artifactbundle.tmp", isDirectory: true)
+ let installedBundle = sdksDirectory.appending(path: "darwin.artifactbundle")
+ try FileManager.default.createDirectory(at: installedBundle, withIntermediateDirectories: true)
+ try FileManager.default.createDirectory(at: temporaryURL, withIntermediateDirectories: false)
+
+ do {
+ let temporaryBundle = try DarwinSDK.prepareTemporaryBundle(environment: environment)
+ #expect(temporaryBundle.url == temporaryURL)
+ #expect(!FileManager.default.fileExists(atPath: temporaryURL.path))
+
+ try FileManager.default.createDirectory(at: temporaryBundle.url, withIntermediateDirectories: false)
+ #expect(DarwinSDK(bundle: temporaryBundle.url)?.version == "develop")
+ }
+
+ #expect(!FileManager.default.fileExists(atPath: temporaryURL.path))
+ #expect(FileManager.default.fileExists(atPath: installedBundle.path))
+}