CommandLineToolkit

1
import Foundation
2
import ProcessController
3
import SynchronousWaiter
4

5
public final class FakeProcessController: ProcessController {
6
    public var subprocess: Subprocess
7

8
    public init(subprocess: Subprocess, processStatus: ProcessStatus = .notStarted) {
9
        self.subprocess = subprocess
10
        self.overridedProcessStatus = processStatus
11
    }
12
    
13
    public var processName: String {
14
        do {
15
            return try subprocess.arguments[0].stringValue()
16
        } catch {
17
            return "Error getting processName: \(error)"
18
        }
19
    }
20
    
21
    public var processId: Int32 {
22
        return 0
23
    }
24
    
25
    public func start() {
26
        for listener in startListeners {
27
            listener(self, {})
28
        }
29
    }
30
    
31
    public func waitForProcessToDie() {
32
        try? SynchronousWaiter().waitWhile { isProcessRunning }
33
    }
34

35
    public func waitForProcessToDieAsync() async {
36
        await withCheckedContinuation { continuation in
37
            try? SynchronousWaiter().waitWhile { isProcessRunning }
38
            continuation.resume()
39
        }
40
    }
41

42
    public var overridedProcessStatus: ProcessStatus = .notStarted
43
    
44
    public func processStatus() -> ProcessStatus {
45
        return overridedProcessStatus
46
    }
47
    
48
    public var signalsSent = [Int32]()
49
    
50
    public func send(signal: Int32) {
51
        signalsSent.append(signal)
52
        broadcastSignal(signal)
53
    }
54
    
55
    public func signalAndForceKillIfNeeded(
56
        terminationSignal: Int32,
57
        terminationSignalTimeout: TimeInterval,
58
        onKill: @escaping () -> ()
59
    ) {
60
        send(signal: terminationSignal)
61
        invokeTerminationProcedures(exitCode: terminationSignal)
62
        onKill()
63
    }
64
    
65
    public func invokeTerminationProcedures(
66
        exitCode: Int32 = 0
67
    ) {
68
        overridedProcessStatus = .terminated(exitCode: exitCode)
69
        broadcastTermination()
70
    }
71
    
72
    public var startListeners = [StartListener]()
73
    
74
    public func onStart(listener: @escaping StartListener) {
75
        startListeners.append(listener)
76
    }
77
    
78
    // Stdout
79
    
80
    public var stdoutListeners = [StdoutListener]()
81
    
82
    public func onStdout(listener: @escaping StdoutListener) {
83
        stdoutListeners.append(listener)
84
    }
85
    
86
    public func broadcastStdout(data: Data) {
87
        stdoutListeners.forEach { $0(self, data, { }) }
88
    }
89
    
90
    // Stderr
91
    
92
    public var stderrListeners = [StdoutListener]()
93
    
94
    public func onStderr(listener: @escaping StderrListener) {
95
        stderrListeners.append(listener)
96
    }
97
    
98
    public func broadcastStderr(data: Data) {
99
        stderrListeners.forEach { $0(self, data, { }) }
100
    }
101
    
102
    // Signalling
103
    
104
    public var signalListeners = [SignalListener]()
105
    
106
    public func onSignal(listener: @escaping SignalListener) {
107
        signalListeners.append(listener)
108
    }
109
    
110
    public func broadcastSignal(_ signal: Int32) {
111
        signalListeners.forEach { $0(self, signal, { }) }
112
    }
113
    
114
    // Termination
115
    
116
    public var terminationListeners = [TerminationListener]()
117
    
118
    public func onTermination(listener: @escaping TerminationListener) {
119
        terminationListeners.append(listener)
120
    }
121
    
122
    public func broadcastTermination() {
123
        terminationListeners.forEach { $0(self, { }) }
124
    }
125
}
126