SPB Git

Repository Public

ProcessExecution.swift 6.3 KB 211 lines swift

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
Files main
Menu

Theme