forked from PerfectlySoft/Perfect
-
Notifications
You must be signed in to change notification settings - Fork 0
/
SysProcess.swift
192 lines (160 loc) · 5.79 KB
/
SysProcess.swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
//
// SysProcess.swift
// PerfectLib
//
// Created by Kyle Jessup on 7/20/15.
// Copyright (C) 2015 PerfectlySoft, Inc.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version, as supplemented by the
// Perfect Additional Terms.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License, as supplemented by the
// Perfect Additional Terms, for more details.
//
// You should have received a copy of the GNU Affero General Public License
// and the Perfect Additional Terms that immediately follow the terms and
// conditions of the GNU Affero General Public License along with this
// program. If not, see <http://www.perfect.org/AGPL_3_0_With_Perfect_Additional_Terms.txt>.
//
import Darwin
/// This class permits an external process to be launched given a set of command line arguments and environment variables.
/// The standard in, out and err file streams are made available. The process can be terminated or permitted to be run to completion.
public class SysProcess : Closeable {
/// The standard in file stream.
public var stdin: File?
/// The standard out file stream.
public var stdout: File?
/// The standard err file stream.
public var stderr: File?
/// The process identifier.
public var pid = pid_t(-1)
/// Initialize the object and launch the process.
/// - parameter cmd: The path to the process which will be launched.
/// - parameter args: An optional array of String arguments which will be given to the process.
/// - parameter env: An optional array of environment variable name and value pairs.
/// - throws: `LassoError.SystemError`
public init(_ cmd: String, args: [String]?, env: [(String,String)]?) throws {
let cArgsCount = args != nil ? args!.count : 0
let cArgs = UnsafeMutablePointer<UnsafeMutablePointer<CChar>>.alloc(cArgsCount + 2)
defer { cArgs.destroy() ; cArgs.dealloc(cArgsCount + 2) }
cArgs[0] = strdup(cmd)
cArgs[cArgsCount + 1] = UnsafeMutablePointer<CChar>(())
var idx = 0
for (; idx < cArgsCount; ++idx) {
cArgs[idx+1] = strdup(args![idx])
}
let cEnvCount = env != nil ? env!.count : 0
let cEnv = UnsafeMutablePointer<UnsafeMutablePointer<CChar>>.alloc(cEnvCount + 1)
defer { cEnv.destroy() ; cEnv.dealloc(cEnvCount + 1) }
cEnv[cEnvCount] = UnsafeMutablePointer<CChar>(())
idx = 0
for (; idx < cEnvCount; ++idx) {
cEnv[idx] = strdup(env![idx].0 + "=" + env![idx].1)
}
let fSTDIN = UnsafeMutablePointer<Int32>.alloc(2)
let fSTDOUT = UnsafeMutablePointer<Int32>.alloc(2)
let fSTDERR = UnsafeMutablePointer<Int32>.alloc(2)
defer {
fSTDIN.destroy() ; fSTDIN.dealloc(2)
fSTDOUT.destroy() ; fSTDOUT.dealloc(2)
fSTDERR.destroy() ; fSTDERR.dealloc(2)
}
Darwin.pipe(fSTDIN)
Darwin.pipe(fSTDOUT)
Darwin.pipe(fSTDERR)
var action = posix_spawn_file_actions_t()
posix_spawn_file_actions_init(&action);
posix_spawn_file_actions_adddup2(&action, fSTDOUT[1], STDOUT_FILENO);
posix_spawn_file_actions_adddup2(&action, fSTDIN[0], STDIN_FILENO);
posix_spawn_file_actions_adddup2(&action, fSTDERR[1], STDERR_FILENO);
posix_spawn_file_actions_addclose(&action, fSTDOUT[0]);
posix_spawn_file_actions_addclose(&action, fSTDIN[0]);
posix_spawn_file_actions_addclose(&action, fSTDERR[0]);
posix_spawn_file_actions_addclose(&action, fSTDOUT[1]);
posix_spawn_file_actions_addclose(&action, fSTDIN[1]);
posix_spawn_file_actions_addclose(&action, fSTDERR[1]);
var procPid = pid_t()
let spawnRes = Darwin.posix_spawnp(&procPid, cmd, &action, UnsafeMutablePointer<posix_spawnattr_t>(()), cArgs, cEnv)
posix_spawn_file_actions_destroy(&action)
idx = 0
for (; idx < cArgsCount; ++idx) {
free(cArgs[idx])
}
idx = 0
for (; idx < cEnvCount; ++idx) {
free(cEnv[idx])
}
Darwin.close(fSTDIN[0])
Darwin.close(fSTDOUT[1])
Darwin.close(fSTDERR[1])
if spawnRes != 0 {
Darwin.close(fSTDIN[1])
Darwin.close(fSTDOUT[0])
Darwin.close(fSTDERR[0])
try ThrowSystemError()
}
self.pid = procPid
self.stdin = File(fd: fSTDIN[1], path: "")
self.stdout = File(fd: fSTDOUT[0], path: "")
self.stderr = File(fd: fSTDERR[0], path: "")
}
deinit {
self.close()
}
/// Returns true if the process was opened and was running at some point.
/// Note that the process may not be currently running. Use `wait(false)` to check if the process is currently running.
public func isOpen() -> Bool {
return self.pid != -1
}
/// Terminate the process and clean up.
public func close() {
if self.stdin != nil {
self.stdin!.close()
}
if self.stdout != nil {
self.stdout!.close()
}
if self.stderr != nil {
self.stderr!.close()
}
if self.pid != -1 {
do {
try self.kill()
} catch {
}
}
self.stdin = nil
self.stdout = nil
self.stderr = nil
self.pid = -1
}
/// Detach from the process such that it will not be manually terminated when this object is deinitialized.
public func detach() {
self.pid = -1
}
/// Determine if the process has completed running and retrieve its result code.
public func wait(hang: Bool = true) throws -> Int32 {
var code = Int32(0)
let status = Darwin.waitpid(self.pid, &code, WUNTRACED | (hang ? 0 : WNOHANG))
if status == -1 {
try ThrowSystemError()
}
self.pid = -1
close()
return code
}
/// Terminate the process and return its result code.
public func kill(signal: Int32 = SIGTERM) throws -> Int32 {
let status = Darwin.kill(self.pid, signal)
guard status != -1 else {
try ThrowSystemError()
}
return try self.wait()
}
}