Repository Public
1import Foundation23/// Result of a finished subprocess.4package struct ProcessOutput: Sendable {5 package var exitStatus: Int326 package var standardOutput: Data7 package var standardError: Data8 /// `true` when stdout exceeded the cap; the process was killed and stdout cut at the cap.9 package var outputTruncated: Bool10 /// `true` when the process was killed because it exceeded its timeout.11 package var timedOut: Bool12}1314package enum ProcessRunError: Error, Sendable, Equatable {15 case launchFailed(String)16}1718private final class PipeBox: @unchecked Sendable {19 let pipe = Pipe()20 var readDescriptor: Int32 { pipe.fileHandleForReading.fileDescriptor }21}2223private final class RunState: @unchecked Sendable {24 private let lock = NSLock()25 private let cap: Int26 private var pid: pid_t = 027 private var out = Data()28 private var err = Data()29 private var truncated = false30 private var timedOut = false31 private var cancelled = false3233 init(cap: Int) { self.cap = cap }3435 func setPID(_ newValue: pid_t) {36 lock.lock()37 pid = newValue38 let alreadyCancelled = cancelled39 lock.unlock()40 if alreadyCancelled { send(SIGKILL) }41 }4243 func clearPID() {44 lock.lock()45 pid = 046 lock.unlock()47 }4849 /// Signals the child only while it is known to be alive (no PID reuse hazard).50 func send(_ signalNumber: Int32) {51 lock.lock()52 if pid > 0 { kill(pid, signalNumber) }53 lock.unlock()54 }5556 func cancel() {57 lock.lock()58 cancelled = true59 lock.unlock()60 send(SIGKILL)61 }6263 func markTimedOut() {64 lock.lock()65 if pid > 0 { timedOut = true }66 lock.unlock()67 }6869 var isCancelled: Bool {70 lock.lock()71 defer { lock.unlock() }72 return cancelled73 }7475 /// Returns `false` once stdout has overflowed the cap.76 func append(_ chunk: Data, toStandardOutput: Bool) -> Bool {77 lock.lock()78 defer { lock.unlock() }79 if toStandardOutput {80 let room = cap - out.count81 if chunk.count > room {82 if room > 0 { out.append(chunk.prefix(room)) }83 truncated = true84 return false85 }86 out.append(chunk)87 } else {88 let room = cap - err.count89 if room > 0 { err.append(chunk.prefix(room)) }90 }91 return true92 }9394 func output(exitStatus: Int32) -> ProcessOutput {95 lock.lock()96 defer { lock.unlock() }97 return ProcessOutput(98 exitStatus: exitStatus,99 standardOutput: out,100 standardError: err,101 outputTruncated: truncated,102 timedOut: timedOut103 )104 }105}106107private func drain(_ box: PipeBox, into state: RunState, isStandardOutput: Bool) {108 let descriptor = box.readDescriptor109 var buffer = [UInt8](repeating: 0, count: 64 * 1024)110 while true {111 let count = buffer.withUnsafeMutableBytes { read(descriptor, $0.baseAddress, $0.count) }112 if count > 0 {113 let accepted = state.append(Data(buffer[0..<count]), toStandardOutput: isStandardOutput)114 if !accepted { state.send(SIGKILL) }115 } else if count < 0 && errno == EINTR {116 continue117 } else {118 break119 }120 }121}122123private func runSynchronously(124 executable: URL,125 arguments: [String],126 environment: [String: String]?,127 currentDirectory: URL?,128 timeoutSeconds: Double,129 state: RunState130) throws -> ProcessOutput {131 if state.isCancelled { throw CancellationError() }132133 let process = Process()134 process.executableURL = executable135 process.arguments = arguments136 if let environment { process.environment = environment }137 if let currentDirectory { process.currentDirectoryURL = currentDirectory }138 let outBox = PipeBox()139 let errBox = PipeBox()140 process.standardInput = FileHandle.nullDevice141 process.standardOutput = outBox.pipe142 process.standardError = errBox.pipe143144 do {145 try process.run()146 } catch {147 throw ProcessRunError.launchFailed(error.localizedDescription)148 }149 state.setPID(process.processIdentifier)150151 let readers = DispatchGroup()152 for (box, isOut) in [(outBox, true), (errBox, false)] {153 readers.enter()154 DispatchQueue.global(qos: .userInitiated).async {155 drain(box, into: state, isStandardOutput: isOut)156 readers.leave()157 }158 }159160 let deadline = DispatchWorkItem {161 state.markTimedOut()162 state.send(SIGTERM)163 DispatchQueue.global().asyncAfter(deadline: .now() + 1) { state.send(SIGKILL) }164 }165 DispatchQueue.global().asyncAfter(deadline: .now() + timeoutSeconds, execute: deadline)166167 process.waitUntilExit()168 deadline.cancel()169 state.clearPID()170 // A grandchild may keep the pipe open; do not wait for it forever.171 _ = readers.wait(timeout: .now() + 2)172173 if state.isCancelled { throw CancellationError() }174 return state.output(exitStatus: process.terminationStatus)175}176177/// Runs an executable with an explicit argv (no shell), a timeout and a cap on captured output.178package func runProcess(179 executable: URL,180 arguments: [String],181 environment: [String: String]? = nil,182 currentDirectory: URL? = nil,183 timeout: Duration,184 maxOutputBytes: Int185) async throws -> ProcessOutput {186 let state = RunState(cap: max(0, maxOutputBytes))187 let components = timeout.components188 let seconds = max(0.01, Double(components.seconds) + Double(components.attoseconds) / 1e18)189 return try await withTaskCancellationHandler {190 try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<ProcessOutput, any Error>) in191 DispatchQueue.global(qos: .userInitiated).async {192 do {193 let output = try runSynchronously(194 executable: executable,195 arguments: arguments,196 environment: environment,197 currentDirectory: currentDirectory,198 timeoutSeconds: seconds,199 state: state200 )201 continuation.resume(returning: output)202 } catch {203 continuation.resume(throwing: error)204 }205 }206 }207 } onCancel: {208 state.cancel()209 }210}211