Compare commits

...

6 Commits

26 changed files with 484 additions and 225 deletions
+8
View File
@@ -0,0 +1,8 @@
*
!/Package.swift
!/Package.resolved
!/Sources
!/Tests
!/Linux
/Linux/packages
/Linux/staging
+14
View File
@@ -81,3 +81,17 @@ jobs:
TAG="${{ github.ref_name }}"
gh release create "$TAG" --draft --title "v$TAG"
gh release upload "$TAG" output/**/*.{AppImage,AppImage.zsync,app.zip,app.dSYM.zip}
docker:
uses: docker/github-builder/.github/workflows/build.yml@v1
permissions:
contents: read # to fetch the repository content
id-token: write # for signing attestations and cache entries with GitHub OIDC
packages: write # to push built images to GitHub Container Registry
with:
output: image
push: true
platforms: linux/amd64,linux/arm64
meta-images: |
ghcr.io/xtool-org/xtool
meta-tags: |
type=semver,pattern={{version}}
+21 -3
View File
@@ -79,11 +79,15 @@ RUN cd xadi \
&& cp -r bin/libxadi.so /prefix/usr/lib/libxadi.so
FROM build-base
FROM build-base AS build-xtool-base
COPY --from=build-limd /prefix/usr /usr
COPY --from=build-xadi /prefix/usr /usr
WORKDIR /xtool
FROM build-xtool-base AS dev
# Docker doesn't support FUSE
ENV APPIMAGE_EXTRACT_AND_RUN=1
@@ -92,6 +96,20 @@ ENV APPIMAGE_EXTRACT_AND_RUN=1
# socat -dd TCP-LISTEN:27015,range=127.0.0.1/32,reuseaddr,fork UNIX-CLIENT:/var/run/usbmuxd
ENV USBMUXD_SOCKET_ADDRESS=host.docker.internal:27015
WORKDIR /xtool
CMD [ "/bin/bash" ]
FROM build-xtool-base AS build-xtool
ADD Package.swift Package.resolved /xtool/
RUN swift package resolve
ADD . /xtool
RUN ./Linux/build.sh
FROM swift:6.3 AS xtool
COPY --from=build-xtool /xtool/Linux/packages/xtool-*.AppImage /xtool/xtool.AppImage
RUN (cd /xtool && ./xtool.AppImage --appimage-extract) \
&& mv /xtool/squashfs-root /usr/local/xtool \
&& rm -rf /xtool \
&& ln -s /usr/local/xtool/AppRun /usr/local/bin/xtool
+1
View File
@@ -22,4 +22,5 @@ else
fi
"$docc" "$command" xtool.docc \
--enable-experimental-code-block-annotations \
--experimental-enable-custom-templates
@@ -14,6 +14,12 @@ If you're on Windows, you can use xtool via [Windows Subsystem for Linux](https:
Once you install WSL, you'll also need to set up USB passthrough. See Microsoft's instructions on [installing USBIPD](https://learn.microsoft.com/en-us/windows/wsl/connect-usb). Make sure you're able to bind your iOS device to WSL via USB.
> Note:
>
> If you encounter `Error: AFCClient.Error.muxError`, follow the steps described in [this issue comment](https://github.com/xtool-org/xtool/issues/19#issuecomment-2898986718) from user rena2019.
>
> This relays the device connection from iTunes on Windows, instead of relying on USBIPD.
### Swift
Install the Swift 6.3 toolchain for your Linux distribution from <https://swift.org/install/linux>.
+4
View File
@@ -56,6 +56,10 @@ linux-clean:
linux-dist:
docker compose run --build --rm xtool Linux/build.sh
.PHONY: docker
docker:
docker build . -t ghcr.io/xtool-org/xtool:latest
.PHONY: mac
# dev build for macOS
mac: project
+10 -1
View File
@@ -1,5 +1,5 @@
{
"originHash" : "eb2a57fb4e4c2c83ff1f1fa55631db81988fc6e2e576a05a3cc5c8ed69432c3a",
"originHash" : "80db0cddb0e78cf6a4c79f94537cdfebd8004679161532fbae8a57ee9d1d8cd1",
"pins" : [
{
"identity" : "aexml",
@@ -352,6 +352,15 @@
"version" : "2.11.0"
}
},
{
"identity" : "swift-subprocess",
"kind" : "remoteSourceControl",
"location" : "https://github.com/swiftlang/swift-subprocess",
"state" : {
"revision" : "11633673a41f509f8945f23c96c7acd4adafd679",
"version" : "0.5.0"
}
},
{
"identity" : "swift-syntax",
"kind" : "remoteSourceControl",
+13 -1
View File
@@ -55,6 +55,7 @@ let package = Package(
.package(url: "https://github.com/apple/swift-nio", from: "2.77.0"),
.package(url: "https://github.com/swiftlang/swift-docc-plugin", from: "1.0.0"),
.package(url: "https://github.com/swiftlang/swift-subprocess", .upToNextMinor(from: "0.5.0")),
.package(url: "https://github.com/swift-server/async-http-client.git", from: "1.23.0"),
.package(url: "https://github.com/swift-server/swift-openapi-async-http-client", from: "1.0.0"),
@@ -92,7 +93,17 @@ 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"),
.product(
name: "Subprocess",
package: "swift-subprocess",
condition: .when(platforms: [.linux, .macOS])
),
]
),
.target(
name: "XKit",
dependencies: [
@@ -135,6 +146,7 @@ let package = Package(
.testTarget(
name: "XToolTests",
dependencies: [
"XKit",
"XToolSupport",
]
),
+27 -21
View File
@@ -1,9 +1,11 @@
import Foundation
import Subprocess
import XUtils
public struct BuildSettings: Sendable {
private static let customBinDir =
// this is the same option used by SwiftPM itself for dev builds
ProcessInfo.processInfo.environment["SWIFTPM_CUSTOM_BIN_DIR"].map { URL(fileURLWithPath: $0) }
ProcessInfo.processInfo.environment["SWIFTPM_CUSTOM_BIN_DIR"].map { FilePath($0) }
private static let envURL = URL(fileURLWithPath: "/usr/bin/env")
@@ -34,18 +36,16 @@ public struct BuildSettings: Sendable {
#if os(macOS)
private static func xcrun(_ arguments: [String]) async throws -> String {
let xcrun = Process()
let pipe = Pipe()
xcrun.executableURL = URL(fileURLWithPath: "/usr/bin/xcrun")
xcrun.arguments = arguments
xcrun.standardOutput = pipe
try await xcrun.runUntilExit()
return String(decoding: pipe.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
let result = try await Subprocess.run(
.path("/usr/bin/xcrun"),
arguments: .init(arguments),
output: .string(limit: .max)
).checkSuccess()
return result.standardOutput?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
}
private static let swiftURL = Task {
try await URL(fileURLWithPath: xcrun(["-f", "swift"]))
try await FilePath(xcrun(["-f", "swift"]))
}
#endif
@@ -53,12 +53,11 @@ public struct BuildSettings: Sendable {
forTool tool: String,
arguments: [String],
packagePathOverride: String? = nil
) async throws -> Process {
let process = Process()
) async throws -> Subprocess.Configuration {
let executable: Executable
let baseArguments: [String]
if let customBinDir = Self.customBinDir {
process.executableURL = customBinDir.appendingPathComponent("swift-\(tool)")
executable = .path(customBinDir.appending("swift-\(tool)"))
baseArguments = []
} else {
#if os(macOS)
@@ -67,9 +66,9 @@ public struct BuildSettings: Sendable {
// 1) invoking the real swift executable (located with `xcrun -f`) and
// 2) explicitly removing SDKROOT from the env, as it may be inherited
// through the `swift run pack` invocation.
process.executableURL = try await Self.swiftURL.value
executable = .path(try await Self.swiftURL.value)
#else
process.executableURL = try await ToolRegistry.locate("swift")
executable = .name("swift")
#endif
baseArguments = [tool]
}
@@ -79,11 +78,18 @@ public struct BuildSettings: Sendable {
"--configuration", configuration.rawValue,
]
var env = ProcessInfo.processInfo.environment
env.removeValue(forKey: "SDKROOT")
process.environment = env
process.arguments = baseArguments + extraArguments + sdkOptions + options + arguments
return process
var rawEnv = ProcessInfo.processInfo.environment
rawEnv.removeValue(forKey: "SDKROOT")
let env = Dictionary(uniqueKeysWithValues: rawEnv.map {
(Environment.Key(rawValue: $0)!, $1)
})
return Configuration(
executable,
arguments: .init(baseArguments + extraArguments + sdkOptions + options + arguments),
environment: .custom(env),
platformOptions: .withGracefulShutDown,
)
}
}
+8 -3
View File
@@ -1,5 +1,6 @@
import Foundation
import XUtils
import Subprocess
public struct Packer: Sendable {
public let buildSettings: BuildSettings
@@ -54,7 +55,7 @@ public struct Packer: Sendable {
try Data().write(to: sources.appendingPathComponent("stub.c", isDirectory: false))
}
let builder = try await buildSettings.swiftPMInvocation(
let buildConfig = try await buildSettings.swiftPMInvocation(
forTool: "build",
arguments: [
"--package-path", packageDir.path,
@@ -68,8 +69,12 @@ public struct Packer: Sendable {
"--disable-automatic-resolution",
]
)
builder.standardOutput = FileHandle.standardError
try await builder.runUntilExit()
try await Subprocess.run(
buildConfig,
output: .currentStandardError,
error: .currentStandardError,
)
.checkSuccess()
}
public func pack() async throws -> URL {
+9 -6
View File
@@ -1,5 +1,6 @@
import Foundation
import XUtils
import Subprocess
public struct Planner: Sendable {
public var buildSettings: BuildSettings
@@ -243,16 +244,18 @@ public struct Planner: Sendable {
}
private func _dumpAction(arguments: [String], path: String) async throws -> Data {
let dump = try await buildSettings.swiftPMInvocation(
let dumpConfig = try await buildSettings.swiftPMInvocation(
forTool: "package",
arguments: arguments,
packagePathOverride: path
)
let pipe = Pipe()
dump.standardOutput = pipe
async let task = Data(reading: pipe.fileHandleForReading)
try await dump.runUntilExit()
return try await task
return try await Subprocess.run(
dumpConfig,
output: .data(limit: .max),
error: .currentStandardError,
)
.checkSuccess()
.standardOutput
}
private func selectLibrary(
-63
View File
@@ -1,63 +0,0 @@
import Foundation
extension Process {
/// Launches the process and suspends until the receiver is finished.
///
/// - Parameter onCancel: The action to take if the current
/// task is cancelled.
public func runUntilExit(onCancel: TaskCancelAction = .interrupt) async throws {
try Task.checkCancellation()
let (terminationStream, terminationContinuation) = AsyncStream<Never>.makeStream()
terminationHandler = { _ in
terminationContinuation.finish()
}
do {
try run()
} catch {
terminationContinuation.finish()
throw error
}
await withTaskCancellationHandler {
for await _ in terminationStream {}
} onCancel: {
switch onCancel {
case .interrupt:
interrupt()
case .terminate:
terminate()
case .ignore:
break
}
}
try Task.checkCancellation()
switch terminationReason {
case .exit where terminationStatus == 0:
break
case .exit:
throw Failure.exit(terminationStatus)
case .uncaughtSignal:
throw Failure.uncaughtSignal(terminationStatus)
@unknown default:
break
}
}
public enum Failure: Error {
case exit(CInt)
case uncaughtSignal(CInt)
}
public enum TaskCancelAction: Sendable {
/// Sends `SIGINT` to the process.
case interrupt
/// Sends `SIGTERM` to the process.
case terminate
/// Don't participate in cooperative cancellation.
case ignore
}
}
+5 -19
View File
@@ -1,4 +1,5 @@
import Foundation
import Subprocess
package enum ToolRegistry {
package enum Errors: Error, CustomStringConvertible {
@@ -16,11 +17,6 @@ package enum ToolRegistry {
/// Obtain the full path to a tool in the user's `PATH`.
///
/// This effectively invokes `/bin/sh -c "command -v '$tool'"`.
///
/// - Warning: Make sure you trust/sanitize the `tool` parameter. If it
/// contains a single quote, it can be used in a shell escape.
///
/// - Throws: `Errors.toolNotFound` if the tool could not be located.
package static func locate(_ tool: String) async throws -> URL {
try await cache.locate(tool: tool)
@@ -30,20 +26,10 @@ package enum ToolRegistry {
private var cache: [String: Task<URL, Error>] = [:]
private func _locate(tool: String) async throws -> URL {
let pipe = Pipe()
let proc = Process()
proc.executableURL = URL(fileURLWithPath: "/bin/sh")
proc.arguments = ["-c", "command -v '\(tool)'"]
proc.standardOutput = pipe
async let bytes = pipe.fileHandleForReading.readToEnd()
do {
try await proc.runUntilExit()
} catch is Process.Failure {
throw Errors.toolNotFound(tool)
}
let path = String(decoding: try await bytes ?? Data(), as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
return URL(fileURLWithPath: path)
guard let path = try? await Executable.name(tool).resolveExecutablePath(in: .inherit),
let url = URL(filePath: path)
else { throw Errors.toolNotFound(tool) }
return url
}
func locate(tool: String) async throws -> URL {
@@ -138,3 +138,9 @@ extension WirelessAccessoryEntitlement: EntitlementWithCapability {
DeveloperServicesCapability(.wirelessAccessoryConfiguration, isFree: true)
}
}
extension WiFiAwareEntitlement: EntitlementWithCapability {
var capability: DeveloperServicesCapability {
DeveloperServicesCapability(rawName: "WIFI_AWARE", isFree: false)
}
}
@@ -3,6 +3,7 @@
import Foundation
import XADI
import Dependencies
import Subprocess
public actor XADIProvider: RawADIProvider {
@MainActor private static var loadTask: Task<Void, Error>?
@@ -45,17 +46,17 @@ public actor XADIProvider: RawADIProvider {
let archDir = "lib/\(arch)"
// TODO: Use ZIPFoundation
let proc = Process()
proc.executableURL = URL(filePath: "/usr/bin/env")
proc.arguments = [
"unzip", "-q",
applemusic.path(),
"\(archDir)/libCoreADI.so",
"\(archDir)/libstoreservicescore.so",
"-d", tmp.path()
]
try proc.run()
proc.waitUntilExit()
try await Subprocess.run(
.name("unzip"),
arguments: [
"-q",
applemusic.path,
"\(archDir)/libCoreADI.so",
"\(archDir)/libstoreservicescore.so",
"-d", tmp.path
],
output: .discarded
).checkSuccess()
try FileManager.default.moveItem(
at: tmp.appending(path: archDir),
to: libDir
@@ -26,6 +26,7 @@ extension EntitlementContainer {
SiriKitEntitlement.self,
InterAppAudioEntitlement.self,
WirelessAccessoryEntitlement.self,
WiFiAwareEntitlement.self,
HomeKitEntitlement.self,
HealthKitEntitlement.self,
]
@@ -155,6 +156,21 @@ public struct WirelessAccessoryEntitlement: Entitlement, RawRepresentable {
public init(rawValue: Bool) { self.rawValue = rawValue }
}
public struct WiFiAwareEntitlement: Entitlement, RawRepresentable {
public static let identifier = "com.apple.developer.wifi-aware"
public var rawValue: [String]
public init(rawValue: [String]) { self.rawValue = rawValue }
public init(from decoder: Decoder) throws {
rawValue = try decoder.singleValueContainer().decode([String].self)
}
public func encode(to encoder: Encoder) throws {
var container = encoder.singleValueContainer()
try container.encode(rawValue)
}
}
public struct HomeKitEntitlement: Entitlement, RawRepresentable {
public static let identifier = "com.apple.developer.homekit"
+1 -1
View File
@@ -1,6 +1,6 @@
import Foundation
import XKit
import SystemPackage
import XUtils
import NIOPosix
import NIOCore
+8 -4
View File
@@ -282,6 +282,8 @@ struct DevCommand: AsyncParsableCommand {
extension BuildConfiguration: ExpressibleByArgument {}
#if os(macOS)
import Subprocess
struct SimInstallOperation {
var path: URL
@@ -289,10 +291,12 @@ struct SimInstallOperation {
var simulator = "booted"
func run() async throws {
let process = Process()
process.executableURL = URL(fileURLWithPath: "/usr/bin/xcrun")
process.arguments = ["simctl", "install", simulator, path.path]
try await process.runUntilExit()
try await Subprocess.run(
.path("/usr/bin/xcrun"),
arguments: ["simctl", "install", simulator, path.path],
output: .discarded
)
.checkSuccess()
print("Installed to simulator")
}
}
@@ -2,6 +2,8 @@ import Foundation
import XKit
import Dependencies
import PackLib
import Subprocess
import XUtils
extension ZIPCompressor: DependencyKey {
// TODO: Use `powershell Compress-Archive` and `powershell Expand-Archive` on Windows
@@ -12,20 +14,23 @@ extension ZIPCompressor: DependencyKey {
let dest = dir.deletingLastPathComponent().appendingPathComponent("app.ipa")
let zip = Process()
zip.executableURL = try await ToolRegistry.locate("zip")
zip.currentDirectoryURL = dir.deletingLastPathComponent()
zip.arguments = ["-yqru0", dest.path, dir.lastPathComponent]
try await zip.runUntilExit()
try await Subprocess.run(
.name("zip"),
arguments: ["-yqru0", dest.path, dir.lastPathComponent],
workingDirectory: FilePath(dir.deletingLastPathComponent()),
output: .discarded,
).checkSuccess()
return dest
},
decompress: { ipa, directory, progress in
progress(nil)
let unzip = Process()
unzip.executableURL = try await ToolRegistry.locate("unzip")
unzip.arguments = ["-q", ipa.path, "-d", directory.path]
try await unzip.runUntilExit()
try await Subprocess.run(
.name("unzip"),
arguments: ["-q", ipa.path, "-d", directory.path],
output: .discarded,
).checkSuccess()
}
)
}
+23 -20
View File
@@ -1,9 +1,9 @@
import Foundation
import Dependencies
import SystemPackage
import libunxip
import Subprocess
import XKit // HTTPClient, stdoutSafe
import PackLib // ToolRegistry
import XUtils // System.File{Path,Descriptor}
struct SDKBuilder {
enum Arch: String {
@@ -180,14 +180,6 @@ struct SDKBuilder {
withIntermediateDirectories: false
)
let pipe = Pipe()
let untar = Process()
untar.currentDirectoryURL = toolsetDir
untar.executableURL = try await ToolRegistry.locate("tar")
untar.arguments = ["xzf", "-"]
untar.standardInput = pipe.fileHandleForReading
async let tarExit: Void = untar.runUntilExit()
@Dependency(\.httpClient) var httpClient
let url = URL(string: """
https://github.com/xtool-org/darwin-tools-linux-llvm/releases/download/\
@@ -199,22 +191,33 @@ struct SDKBuilder {
case .known(let known): known
case .unknown: nil
}
let writer = pipe.fileHandleForWriting
var written: Int64 = 0
do {
defer { try? writer.close() }
defer { print() }
try await Subprocess.run(
.name("tar"),
arguments: ["xzf", "-"],
workingDirectory: FilePath(toolsetDir),
input: .inputWriter,
output: .discarded,
error: .discarded,
) { execution in
var totalWritten: Int64 = 0
for try await chunk in body {
try writer.write(contentsOf: chunk)
written += Int64(chunk.count)
if let length {
let progress = Int(Double(written) / Double(length) * 100)
var remaining = chunk
while !remaining.isEmpty {
let written = try await execution.standardInputWriter.write(Array(remaining))
remaining = remaining.dropFirst(written)
totalWritten += Int64(written)
guard let length else { continue }
let progress = Int(Double(totalWritten) / Double(length) * 100)
print("\r[Downloading toolset] \(progress)%", terminator: "")
fflush(stdoutSafe)
}
}
try await execution.standardInputWriter.finish()
}
print()
try await tarExit
.checkSuccess()
}
// swiftlint:disable:next cyclomatic_complexity function_body_length
+35 -47
View File
@@ -5,6 +5,7 @@ import ArgumentParser
import Dependencies
import PackLib
import XUtils
import Subprocess
struct SDKCommand: AsyncParsableCommand {
static let configuration = CommandConfiguration(
@@ -151,50 +152,40 @@ struct DarwinSDK {
try await addHostClangResourceDir(to: url)
let process = Process()
process.executableURL = try await ToolRegistry.locate("swift")
process.arguments = ["sdk", "install", url.path]
try await process.runUntilExit()
try await Subprocess.run(
.name("swift"),
arguments: ["sdk", "install", url.path],
output: .discarded
)
.checkSuccess()
}
private static func addHostClangResourceDir(to sdk: URL) async throws {
let outPipe = Pipe()
let clang = Process()
clang.executableURL = try await ToolRegistry.locate("clang")
clang.arguments = ["-print-resource-dir"]
clang.standardOutput = outPipe
clang.standardError = FileHandle.standardError
async let outputData = Data(reading: outPipe.fileHandleForReading)
do {
try await clang.runUntilExit()
} catch is Process.Failure {
throw Console.Error("Failed to query host clang -print-resource-dir")
}
let path = String(decoding: try await outputData, as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
guard !path.isEmpty else {
throw Console.Error("Host clang returned an empty resource directory")
}
let hostClangResources = URL(fileURLWithPath: path, isDirectory: true)
let clangURL = try await ToolRegistry.locate("clang")
let process = try await Subprocess.run(
.path(FilePath(clangURL.path)),
arguments: ["-print-resource-dir"],
output: .string(limit: .max)
).checkSuccess()
let output = process.standardOutput ?? ""
let hostClangResources = URL(filePath: output.trimmingCharacters(in: .whitespacesAndNewlines))
let hostInclude = hostClangResources.appending(path: "include")
let sdkInclude = sdk.appending(path: "Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/clang/include")
try FileManager.default.copyItem(at: hostInclude, to: sdkInclude)
}
static func current() async throws -> DarwinSDK? {
let output = Pipe()
let process = Process()
process.executableURL = try await ToolRegistry.locate("swift")
process.arguments = ["sdk", "configure", "darwin", "arm64-apple-ios", "--show-configuration"]
process.standardOutput = output
process.standardError = FileHandle.nullDevice
async let outputData = Data(reading: output.fileHandleForReading)
let outputString: String
do {
try await process.runUntilExit()
} catch Process.Failure.exit {
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
}
@@ -202,7 +193,6 @@ struct DarwinSDK {
// swiftResourcesPath: /home/user/.swiftpm/swift-sdks/darwin.artifactbundle/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift
// swiftlint:disable:previous line_length
let resourcesPathPrefix = "swiftResourcesPath: "
let outputString = String(decoding: try await outputData, as: UTF8.self)
guard let resourcesPath = outputString
.split(separator: "\n")
@@ -230,21 +220,19 @@ struct DarwinSDK {
private enum SwiftVersion {}
extension SwiftVersion {
static func current() async throws -> Version {
let outPipe = Pipe()
let errPipe = Pipe()
let swift = Process()
swift.executableURL = try await ToolRegistry.locate("swift")
swift.arguments = ["--version"]
swift.standardOutput = outPipe
swift.standardError = errPipe
async let outputTask = outPipe.fileHandleForReading.readToEnd()
let outputString: String?
do {
try await swift.runUntilExit()
} catch is Process.Failure {
outputString = try await Subprocess.run(
.name("swift"),
arguments: ["--version"],
output: .string(limit: .max)
)
.checkSuccess()
.standardOutput
} catch {
throw Console.Error("Failed to obtain Swift version")
}
let outputData = try await outputTask
var output = String(decoding: outputData ?? Data(), as: UTF8.self)[...]
var output = outputString?[...] ?? ""
if output.hasPrefix("Apple ") {
output = output.dropFirst("Apple ".count)
}
+57
View File
@@ -0,0 +1,57 @@
#if canImport(Subprocess)
import Subprocess
import Foundation
extension ExecutionResult {
@discardableResult
public func checkSuccess() throws(SubprocessFailure) -> Self {
try terminationStatus.checkSuccess()
return self
}
}
extension TerminationStatus {
fileprivate func checkSuccess() throws(SubprocessFailure) {
if let failure { throw failure }
}
private var failure: SubprocessFailure? {
if isSuccess { return nil }
switch self {
case .exited(let code): return .exited(code)
case .signaled(let code): return .signaled(code)
}
}
}
public enum SubprocessFailure: Error {
case exited(TerminationStatus.Code)
case signaled(TerminationStatus.Code)
}
extension PlatformOptions {
public static var withGracefulShutDown: Self {
.init().withGracefulShutDown
}
public var withGracefulShutDown: Self {
var copy = self
copy.teardownSequence = [
.gracefulShutDown(
allowedDurationToNextStep: .milliseconds(500)
)
]
return copy
}
}
extension Environment {
public static func currentMap() -> [Environment.Key: String] {
Dictionary(
uniqueKeysWithValues: ProcessInfo.processInfo.environment.map {
(Environment.Key(rawValue: $0)!, $1)
}
)
}
}
#endif
+53
View File
@@ -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)
}
}
+92 -14
View File
@@ -4,6 +4,7 @@ package struct TemporaryDirectory: ~Copyable {
private static let debugTmp = ProcessInfo.processInfo.environment["XTL_DEBUG_TMP"] != nil
private var shouldDelete: Bool
private let base: URL
package 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 = base
self.shouldDelete = false
throw 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 up
shouldDelete = 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)'"
}
}
}
@@ -0,0 +1,39 @@
import Foundation
import Testing
@testable import XKit
@Test func wifiAwareEntitlementMapsToDeveloperCapability() throws {
let plist = """
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>com.apple.developer.wifi-aware</key>
<array>
<string>Publish</string>
<string>Subscribe</string>
</array>
</dict>
</plist>
"""
let entitlements = try PropertyListDecoder().decode(
Entitlements.self,
from: Data(plist.utf8)
)
let wifiAware = try #require(
entitlements.entitlements().compactMap { $0 as? WiFiAwareEntitlement }.first
)
#expect(wifiAware.rawValue == ["Publish", "Subscribe"])
#expect(wifiAware.capability.capabilityType.value1 == nil)
#expect(wifiAware.capability.capabilityType.value2 == "WIFI_AWARE")
#expect(wifiAware.capability.settings == nil)
#expect(!wifiAware.capability.isFree)
let encoded = try PropertyListEncoder().encode(entitlements)
let dictionary = try #require(
PropertyListSerialization.propertyList(from: encoded, format: nil) as? [String: Any]
)
#expect(dictionary[WiFiAwareEntitlement.identifier] as? [String] == ["Publish", "Subscribe"])
}
+2 -2
View File
@@ -2,8 +2,10 @@ services:
xtool:
build:
context: .
target: dev
volumes:
- .:/xtool
- .build/linux:/xtool/.build
container_name: xtool
stdin_open: true
tty: true
@@ -13,6 +15,4 @@ services:
- seccomp:unconfined
extra_hosts:
# host.docker.internal doesn't exist by default on Linux hosts
# TODO: Does this conflict with the default host on macOS?
# we could rename this
- "host.docker.internal:host-gateway"